WIP

Author: GreenWizard2015

src/Tests/Test_CountMinCounter.java

@@ -5,10 +5,10 @@
 import org.junit.Assert;
 import org.junit.Test;
 
-import YASL.CExactCounter;
 import YASL.IItemsCounter;
 import YASL.Counters.CCMCounter;
 import YASL.Counters.CCountMinParams;
+import YASL.Counters.CExactCounter;
 import YASL.Hashing.ChgBasic;
 
 public class Test_CountMinCounter {

src/Tests/Test_CountingStrings.java

@@ -4,9 +4,9 @@
 import org.junit.Test;
 
 import YASL.CEstimator;
-import YASL.CExactCounter;
 import YASL.IEstimator;
 import YASL.Collectors.CExactCollector;
+import YASL.Counters.CExactCounter;
 
 public class Test_Estimator {
 	@Test

src/Tests/Test_Estimator.java

@@ -1,10 +1,16 @@
 package Tests;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+
 import org.junit.Assert;
 import org.junit.Test;
 
 import YASL.IEstimationCollector;
 import YASL.Collectors.KTopCollector;
+import YASL.Collectors.StoredKTop;
+import YASL.Streams.CtisInteger;
+import YASL.Streams.CtosInteger;
 
 public class Test_KTopCollector {
 
@@ -34,4 +40,26 @@ public void sameCounts() {
 		    collector.collect().toString() //
 		);
 	}
+
+	@Test
+	public void loading() throws Exception {
+		final IEstimationCollector<Integer> collectorA = new KTopCollector<>(3);
+		collectorA.put(3, 4);
+		collectorA.put(2, 3);
+
+		ByteArrayOutputStream stream = new ByteArrayOutputStream();
+		collectorA.store(new CtosInteger(stream));
+
+		final IEstimationCollector<Integer> collectorB = (new StoredKTop<Integer>( //
+		    new CtisInteger( //
+		        new ByteArrayInputStream(stream.toByteArray()) //
+				), //
+		    3 //
+		)).load();
+
+		Assert.assertEquals( //
+		    collectorA.collect().toString(), //
+		    collectorB.collect().toString() //
+		);
+	}
 }

src/Tests/Test_KTopCollector.java

@@ -0,0 +1,37 @@
+package Tests;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import YASL.Counters.Tables.CcsIntTable;
+import YASL.Counters.Tables.CcsStoredTable;
+import YASL.Counters.Tables.CcsTable;
+
+public class Test_csTable {
+
+	@Test
+	public void loadIntTable() throws IOException {
+		CcsTable tableA = new CcsIntTable(2, 1);
+		tableA.put(0, 0, 5);
+		tableA.put(1, 0, 7);
+
+		ByteArrayOutputStream stream = new ByteArrayOutputStream();
+		tableA.store(new DataOutputStream(stream));
+
+		CcsTable tableB = (new CcsStoredTable( //
+		    new DataInputStream( //
+		        new ByteArrayInputStream(stream.toByteArray()) //
+				), //
+		    2, 1 //
+		)).asInt();
+
+		Assert.assertEquals(tableA.read(0, 0), tableB.read(0, 0));
+		Assert.assertEquals(tableA.read(1, 0), tableB.read(1, 0));
+	}
+}

src/Tests/Test_csTable.java

@@ -1,5 +1,9 @@
 package YASL;
 
+import java.io.IOException;
+
+import YASL.Streams.TypedOutputStream;
+
 public class CEstimator<T> implements IEstimator<T> {
 	private final IItemsCounter<T> _counter;
 	private final IEstimationCollector<T> _collector;
@@ -22,4 +26,10 @@ public void add(T item, long count) {
 	public CEstimatedItems<T> estimate() {
 		return _collector.collect();
 	}
+
+	@Override
+	public void store(TypedOutputStream<T> stream) throws IOException {
+		_counter.store(stream);
+		_collector.store(stream);
+	}
 }

src/YASL/CEstimator.java

@@ -1,12 +1,14 @@
 package YASL.Collectors;
 
+import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.stream.Collectors;
 
 import YASL.CEstimatedItems;
 import YASL.CEstimationFor;
 import YASL.IEstimationCollector;
+import YASL.Streams.TypedOutputStream;
 
 public class CExactCollector<T> implements IEstimationCollector<T> {
 
@@ -26,4 +28,9 @@ public CEstimatedItems<T> collect() {
 		        .collect(Collectors.toList()) //
 		);
 	}
+
+	@Override
+	public void store(TypedOutputStream<T> stream) throws IOException {
+    throw new UnsupportedOperationException();
+	}
 }

src/YASL/Collectors/CExactCollector.java

@@ -1,5 +1,6 @@
 package YASL.Collectors;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -10,17 +11,26 @@
 import YASL.CEstimatedItems;
 import YASL.CEstimationFor;
 import YASL.IEstimationCollector;
+import YASL.Streams.TypedOutputStream;
 
 public class KTopCollector<T> implements IEstimationCollector<T> {
 	private final int												_K;
 	private long														_min	= 0L;
 	private final List<CEstimationFor<T>>		_items;
 	private final Map<T, CEstimationFor<T>>	_byValue;
 
+	public KTopCollector( //
+	    int _K, //
+	    List<CEstimationFor<T>> _items, //
+	    Map<T, CEstimationFor<T>> _byValue //
+	) {
+		this._K = _K;
+		this._items = _items;
+		this._byValue = _byValue;
+	}
+
 	public KTopCollector(int K) {
-		this._K = K;
-		_items = new ArrayList<>();
-		_byValue = new HashMap<>();
+		this(K, new ArrayList<>(), new HashMap<>());
 	}
 
 	@Override
@@ -58,4 +68,15 @@ public CEstimatedItems<T> collect() {
 		    _items.stream().collect(Collectors.toList()) //
 		);
 	}
+
+	@Override
+	public void store(TypedOutputStream<T> stream) throws IOException {
+		fitK();
+
+		stream.writeInt(_items.size());
+		for (CEstimationFor<T> item : _items) {
+			stream.writeType(item.Item);
+			stream.writeLong(item.Count);
+		}
+	}
 }

src/YASL/Collectors/KTopCollector.java

@@ -0,0 +1,37 @@
+package YASL.Collectors;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import YASL.CEstimationFor;
+import YASL.IEstimationCollector;
+import YASL.Streams.TypedInputStream;
+
+public class StoredKTop<T> {
+	private final TypedInputStream<T>	_stream;
+	private final int									_size;
+
+	public StoredKTop(TypedInputStream<T> _stream, int _size) {
+		this._stream = _stream;
+		this._size = _size;
+	}
+
+	public IEstimationCollector<T> load() throws IOException {
+		final int cnt = _stream.readInt();
+		final List<CEstimationFor<T>> items = new ArrayList<>(cnt);
+		final Map<T, CEstimationFor<T>> byValue = new HashMap<>();
+
+		for (int i = 0; i < cnt; i++) {
+			final T item = _stream.readType();
+			final long itemCount = _stream.readLong();
+			final CEstimationFor<T> est= new CEstimationFor<>(item, itemCount);
+
+			items.add(est);
+			byValue.put(item, est);
+		}
+		return new KTopCollector<>(_size, items, byValue);
+	}
+}