@Override byte[] encodeIncreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeBytes(bytesFromHexString(value())); return orderedCode.getEncodedBytes(); }
/** Calculates the encoding length in bytes of the signed number n. */ @VisibleForTesting int getSignedEncodingLength(long n) { return BITS_TO_LENGTH[log2Floor(n < 0 ? ~n : n) + 1]; }
/** * Returns the next byte array item from its encoded byte array store and removes the item from * the store. * * @see #writeBytes(byte[]) */ public byte[] readBytes() { return readBytes(false); }
private void writeString(OrderedCode orderedCode, KeyPart part, String v) { if (part.isDesc()) { orderedCode.writeBytesDecreasing(v.getBytes(StandardCharsets.UTF_8)); } else { orderedCode.writeBytes(v.getBytes(StandardCharsets.UTF_8)); } }
@Override byte[] encodeIncreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeNumIncreasing(value()); return orderedCode.getEncodedBytes(); }
@Override byte[] encodeDecreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeBytesDecreasing(bytesFromHexString(value())); return orderedCode.getEncodedBytes(); }
OrderedCode orderedCode = new OrderedCode(); assertFalse(orderedCode.hasRemainingEncodedBytes()); orderedCode.writeBytes(bytes); assertTrue(orderedCode.hasRemainingEncodedBytes()); assertTrue(Arrays.equals(orderedCode.readBytes(), bytes)); assertFalse(orderedCode.hasRemainingEncodedBytes()); orderedCode.writeNumIncreasing(number); assertTrue(orderedCode.hasRemainingEncodedBytes()); assertEquals(orderedCode.readNumIncreasing(), number); assertFalse(orderedCode.hasRemainingEncodedBytes()); orderedCode.writeSignedNumIncreasing(number); assertTrue(orderedCode.hasRemainingEncodedBytes()); assertEquals(orderedCode.readSignedNumIncreasing(), number); assertFalse(orderedCode.hasRemainingEncodedBytes()); orderedCode.writeInfinity(); assertTrue(orderedCode.hasRemainingEncodedBytes()); assertTrue(orderedCode.readInfinity()); assertFalse(orderedCode.hasRemainingEncodedBytes()); orderedCode.writeTrailingBytes(bytes); assertTrue(orderedCode.hasRemainingEncodedBytes()); assertTrue(Arrays.equals(orderedCode.readTrailingBytes(), bytes)); assertFalse(orderedCode.hasRemainingEncodedBytes()); orderedCode.writeBytes(bytes);
OrderedCode orderedCode = new OrderedCode(); orderedCode.writeBytes(ffChar); orderedCode.writeBytes(nullChar); orderedCode.writeInfinity(); assertTrue( Arrays.equals( orderedCode.getEncodedBytes(), Bytes.concat( ffCharEncoded, separatorEncoded, infinityEncoded))); assertTrue(Arrays.equals(orderedCode.readBytes(), ffChar)); assertTrue(Arrays.equals(orderedCode.readBytes(), nullChar)); assertTrue(orderedCode.readInfinity()); orderedCode = new OrderedCode(Bytes.concat(ffCharEncoded, separatorEncoded)); assertTrue(Arrays.equals(orderedCode.readBytes(), ffChar)); orderedCode = new OrderedCode(Bytes.concat(nullCharEncoded, separatorEncoded)); assertTrue(Arrays.equals(orderedCode.readBytes(), nullChar)); orderedCode = new OrderedCode(invalidEncodingForRead); try { orderedCode.readBytes(); fail("Should have failed."); } catch (Exception e) { assertTrue(orderedCode.hasRemainingEncodedBytes());
@Test public void testOrderingInfinity() { OrderedCode inf = new OrderedCode(); inf.writeInfinity(); OrderedCode negInf = new OrderedCode(); negInf.writeInfinityDecreasing(); OrderedCode longValue = new OrderedCode(); longValue.writeSignedNumIncreasing(1); assertTrue(compare(inf.getEncodedBytes(), negInf.getEncodedBytes()) > 0); assertTrue(compare(longValue.getEncodedBytes(), negInf.getEncodedBytes()) > 0); assertTrue(compare(inf.getEncodedBytes(), longValue.getEncodedBytes()) > 0); }
@Test public void testWriteTrailingBytes() { byte[] escapeChars = new byte[] { OrderedCode.ESCAPE1, OrderedCode.NULL_CHARACTER, OrderedCode.SEPARATOR, OrderedCode.ESCAPE2, OrderedCode.INFINITY, OrderedCode.FF_CHARACTER }; byte[] anotherArray = new byte[] {'a', 'b', 'c', 'd', 'e'}; OrderedCode orderedCode = new OrderedCode(); orderedCode.writeTrailingBytes(escapeChars); assertTrue(Arrays.equals(orderedCode.getEncodedBytes(), escapeChars)); assertTrue(Arrays.equals(orderedCode.readTrailingBytes(), escapeChars)); try { orderedCode.readInfinity(); fail("Expected IllegalArgumentException."); } catch (IllegalArgumentException e) { // expected } orderedCode = new OrderedCode(); orderedCode.writeTrailingBytes(anotherArray); assertTrue(Arrays.equals(orderedCode.getEncodedBytes(), anotherArray)); assertTrue(Arrays.equals(orderedCode.readTrailingBytes(), anotherArray)); }
@Test public void testWriteBytes() { byte[] first = {'a', 'b', 'c'}; byte[] second = {'d', 'e', 'f'}; byte[] last = {'x', 'y', 'z'}; OrderedCode orderedCode = new OrderedCode(); orderedCode.writeBytes(first); byte[] firstEncoded = orderedCode.getEncodedBytes(); assertTrue(Arrays.equals(orderedCode.readBytes(), first)); orderedCode.writeBytes(first); orderedCode.writeBytes(second); orderedCode.writeBytes(last); byte[] allEncoded = orderedCode.getEncodedBytes(); assertTrue(Arrays.equals(orderedCode.readBytes(), first)); assertTrue(Arrays.equals(orderedCode.readBytes(), second)); assertTrue(Arrays.equals(orderedCode.readBytes(), last)); orderedCode = new OrderedCode(firstEncoded); orderedCode.writeBytes(second); orderedCode.writeBytes(last); assertTrue(Arrays.equals(orderedCode.getEncodedBytes(), allEncoded)); assertTrue(Arrays.equals(orderedCode.readBytes(), first)); assertTrue(Arrays.equals(orderedCode.readBytes(), second)); assertTrue(Arrays.equals(orderedCode.readBytes(), last)); orderedCode = new OrderedCode(allEncoded); assertTrue(Arrays.equals(orderedCode.readBytes(), first)); assertTrue(Arrays.equals(orderedCode.readBytes(), second)); assertTrue(Arrays.equals(orderedCode.readBytes(), last)); }
/** * Assert that encoding (via {@link OrderedCode#writeSignedNumIncreasing(long)}) the specified * long value and then decoding (via {@link OrderedCode#readSignedNumIncreasing()}) results in the * original value. */ private static void assertSignedNumIncreasingWriteAndReadIsLossless(long num) { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeSignedNumIncreasing(num); assertEquals( "Unexpected result when decoding writeSignedNumIncreasing(" + num + ")", num, orderedCode.readSignedNumIncreasing()); assertFalse( "Unexpected remaining encoded bytes after decoding " + num, orderedCode.hasRemainingEncodedBytes()); }
@Test public void testWriteBytesDecreasing() { byte[] first = {'a', 'b', 'c'}; byte[] second = {'d', 'e', 'f'}; byte[] last = {'x', 'y', 'z'}; OrderedCode orderedCode = new OrderedCode(); orderedCode.writeBytesDecreasing(first); byte[] firstEncoded = orderedCode.getEncodedBytes(); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), first)); orderedCode.writeBytesDecreasing(first); orderedCode.writeBytesDecreasing(second); orderedCode.writeBytesDecreasing(last); byte[] allEncoded = orderedCode.getEncodedBytes(); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), first)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), second)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), last)); orderedCode = new OrderedCode(firstEncoded); orderedCode.writeBytesDecreasing(second); orderedCode.writeBytesDecreasing(last); assertTrue(Arrays.equals(orderedCode.getEncodedBytes(), allEncoded)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), first)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), second)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), last)); orderedCode = new OrderedCode(allEncoded); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), first)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), second)); assertTrue(Arrays.equals(orderedCode.readBytesDecreasing(), last)); }
@Test public void testWriteNumDecreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeNumDecreasing(0); orderedCode.writeNumDecreasing(1); orderedCode.writeNumDecreasing(Long.MIN_VALUE); orderedCode.writeNumDecreasing(Long.MAX_VALUE); assertEquals(0, orderedCode.readNumDecreasing()); assertEquals(1, orderedCode.readNumDecreasing()); assertEquals(Long.MIN_VALUE, orderedCode.readNumDecreasing()); assertEquals(Long.MAX_VALUE, orderedCode.readNumDecreasing()); }
@Test public void testWriteNumIncreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeNumIncreasing(0); orderedCode.writeNumIncreasing(1); orderedCode.writeNumIncreasing(Long.MIN_VALUE); orderedCode.writeNumIncreasing(Long.MAX_VALUE); assertEquals(0, orderedCode.readNumIncreasing()); assertEquals(1, orderedCode.readNumIncreasing()); assertEquals(Long.MIN_VALUE, orderedCode.readNumIncreasing()); assertEquals(Long.MAX_VALUE, orderedCode.readNumIncreasing()); }
@Override byte[] encodeDecreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeNumDecreasing(value()); return orderedCode.getEncodedBytes(); }
/** Ensures that numbers encoded as "decreasing" do indeed sort in reverse order. */ @Test public void testDecreasing() { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeSignedNumDecreasing(10L); byte[] ten = orderedCode.getEncodedBytes(); orderedCode = new OrderedCode(); orderedCode.writeSignedNumDecreasing(20L); byte[] twenty = orderedCode.getEncodedBytes(); // In decreasing order, twenty preceeds ten. assertTrue(compare(twenty, ten) < 0); }
/** * OrderedCode.log2Floor(long) is defined to return -1 given an input of zero (because that's what * Bits::Log2Floor64(uint64) does). */ @Test public void testLog2Floor_zero() { OrderedCode orderedCode = new OrderedCode(); assertEquals(-1, orderedCode.log2Floor(0)); }
/** * Assert that encoding (via {@link OrderedCode#writeSignedNumDecreasing(long)}) the specified * long value and then decoding (via {@link OrderedCode#readSignedNumDecreasing()}) results in the * original value. */ private static void assertSignedNumDecreasingWriteAndReadIsLossless(long num) { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeSignedNumDecreasing(num); assertEquals( "Unexpected result when decoding writeSignedNumDecreasing(" + num + ")", num, orderedCode.readSignedNumDecreasing()); assertFalse( "Unexpected remaining encoded bytes after decoding " + num, orderedCode.hasRemainingEncodedBytes()); }
/** * Assert that encoding the specified long via {@link OrderedCode#writeSignedNumIncreasing(long)} * results in the bytes represented by the specified string of hex digits. E.g. * assertSignedNumIncreasingEncodingEquals("3fbf", -65) asserts that -65 is encoded as { (byte) * 0x3f, (byte) 0xbf }. */ private static void assertSignedNumIncreasingEncodingEquals( String expectedHexEncoding, long num) { OrderedCode orderedCode = new OrderedCode(); orderedCode.writeSignedNumIncreasing(num); assertEquals( "Unexpected encoding for " + num, expectedHexEncoding, bytesToHexString(orderedCode.getEncodedBytes())); }