first test run with chunk cache.

Author: thsc42

src/net/sharksystem/aasp/AASPChunkCache.java

@@ -34,12 +34,11 @@ public interface AASPChunkCache {
 
     /**
      * 
-     * @param chronologically in chronological order: true: oldest message comes
      * first, false: newest message comes first
      * @return iterator of all messages in that chunk cache
      * @throws IOException 
      */
-    Iterator<CharSequence> getMessages(boolean chronologically) throws IOException;
+    Iterator<CharSequence> getMessages() throws IOException;
 
     /**
      * Returns a message with a given position

src/net/sharksystem/aasp/AASPChunkStorageFS.java

@@ -64,7 +64,6 @@ String getFullFileName(int era, String targetUrl) {
     /**
      * 
      * @param era
-     * @param fileName
      * @return full name (path/name) of that given url and target. Directories
      * are expected to be existent
      */
@@ -110,45 +109,10 @@ public boolean accept(File dir, String fileName) {
     @Override
     public void dropChunks(int era) throws IOException {
         // here comes a Java 6 compatible version - fits to android SDK 23
-        String eraPathName = this.rootDirectory + "/" + Integer.toString(era); 
-        File dir = new File(eraPathName);
-        
-        String[] dirEntries = dir.list();
-        
-        /*
-        Path dir = Paths.get(this.rootDirectory + "/" + Integer.toString(era));
-        
-        DirectoryStream<Path> entries = null;
-        try {
-            entries = Files.newDirectoryStream(dir);
-        }
-        catch(IOException ioe) {
-            // directory does not exist - ok, nothing to drop
-            return;
-        }
-        
-        for (Path path : entries) {
-            File file = path.toFile();
-            file.delete();
-        }
-*/
-        if(dirEntries != null) {
-            for(String fileName : dirEntries) {
-                File fileInDir = new File(eraPathName + "/" + fileName);
-                try {
-                    fileInDir.delete();
-                }
-                catch(RuntimeException e) {
-                    System.err.println("AASPStorageFS: cannot remove old file:" + e.getLocalizedMessage());
-                    // try next
-                }
-            }
-        }
-        
-        // finally remove directory itself
-//        dir.toFile().delete();
+        String eraPathName = this.rootDirectory + "/" + Integer.toString(era);
+
+        AASPEngineFS.removeFolder(eraPathName);
 
-        dir.delete();
     }
 
     String getRootPath() {

src/net/sharksystem/aasp/AASPEngineFS.java

@@ -98,4 +98,33 @@ public AASPChunkStorage getReceivedChunkStorage(CharSequence sender) {
         String dir = this.rootDirectory + "/" + sender;
         return new AASPChunkStorageFS(dir);
     }
+
+    ////////////////////////////////////////////////////////////////////////////////////////
+    //                                         helper                                     //
+    ////////////////////////////////////////////////////////////////////////////////////////
+
+    static void removeFolder(String eraPathName) {
+        File dir = new File(eraPathName);
+
+        String[] dirEntries = dir.list();
+
+        if(dirEntries != null) {
+            for(String fileName : dirEntries) {
+                File fileInDir = new File(eraPathName + "/" + fileName);
+                if(fileInDir.isDirectory()) {
+                    AASPEngineFS.removeFolder(fileInDir.getAbsolutePath());
+                } else {
+                    try {
+                        fileInDir.delete();
+                    } catch (RuntimeException e) {
+                        System.err.println("AASPEngineFS: cannot file:" + e.getLocalizedMessage());
+                        // try next
+                    }
+                }
+            }
+        }
+
+        dir.delete();
+    }
+
 }

src/net/sharksystem/aasp/AASPInMemoChunkCache.java

@@ -4,12 +4,14 @@
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+import java.util.NoSuchElementException;
 
 /**
  *
  * @author thsc
  */
 class AASPInMemoChunkCache implements AASPChunkCache {
+    public static final int DEFAULT_MAX_CACHE_SIZE = 1000;
     private final CharSequence uri;
     private final AASPChunkStorageFS chunkStorage;
     private final int fromEra;
@@ -21,19 +23,26 @@ class AASPInMemoChunkCache implements AASPChunkCache {
     private List<CharSequence> messageCache;
     private int firstIndexMessageCache = -1;
     private int lastIndexMessageCache = -1;
-    private int maxCacheLen = 1000;
+    private int maxCacheLen;
 
     private int numberOfMessages = 0;
 
-    public AASPInMemoChunkCache(AASPChunkStorageFS chunkStorage, 
-            CharSequence uri, int fromEra, int toEra) {
-        
+    public AASPInMemoChunkCache(AASPChunkStorageFS chunkStorage,
+                                CharSequence uri, int fromEra, int toEra, int maxCacheLen) {
+
         this.uri = uri;
         this.chunkStorage = chunkStorage;
         this.fromEra = fromEra;
         this.toEra = toEra;
+        this.maxCacheLen = maxCacheLen;
     }
-    
+
+    public AASPInMemoChunkCache(AASPChunkStorageFS chunkStorage,
+                                CharSequence uri, int fromEra, int toEra) {
+
+        this(chunkStorage, uri, fromEra, toEra, DEFAULT_MAX_CACHE_SIZE);
+    }
+
     private boolean initialized = false;
 
     private void initialize() throws IOException {
@@ -87,15 +96,10 @@ public CharSequence getURI() {
     }
 
     @Override
-    public Iterator<CharSequence> getMessages(boolean chronologically) throws IOException {
+    public Iterator<CharSequence> getMessages() throws IOException {
         this.initialize();
 
-        List<CharSequence> dummyList = new ArrayList<>();
-        
-        dummyList.add("dummy entry 1");
-        dummyList.add("dummy entry 2");
-        
-        return dummyList.iterator();
+        return new ChunkListMessageIterator(this.chunkList);
     }
 
     @Override
@@ -104,7 +108,7 @@ public CharSequence getMessage(int position, boolean chronologically)
 
         this.initialize();
 
-        if(position > this.numberOfMessages)
+        if(position >= this.numberOfMessages)
             throw new AASPException("Position exceeds number of message");
 
         if(!chronologically) {
@@ -125,14 +129,15 @@ public CharSequence getMessage(int position, boolean chronologically)
         int fittingChunkIndex = 0;
 
         for(AASPChunk chunk : this.chunkList) {
-            lastIndex = firstIndex + chunk.getNumberMessage();
+            lastIndex = firstIndex + chunk.getNumberMessage() - 1;
 
             if(position >= firstIndex && position <= lastIndex) {
                 // we have got our chunk
                 fittingChunk = chunk;
                 break;
             }
 
+            firstIndex += chunk.getNumberMessage();
             fittingChunkIndex++;
         }
 
@@ -145,8 +150,39 @@ public CharSequence getMessage(int position, boolean chronologically)
         // reset cache
         this.messageCache = new ArrayList<>();
 
+        /////////////////////////////////////////////////////////////////
         // simple approach in that first implementation ... we keep fitting chunk in memory
+        /////////////////////////////////////////////////////////////////
+
         Iterator<CharSequence> messages = fittingChunk.getMessages();
+
+        // chunk bigger than max cache size?
+        int chunkSize = fittingChunk.getNumberMessage();
+        if(chunkSize > this.maxCacheLen) {
+            // calculate how many messages to skip before caching
+
+            /*
+            situation:
+            chunk head |................position...........................| tail
+            cache head |................| tail
+
+            solution: put position in middle of the cache
+            chunk |................position...........................|
+            planned cache |........position........|
+            skipLen...|
+             */
+
+            int skipLen = position - (this.maxCacheLen / 2);
+
+            // first index in cache will be this one:
+            firstIndex += skipLen;
+
+            // skip
+            for(;skipLen > 0; skipLen--) {
+                this.messageCache.add(messages.next());
+            }
+        }
+
         this.firstIndexMessageCache = firstIndex;
 
         int counter = 0;
@@ -159,13 +195,83 @@ public CharSequence getMessage(int position, boolean chronologically)
         this.lastIndexMessageCache = this.firstIndexMessageCache + counter - 1;
 
         // cache filled - call again
-        return this.getMessage(position, chronologically);
+        /* not: it is always chronologically true!!
+        a) we already came in with true -> it remains true
+        b) we came with false -> we have already recalculated that position, we would
+        move it around again with that call - keep position unchanged: true!
+         */
+
+        return this.getMessage(position, true);
     }
 
     @Override
     public void add(CharSequence message) throws IOException {
         // TODO
         //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
     }
-}
 
+    private class ChunkListMessageIterator implements Iterator<CharSequence> {
+
+        private final List<AASPChunk> chunkList;
+        private AASPChunk currentChunk;
+        private int nextIndex;
+        private Iterator<CharSequence> currentIterator;
+        private CharSequence messageAhead;
+
+        public ChunkListMessageIterator(List<AASPChunk> chunkList) throws IOException {
+            this.chunkList = chunkList;
+            this.currentChunk = null;
+            this.nextIndex = 0;
+            this.messageAhead = null; // mark as empty
+            this.readAhead(); // init cache
+        }
+
+        /**
+         * read next message in field messageAhead.
+         */
+        private void readAhead() {
+            if (this.currentIterator != null) {
+                if (this.currentIterator.hasNext()) {
+                    // 'normal' case: we read next message
+                    this.messageAhead = this.currentIterator.next();
+                    return; // done
+                }
+            }
+            // no more messages in that iterator / chunk
+            if (this.chunkList == null || nextIndex >= this.chunkList.size() ) {
+                return; // there is no list at all or we are already through with it
+            }
+
+            // open next chunk / iterator
+            this.currentChunk = this.chunkList.get(this.nextIndex++);
+            try {
+                this.currentIterator = this.currentChunk.getMessages();
+                this.readAhead(); // next try
+            } catch (IOException e) {
+                // cannot recover from that problem
+                return;
+            }
+        }
+
+        @Override
+        public boolean hasNext() {
+            return this.messageAhead != null;
+        }
+
+        @Override
+        public CharSequence next() {
+            if(this.messageAhead == null) {
+                throw new NoSuchElementException("list empty or already reached end");
+            }
+
+            // remove that single message cache
+            CharSequence retMessage = this.messageAhead;
+            this.messageAhead = null;
+
+            // read ahead - if possible
+            this.readAhead();
+
+            return retMessage;
+        }
+    }
+}