caching fix

dhfs-parent/objects/src/main/java/com/usatiuk/dhfs/objects/MappingKvIterator.java

@@ -0,0 +1,37 @@
+package com.usatiuk.dhfs.objects;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.function.Function;
+
+public class MappingKvIterator<K extends Comparable<K>, V, V_T> implements CloseableKvIterator<K, V_T> {
+    private final CloseableKvIterator<K, V> _backing;
+    private final Function<V, V_T> _transformer;
+
+    public MappingKvIterator(CloseableKvIterator<K, V> backing, Function<V, V_T> transformer) {
+        _backing = backing;
+        _transformer = transformer;
+    }
+
+    @Override
+    public K peekNextKey() {
+        return _backing.peekNextKey();
+    }
+
+    @Override
+    public void close() {
+        _backing.close();
+    }
+
+    @Override
+    public boolean hasNext() {
+        return _backing.hasNext();
+    }
+
+    @Override
+    public Pair<K, V_T> next() {
+        var got = _backing.next();
+        return Pair.of(got.getKey(), _transformer.apply(got.getValue()));
+    }
+
+}

dhfs-parent/objects/src/main/java/com/usatiuk/dhfs/objects/TxWritebackImpl.java

@@ -380,7 +380,7 @@ public class TxWritebackImpl implements TxWriteback {
     // Does not have to guarantee consistent view, snapshots are handled by upper layers
     @Override
     public CloseableKvIterator<JObjectKey, TombstoneMergingKvIterator.DataType<JDataVersionedWrapper>> getIterator(IteratorStart start, JObjectKey key) {
-        return new PredicateKvIterator<>(
+        return new MappingKvIterator<>(
                 new NavigableMapKvIterator<>(_pendingWrites, start, key),
                 e -> switch (e) {
                     case PendingWrite p -> new TombstoneMergingKvIterator.Data<>(p.data());

dhfs-parent/objects/src/main/java/com/usatiuk/dhfs/objects/WritebackObjectPersistentStore.java

@@ -98,7 +98,7 @@ public class WritebackObjectPersistentStore {
     // Does not have to guarantee consistent view, snapshots are handled by upper layers
     public CloseableKvIterator<JObjectKey, TombstoneMergingKvIterator.DataType<JDataVersionedWrapper>> getIterator(IteratorStart start, JObjectKey key) {
         return new MergingKvIterator<>(txWriteback.getIterator(start, key),
-                new PredicateKvIterator<>(delegate.getIterator(start, key), TombstoneMergingKvIterator.Data::new));
+                new MappingKvIterator<>(delegate.getIterator(start, key), TombstoneMergingKvIterator.Data::new));
     }
 
     public CloseableKvIterator<JObjectKey, TombstoneMergingKvIterator.DataType<JDataVersionedWrapper>> getIterator(JObjectKey key) {

dhfs-parent/objects/src/main/java/com/usatiuk/dhfs/objects/persistence/CachingObjectPersistentStore.java

@@ -59,6 +59,7 @@ public class CachingObjectPersistentStore {
     }
 
     private void put(JObjectKey key, Optional<JDataVersionedWrapper> obj) {
+//        Log.tracev("Adding {0} to cache: {1}", key, obj);
         synchronized (_cache) {
             int size = obj.map(o -> o.data().estimateSize()).orElse(0);
 
@@ -103,11 +104,43 @@ public class CachingObjectPersistentStore {
                 _curSize -= Optional.ofNullable(_cache.get(key)).map(CacheEntry::size).orElse(0L);
                 _cache.remove(key);
                 _sortedCache.remove(key);
+//                Log.tracev("Removing {0} from cache", key);
             }
         }
         delegate.commitTx(names);
     }
 
+
+    private class CachingKvIterator implements CloseableKvIterator<JObjectKey, JDataVersionedWrapper> {
+        private final CloseableKvIterator<JObjectKey, JDataVersionedWrapper> _delegate;
+
+        private CachingKvIterator(CloseableKvIterator<JObjectKey, JDataVersionedWrapper> delegate) {
+            _delegate = delegate;
+        }
+
+        @Override
+        public JObjectKey peekNextKey() {
+            return _delegate.peekNextKey();
+        }
+
+        @Override
+        public void close() {
+            _delegate.close();
+        }
+
+        @Override
+        public boolean hasNext() {
+            return _delegate.hasNext();
+        }
+
+        @Override
+        public Pair<JObjectKey, JDataVersionedWrapper> next() {
+            var next = _delegate.next();
+            put(next.getKey(), Optional.of(next.getValue()));
+            return next;
+        }
+    }
+
     // Returns an iterator with a view of all commited objects
     // Does not have to guarantee consistent view, snapshots are handled by upper layers
     public CloseableKvIterator<JObjectKey, JDataVersionedWrapper> getIterator(IteratorStart start, JObjectKey key) {
@@ -115,8 +148,7 @@ public class CachingObjectPersistentStore {
                 new PredicateKvIterator<>(
                         new NavigableMapKvIterator<>(_sortedCache, start, key),
                         e -> e.object().orElse(null)
-                ),
-                delegate.getIterator(start, key)); // TODO: Doesn't work
+                ), new CachingKvIterator(delegate.getIterator(start, key)));
     }
 
     public CloseableKvIterator<JObjectKey, JDataVersionedWrapper> getIterator(JObjectKey key) {