asap cache / channel setup is much faster - check what era present instead of guessing.

Author: thsc42

src/net/sharksystem/Utils.java

@@ -1,5 +1,12 @@
 package net.sharksystem;
 
+import net.sharksystem.asap.ASAP;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+
 public class Utils {
     public static String url2FileName(String url) {
         // escape:
@@ -21,4 +28,60 @@ public static String url2FileName(String url) {
 
         return newString;
     }
+
+    /**
+     *
+     * @param rootFolder
+     * @return collection of integer values depicting era present in that folder
+     */
+    public static Collection<Integer> getErasInFolder(String rootFolder) {
+        Collection<Integer> eras = new HashSet<>();
+        File dir = new File(rootFolder);
+        String[] dirEntries = dir.list();
+        if (dirEntries != null) {
+            for (String fileName : dirEntries) {
+                // era folder?
+                try {
+                    int era = Integer.parseInt(fileName);
+                    // It is an era folder
+                    eras.add(era);
+                } catch (NumberFormatException e) {
+                    // no number - no problem - go ahead!
+                }
+            }
+        }
+        return eras;
+    }
+
+    /**
+     *
+     * @param searchSpace list of possible eras
+     * @param fromEra lowest era
+     * @param toEra highest era
+     * @return list of era which are within from and to and also in search space
+     */
+    public static Collection<Integer> getErasInRange(Collection<Integer> searchSpace,
+                                                     int fromEra, int toEra) {
+
+        Collection<Integer> eras = new ArrayList<>();
+
+        // the only trick is to be aware of the cyclic nature of era numbers
+        boolean wrapped = fromEra > toEra; // it reached the era end and started new
+
+        for(Integer era : searchSpace) {
+            if(!wrapped) {
+                //INIT ---- from-> +++++++++++++ <-to ----- MAX (+ fits)
+                if(era >= fromEra && era <= toEra) eras.add(era);
+            } else {
+                // INIT+++++++++<-to ------ from->++++++MAX
+                if(era <= toEra && era >= ASAP.INITIAL_ERA
+                    || era >= fromEra && era <= ASAP.MAX_ERA
+                ) eras.add(era);
+            }
+        }
+
+        return eras;
+
+    }
+
 }

src/net/sharksystem/asap/ASAPChunkStorageFS.java

@@ -128,21 +128,23 @@ public void dropChunks(int era) throws IOException {
 
     @Override
     public ASAPMessages getASAPChunkCache(CharSequence uri, int toEra) throws IOException {
+        // INIT ++++++++++++++++++++++ toEra +++++++++++++++++++++ MAX
+
+        int fromEra = ASAP.nextEra(toEra); // the whole cycle
+/*
         // go back 1000 eras
         int fromEra = toEra;
         for(int i = 0; i < 1000; i++) {
             fromEra = ASAP.previousEra(fromEra);
         }
-
+ */
         return this.getASAPChunkCache(uri, fromEra, toEra);
     }
 
     @Override
     public ASAPMessages getASAPChunkCache(CharSequence uri, int fromEra, int toEra) throws IOException {
         Log.writeLog(this, "create ASAPInMemoMessages");
 
-        Log.writeLogErr(this, "PLEASE: Implement a method getValidEra() which delivers set of all era which are present int that store - would increase performance!");
-
         return new ASAPInMemoMessages(
                 this,
                 this.getFormat(),

src/net/sharksystem/asap/ASAPInMemoMessages.java

@@ -1,13 +1,11 @@
 package net.sharksystem.asap;
 
+import net.sharksystem.Utils;
 import net.sharksystem.asap.apps.ASAPMessages;
 import net.sharksystem.asap.util.Log;
 
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.NoSuchElementException;
+import java.util.*;
 
 /**
  * @author thsc
@@ -40,9 +38,13 @@ public ASAPInMemoMessages(ASAPChunkStorageFS chunkStorage,
         this.toEra = toEra;
         this.maxCacheLen = maxCacheLen;
 
-        Log.writeLog(this, "format: " + format + " | uri: " + uri
+        Log.writeLog(this, this.toString());
+    }
+
+    public String toString() {
+        return "format: " + format + " | uri: " + uri
                 + " | rootDir: " + chunkStorage.getRootDirectory()
-                + " | fromEra: " + fromEra+ " | toEra: " + toEra);
+                + " | fromEra: " + fromEra+ " | toEra: " + toEra;
     }
 
     public ASAPInMemoMessages(ASAPChunkStorageFS chunkStorage,
@@ -59,31 +61,42 @@ private void initialize() throws IOException {
             this.initialized = true;
         }
     }
-    
+
     private void syncChunkList() throws IOException {
         // get all chunks in chronological order
-        
+        Collection<Integer> erasInFolder = Utils.getErasInFolder(this.chunkStorage.getRootDirectory());
+        if(erasInFolder.isEmpty()) return;
+
+        Collection<Integer> erasToUse = Utils.getErasInRange(erasInFolder, this.fromEra, this.toEra);
+        if(erasToUse.isEmpty()) return;
+
+        /*
         // current era in following loop
         int thisEra = this.fromEra;
-        
+
         // do we need more than one loop?
         boolean anotherLoop = this.fromEra != this.toEra;
         
         // are we in the final loop?
         boolean finalLoop = !anotherLoop;
+         */
 
         // drop old vunk list - if any
         this.chunkList = new ArrayList<>();
 
-        do {
+//        do {
+        for(Integer thisEra : erasToUse) {
             // check if chunk exists - don't create on
-            if(this.chunkStorage.existsChunk(this.uri, thisEra)) {
+            Log.writeLog(this, "reached era: " + thisEra);
+            if (erasInFolder.contains(thisEra) && this.chunkStorage.existsChunk(this.uri, thisEra)) {
                 // is there - get it
+                Log.writeLog(this, "getChunk with era: " + thisEra);
                 ASAPChunk chunk = this.chunkStorage.getChunk(this.uri, thisEra);
                 this.chunkList.add(chunk);
                 this.numberOfMessages += chunk.getNumberMessage();
             }
 
+            /*
             if (anotherLoop) {
                 if (finalLoop) {
                     anotherLoop = false;
@@ -93,6 +106,8 @@ private void syncChunkList() throws IOException {
                 }
             }
         } while (anotherLoop);
+             */
+        }
     }
 
     public int size() throws IOException {