Reworked again

Author: GreenWizard2015

src/Tests/Test_BasicHashingGenerator.java

@@ -3,26 +3,30 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import YASL.Hashing.CIntegerHashing;
 import YASL.Hashing.ChgCombined;
 import YASL.Hashing.IHasher;
 
 public class Test_hgCombined {
+
 	@Test
 	public void returnHashesFirst() {
 		IHasher<Integer> gen = new ChgCombined<Integer>( //
-		    x -> 1, x -> 2 //
+		    new CIntegerHashing<>(x -> 1), //
+		    new CIntegerHashing<>(x -> 2) //
 		).generate(Integer.MAX_VALUE, 2);
 
 		Assert.assertArrayEquals( //
-		    new int[] { 1, 2 }, //
-		    gen.apply(1) //
+		    new int[] { 1, 2 }, gen.apply(1) //
 		);
 	}
 
 	@Test
 	public void respectRange() {
 		IHasher<Integer> gen = new ChgCombined<Integer>( //
-		    x -> 21, x -> -24//
+		    (x, r) -> x, // salt
+		    (x, r) -> r.put((byte) 21), //
+		    (x, r) -> r.put((byte) -24) //
 		).generate(5, 2);
 
 		Assert.assertArrayEquals( //
@@ -34,28 +38,62 @@ public void respectRange() {
 	@Test
 	public void useOnlyWhatNeed() {
 		IHasher<Integer> gen = new ChgCombined<Integer>( //
-		    x -> 1, //
-		    x -> {
+		    new CIntegerHashing<>(x -> 1), //
+		    (x, r) -> {
 			    throw new RuntimeException("Don't touch me!");
-		    }//
-		).generate(5, 1);
+		    } //
+		).generate(Integer.MAX_VALUE, 1);
 
-		Assert.assertArrayEquals( //
-		    new int[] { 1 }, //
-		    gen.apply(1) //
-		);
+		Assert.assertArrayEquals(new int[] { 1 }, gen.apply(2));
 	}
 
 	@Test
 	public void applySalting() {
 		IHasher<Integer> gen = new ChgCombined<Integer>( //
 		    (x, r) -> x * r * 4, //
-		    x -> x, x -> x + 1 //
+		    new CIntegerHashing<>(x -> x), //
+		    new CIntegerHashing<>(x -> x + 1) //
 		).generate(Integer.MAX_VALUE, 5);
 
 		Assert.assertArrayEquals( //
-		    new int[] { 1, 2, 4, 5, 8 }, //
-		    gen.apply(1) //
+		    new int[] { 1, 2, 4, 5, 8 }, gen.apply(1) //
+		);
+	}
+
+	@Test
+	public void sizeOfRange() {
+		ChgCombined<Integer> gen = new ChgCombined<Integer>(null);
+		Assert.assertEquals(1, gen.bytesIn(3));
+
+		Assert.assertEquals(2, gen.bytesIn(256));
+		Assert.assertEquals(2, gen.bytesIn(0xFFFF));
+
+		Assert.assertEquals(4, gen.bytesIn(0xFFFF00));
+		Assert.assertEquals(4, gen.bytesIn(0x7FFFFF00));
+	}
+
+	@Test
+	public void use4bytes() {
+		IHasher<Integer> gen = new ChgCombined<Integer>( //
+		    new CIntegerHashing<>(x -> x) //
+		).generate(Integer.MAX_VALUE, 1);
+
+		Assert.assertArrayEquals( //
+		    new int[] { 1 }, gen.apply(1) //
+		);
+	}
+
+	@Test
+	public void use2bytes() {
+		IHasher<Integer> gen = new ChgCombined<Integer>( //
+		    new CIntegerHashing<>(x -> x), //
+		    new CIntegerHashing<>(x -> {
+			    throw new RuntimeException("Don't touch me.");
+		    }) //
+		).generate(0xFFFF, 2);
+
+		Assert.assertArrayEquals( //
+		    new int[] { 1, 2 }, gen.apply(0x00010002) //
 		);
 	}
 }

src/Tests/Test_hgCombined.java

@@ -0,0 +1,21 @@
+package YASL.Hashing;
+
+import java.nio.ByteBuffer;
+
+public class CIntegerHashing<T> implements IHashingAlgorithm<T> {
+	public interface IIntegerHashing<T> {
+		public int apply(T x);
+	}
+
+	private final IIntegerHashing<T> _hashing;
+
+	public CIntegerHashing(IIntegerHashing<T> _hashing) {
+		this._hashing = _hashing;
+	}
+
+	@Override
+	public void hash(T value, ByteBuffer res) {
+		res.putInt(_hashing.apply(value));
+	}
+
+}

src/YASL/Hashing/CIntegerHashing.java

@@ -1,5 +1,7 @@
 package YASL.Hashing;
 
+import java.nio.ByteBuffer;
+
 public class ChgCombined<T> implements IHashingGenerator<T> {
 	public interface ISalter<T> {
 		public T apply(T value, int round);
@@ -27,27 +29,51 @@ public ChgCombined(IHashingAlgorithm<T>... hashes) {
 	@Override
 	public IHasher<T> generate(int range, int levels) {
 		return x -> {
-			final int[] res = new int[levels];
-			int pos = populate(x, res, 0);
+			final int bytesPerItem = bytesIn(range);
+			final ByteBuffer res = populate(x, levels * bytesPerItem);
+			final int[] resArr = new int[levels];
+			for (int i = 0; i < levels; i++) {
+				switch (bytesPerItem) {
+					case 4:
+						resArr[i] = Math.abs(res.getInt() % range);
+						break;
 
-			int round = 0;
-			while (pos < levels) {
-				round++;
-				pos = populate(_salting.apply(x, round), res, pos);
-			}
+					case 2:
+						resArr[i] = Math.abs(res.getShort() % range);
+						break;
 
-			for (int i = 0; i < res.length; i++)
-				res[i] = Math.abs(res[i] % range);
-			return res;
+					case 1:
+						resArr[i] = Math.abs(res.get() % range);
+						break;
+				}
+			}
+			return resArr;
 		};
 	}
 
-	private int populate(T x, int[] res, int pos) {
-		final int N = Math.min(_hashes.length, res.length - pos);
-		for (int i = 0; i < N; i++) {
-			res[pos] = _hashes[i].hash(x);
-			pos++;
+	public int bytesIn(int range) {
+		if (range <= 0xFF)
+			return 1;
+		if (range <= 0xFFFF)
+			return 2;
+		return 4;
+	}
+
+	private void populate(T x, int sz, ByteBuffer res) {
+		for (int i = 0; i < _hashes.length; i++) {
+			if (sz <= res.position())
+				break;
+			_hashes[i].hash(x, res);
 		}
-		return pos;
+	}
+
+	private ByteBuffer populate(T x, int sz) {
+		final ByteBuffer res = ByteBuffer.allocate(32 + sz);
+		populate(x, sz, res);
+		for (int round = 1; res.position() < sz; round++)
+			populate(_salting.apply(x, round), sz, res);
+
+		res.rewind();
+		return res;
 	}
 }

src/YASL/Hashing/ChgCombined.java

@@ -1,5 +1,7 @@
 package YASL.Hashing;
 
+import java.nio.ByteBuffer;
+
 public interface IHashingAlgorithm<T> {
-	public int hash(T value);
+	public void hash(T value, ByteBuffer res);
 }