public class KeyBuilder extends Object implements IKeyBuilder, LongPacker.IByteBuffer
Note: Avoid any dependencies within this class on the ICU libraries so that the code may run without those libraries when they are not required.
SuccessorUtil, Compute the successor of a value before encoding it as a
component of a key.,
BytesUtil#successor(byte[]), Compute the successor of an encoded key.| Modifier and Type | Class and Description |
|---|---|
static interface |
KeyBuilder.Options
Configuration options for
DefaultKeyBuilderFactory and the
KeyBuilder factory methods. |
| Modifier and Type | Field and Description |
|---|---|
static int |
DEFAULT_INITIAL_CAPACITY
The default capacity of the key buffer.
|
byte |
pad
The default pad character (a space).
|
maxlen| Modifier | Constructor and Description |
|---|---|
|
KeyBuilder()
Creates a key builder with an initial buffer capacity of
1024 bytes. |
|
KeyBuilder(int initialCapacity)
Creates a key builder with the specified initial buffer capacity.
|
protected |
KeyBuilder(UnicodeSortKeyGenerator sortKeyGenerator,
int len,
byte[] buf)
Creates a key builder using an existing buffer with some data (designated
constructor).
|
| Modifier and Type | Method and Description |
|---|---|
KeyBuilder |
append(BigDecimal d)
Encode a
BigDecimal into an unsigned byte[] and append it into
the key buffer. |
KeyBuilder |
append(BigInteger i)
Encode a
BigInteger into an unsigned byte[] and append it into
the key buffer. |
KeyBuilder |
append(byte b)
Appends a byte - the byte is treated as an
unsigned value. |
KeyBuilder |
append(byte[] a)
Appends an array of bytes - the bytes are treated as
unsigned values. |
KeyBuilder |
append(byte[] a,
int off,
int len)
Append len bytes starting at off in a to the key
buffer - the bytes are treated as
unsigned values. |
KeyBuilder |
append(double d)
Appends a double precision floating point value by first converting it
into a signed long integer using
Double.doubleToLongBits(double),
converting that values into a twos-complement number and then appending
the bytes in big-endian order into the key buffer. |
KeyBuilder |
append(float f)
Appends a single precision floating point value by first converting it
into a signed integer using
Float.floatToIntBits(float)
converting that values into a twos-complement number and then appending
the bytes in big-endian order into the key buffer. |
KeyBuilder |
append(int v)
Appends a signed integer to the key by first converting it to a
lexiographic ordering as an unsigned integer and then appending it into
the buffer as 4 bytes using a big-endian order.
|
KeyBuilder |
append(long v)
Appends a signed long integer to the key by first converting it to a
lexiographic ordering as an unsigned long integer and then appending it
into the buffer as 8 bytes using a big-endian order.
|
KeyBuilder |
append(Object val)
Append the value to the buffer, encoding it as appropriate based on the
class of the object.
|
KeyBuilder |
append(short v)
Appends a signed short integer to the key by first converting it to a
two-complete representation supporting unsigned byte[] comparison and
then appending it into the buffer as 2 bytes using a big-endian order.
|
KeyBuilder |
append(String s)
Encodes a Unicode string using the configured
KeyBuilder.Options.COLLATOR
and appends the resulting sort key to the buffer (without a trailing nul
byte). |
KeyBuilder |
append(UUID uuid)
Appends the UUID to the key using the MSB and then the LSB (this
preserves the natural order imposed by
UUID.compareTo(UUID)). |
KeyBuilder |
appendASCII(String s)
Encodes a unicode string by assuming that its contents are ASCII
characters.
|
KeyBuilder |
appendNul()
Append an unsigned zero byte to the key.
|
KeyBuilder |
appendSigned(byte v)
Converts the signed byte to an unsigned byte and appends it to the key.
|
KeyBuilder |
appendText(String text,
boolean unicode,
boolean successor)
Encodes a variable length text field into the buffer.
|
KeyBuilder |
appendUnsigned(byte v) |
byte[] |
array()
The backing byte[] WILL be transparently replaced if the buffer capacity
is extended.
|
static int |
byteLength(BigDecimal value)
Return the #of bytes in the unsigned byte[] representation of the
BigDecimal value. |
static int |
byteLength(BigInteger value)
Return the #of bytes in the unsigned byte[] representation of the
BigInteger value. |
int |
capacity()
Return the capacity of the backing buffer.
|
protected static byte[] |
createBuffer(int initialCapacity)
Create a buffer of the specified initial capacity.
|
static long |
d2l(double d)
Encodes a double precision floating point value as an int64 value that
has the same total ordering (you can compare two doubles encoded by this
method and the long values will have the same ordering as the double
values).
|
static String |
decodeASCII(byte[] key,
int off,
int len)
Decodes an ASCII string from a key.
|
static BigDecimal |
decodeBigDecimal(int offset,
byte[] key)
Decodes a
BigDecimal key, returning a byte[] which may be used to
construct a BigDecimal having the decoded value. |
static BigInteger |
decodeBigInteger(int offset,
byte[] key)
Convert an unsigned byte[] into a
BigInteger. |
static byte[] |
decodeBigInteger2(int offset,
byte[] key)
Decodes a
BigInteger key, returning a byte[] which may be used to
construct a BigInteger having the decoded value. |
static byte |
decodeByte(int v)
Converts an unsigned byte into a signed byte.
|
static double |
decodeDouble(byte[] key,
int off) |
static float |
decodeFloat(byte[] key,
int off) |
static int |
decodeInt(byte[] buf,
int off)
Decodes a signed int value as encoded by
append(int). |
static long |
decodeLong(byte[] buf,
int off)
Decodes a signed long value as encoded by
append(long). |
static short |
decodeShort(byte[] buf,
int off)
Decodes a signed short value as encoded by
append(short). |
static UUID |
decodeUUID(byte[] buf,
int off)
Decode a
UUID as encoded by append(UUID). |
static byte |
encodeByte(int v)
Converts a signed byte into an unsigned byte.
|
void |
ensureCapacity(int capacity)
Ensure that the buffer capacity is a least capacity total bytes.
|
void |
ensureFree(int len)
Ensure that at least len bytes are free in the buffer.
|
static int |
f2i(float f)
Encodes a floating point value as an int32 value that has the same total
ordering (you can compare two floats encoded by this method and the int
values will have the same ordering as the float values).
|
long[] |
fromZOrder(int numDimensions)
Inverts method above in the sense that it interprets the buffer as
a zOrderString and returns an array of long values of size numDimensions,
reflecting the individual components of the z-order string.
|
byte[] |
getKey()
Return the encoded key.
|
byte[] |
getSortKey(Object val)
Return an unsigned byte[] sort key.
|
UnicodeSortKeyGenerator |
getSortKeyGenerator()
The object responsible for generating sort keys from Unicode strings.
|
boolean |
isUnicodeSupported()
Return
true iff Unicode is supported by this object
(returns false if only ASCII support is configured). |
int |
len()
The length of the slice is number of bytes written onto the backing
byte[].
|
static IKeyBuilder |
newInstance()
Create an instance for ASCII keys.
|
static IKeyBuilder |
newInstance(int initialCapacity)
Create an instance for ASCII keys with the specified initial capacity.
|
static IKeyBuilder |
newInstance(int capacity,
CollatorEnum collatorChoice,
Locale locale,
Object strength,
DecompositionEnum mode)
Create a new instance that optionally supports Unicode sort keys.
|
static IKeyBuilder |
newUnicodeInstance()
Create a factory for
IKeyBuilder instances configured using the
system properties. |
static IKeyBuilder |
newUnicodeInstance(Properties properties)
Create a factory for
IKeyBuilder instances configured according
to the specified properties. |
int |
off()
The offset of the slice into the backing byte[] is always zero.
|
KeyBuilder |
pack(long v)
Packs a non-negative long value into the minimum #of bytes in which the
value can be represented and writes those bytes onto the buffer.
|
void |
position(int pos)
Sets the position to any non-negative length less than the current
capacity of the buffer.
|
void |
put(byte[] b,
int off,
int len)
Relative put method for writing a byte[] on the buffer.
|
KeyBuilder |
reset()
Reset the key length to zero before building another key.
|
byte[] |
toByteArray()
An alias for
IKeyBuilder.getKey(). |
byte[] |
toZOrder(int numDimensions)
Converts the key into a z-order byte array, assuming numDimensions components
of type Long (i.e., 64bit each).
|
public static final transient int DEFAULT_INITIAL_CAPACITY
public final byte pad
Note: Any character may be chosen as the pad character as long as it has
a one byte representation. In practice this means you can choose 0x20 (a
space) or 0x00 (a nul). This limit arises in
appendText(String, boolean, boolean) which assumes that it can
write a pad character (or its successor) in one byte. 0xff will NOT work
since its successor is not defined within an bit string of length 8.
public KeyBuilder()
1024 bytes.public KeyBuilder(int initialCapacity)
initialCapacity - The initial capacity of the internal byte[] used to construct
keys. When zero (0) the DEFAULT_INITIAL_CAPACITY will
be used.protected KeyBuilder(UnicodeSortKeyGenerator sortKeyGenerator, int len, byte[] buf)
sortKeyGenerator - The object used to generate sort keys from Unicode strings
(when null Unicode collation support is
disabled).len - The #of bytes of data in the provided buffer.buf - The buffer, with len pre-existing bytes of valid data.
The buffer reference is used directly rather than making a
copy of the data.protected static byte[] createBuffer(int initialCapacity)
initialCapacity - The initial size of the buffer.IllegalArgumentException - if the initial capacity is negative.public final int off()
IKeyBuilderIByteArraySlice.array().off in interface IKeyBuilderoff in interface IByteArraySlicepublic final int len()
IKeyBuilderIKeyBuilder.reset(). The length of the slice in the IByteArraySlice.array().
Note: IByteArraySlice.len() has different semantics for some
concrete implementations. ByteArrayBuffer.len() always returns
the capacity of the backing byte[] while ByteArrayBuffer.pos()
returns the #of bytes written onto the backing buffer. In contrast,
len() is always the #of bytes written onto the backing
buffer.len in interface IKeyBuilderlen in interface IByteArraySlicepublic final byte[] array()
IKeyBuilderarray in interface IKeyBuilderarray in interface IByteArraySlicepublic final int capacity()
IManagedByteArraycapacity in interface IManagedByteArraypublic final void position(int pos)
public final KeyBuilder append(byte b)
IKeyBuilderunsigned value.append in interface IKeyBuilderappend in interface IManagedByteArrayb - The byte.public final KeyBuilder append(byte[] a)
IKeyBuilderunsigned values.append in interface IKeyBuilderappend in interface IManagedByteArraya - The array of bytes.public final KeyBuilder append(byte[] a, int off, int len)
IKeyBuilderunsigned values.append in interface IKeyBuilderappend in interface IManagedByteArraya - The array containing the bytes to append.off - The offset.len - The #of bytes to append.public final void ensureFree(int len)
IManagedByteArrayThis operation is equivalent to
ensureCapacity(len() + len)and the latter is often used as an optimization.
ensureFree in interface IManagedByteArraylen - The minimum #of free bytes.public final void ensureCapacity(int capacity)
IManagedByteArrayensureCapacity in interface IManagedByteArraycapacity - The minimum #of bytes in the buffer.public final byte[] toByteArray()
IKeyBuilderIKeyBuilder.getKey().
Return a copy of the data in the slice.toByteArray in interface IKeyBuildertoByteArray in interface IByteArraySlicepublic final byte[] getKey()
IKeyBuilderNote that keys are donated to the btree so it is important to allocate new keys when running in the same process space. When using a network api, the api provides the necessary decoupling.
getKey in interface IKeyBuilderBytesUtil.compareBytes(byte[], byte[])public final KeyBuilder reset()
IKeyBuilderreset in interface IKeyBuilderreset in interface IManagedByteArraypublic final boolean isUnicodeSupported()
IKeyBuildertrue iff Unicode is supported by this object
(returns false if only ASCII support is configured).isUnicodeSupported in interface IKeyBuilderpublic final UnicodeSortKeyGenerator getSortKeyGenerator()
UnicodeSortKeyGenerator -or- null if Unicode
is not supported by this IKeyBuilder instance.public final KeyBuilder append(String s)
IKeyBuilderKeyBuilder.Options.COLLATOR
and appends the resulting sort key to the buffer (without a trailing nul
byte).
Note: The SuccessorUtil.successor(String) of a string is formed
by appending a trailing nul character. However, since
IDENTICAL appears to be required to differentiate between
a string and its successor (with the trailing nul
character), you MUST form the sort key first and then its successor (by
appending a trailing nul). Failure to follow this pattern
will lead to the successor of the key comparing as EQUAL to the key. For
example,
IKeyBuilder keyBuilder = ...;
String s = "foo";
byte[] fromKey = keyBuilder.reset().append( s );
// right.
byte[] toKey = keyBuilder.reset().append( s ).appendNul();
// wrong!
byte[] toKey = keyBuilder.reset().append( s+"\0" );
append in interface IKeyBuilders - A string.SuccessorUtil.successor(String),
SuccessorUtil.successor(byte[]),
FIXME update the javadoc further to speak to handling of multi-field
keys.public KeyBuilder appendASCII(String s)
IKeyBuilder
Note: This method is potentially much faster than the Unicode aware
IKeyBuilder.append(String). However, this method is NOT unicode aware and
non-ASCII characters will not be encoded correctly. This method MUST NOT
be mixed with keys whose corresponding component is encoded by the
unicode aware methods, e.g., IKeyBuilder.append(String).
appendASCII in interface IKeyBuilders - A String containing US-ASCII characters.public static String decodeASCII(byte[] key, int off, int len)
key - The key.off - The offset of the start of the string.len - The #of bytes to decode (one byte per character).appendASCII(String)public KeyBuilder appendText(String text, boolean unicode, boolean successor)
IKeyBuilderIKeyBuilder.maxlen characters. The sort keys for
strings that differ after truncation solely in the #of trailing
#pad characters will be identical (trailing pad characters are
implicit out to IKeyBuilder.maxlen characters).
Note: Trailing pad characters are normalized to a representation as a single pad character (1 byte) followed by the #of actual or implied trailing pad characters represented as an unsigned short integer (2 bytes). This technique serves to keep multi-field keys with embedded variable length text fields aligned such that the field following a variable length text field does not bleed into the lexiographic ordering of the variable length text field.
Note: While the ASCII encoding happens to use one byte for each character that is NOT true of the Unicode encoding. The space requirements for the Unicode encoding depend on the text, the Locale, the collator strength, and the collator decomposition mode.
Note: The successor option is designed to encapsulate some
trickiness around forming the successor of a variable length text field
embedded in a multi-field key. In particular, simply appending a
nul byte will NOT work (it works fine when the text field
is the last field in the key or when it is the only component in the
key). This approach breaks encapsulation of the field boundaries such
that the resulting "successor" is actually ordered before the original
key. This happens because you introduce a 0x0 byte right on the boundary
of the next field, effectively causing the next field to have a smaller
value. Consider the following example (in hex) where "|" represents the
end of the "text" field:
ab cd | 12
if you compute the successor by appending a nul byte to the text field
you get
ab cd | 00 12
which is ordered before the original key!appendText in interface IKeyBuildertext - The text.unicode - When true the text is interpreted as Unicode according to the
KeyBuilder.Options.COLLATOR option. Otherwise it is interpreted
as ASCII.successor - When true, the successor of the text will be encoded.
Otherwise the text will be encoded.IKeyBuilder.http://www.unicode.org/reports/tr10/tr10-10.html#Interleaved_Levelspublic final KeyBuilder append(double d)
IKeyBuilderDouble.doubleToLongBits(double),
converting that values into a twos-complement number and then appending
the bytes in big-endian order into the key buffer.
Note: this converts -0d and +0d to the same key.
append in interface IKeyBuilderd - The double-precision floating point value.public static double decodeDouble(byte[] key,
int off)
public final KeyBuilder append(float f)
IKeyBuilderFloat.floatToIntBits(float)
converting that values into a twos-complement number and then appending
the bytes in big-endian order into the key buffer.
Note: this converts -0f and +0f to the same key.
append in interface IKeyBuilderf - The single-precision floating point value.public static float decodeFloat(byte[] key,
int off)
public final KeyBuilder append(UUID uuid)
IKeyBuilderUUID.compareTo(UUID)).append in interface IKeyBuilderuuid - The UUID.public final KeyBuilder append(long v)
IKeyBuilderappend in interface IKeyBuilderpublic final KeyBuilder pack(long v)
[0|1|2|3|4|5|6|7] 1 - - - nbytes = 8, clear high bit and interpret this plus the next 7 bytes as a long. 0 1 1 1 nbytes = 7, clear high nibble and interpret this plus the next 6 bytes as a long. 0 1 1 0 nbytes = 6, clear high nibble and interpret this plus the next 5 bytes as a long. 0 1 0 1 nbytes = 5, clear high nibble and interpret this plus the next 4 bytes as a long. 0 1 0 0 nbytes = 4, clear high nibble and interpret this plus the next 3 bytes as a long. 0 0 1 1 nbytes = 3, clear high nibble and interpret this plus the next 3 bytes as a long. 0 0 1 0 nbytes = 2, clear high nibble and interpret this plus the next byte as a long. 0 0 0 1 nbytes = 1, clear high nibble. value is the low nibble.Note: These are decodable (no loss) but negative longs are not allowed.
Note: The order is NOT fully preserved. Any long which is encoded into less than 8 bytes has its order preserved. However, a long which is encoded into 8 bytes will wind up ordered before any longs which pack into fewer bytes.
v - The unsigned long value.public void put(byte[] b,
int off,
int len)
put in interface LongPacker.IByteBufferb - The byte[].off - The offset of the first byte in b to be written on
the buffer.len - The #of bytes in b to be written on the buffer.public final KeyBuilder append(int v)
IKeyBuilderappend in interface IKeyBuilderpublic final KeyBuilder append(short v)
IKeyBuilderappend in interface IKeyBuilderpublic final KeyBuilder appendUnsigned(byte v)
public final KeyBuilder appendSigned(byte v)
IKeyBuilderappendSigned in interface IKeyBuilderv - The signed byte.public final KeyBuilder appendNul()
IKeyBuilderappendNul in interface IKeyBuilderpublic KeyBuilder append(BigInteger i)
IKeyBuilderBigInteger into an unsigned byte[] and append it into
the key buffer.
The encoding is a 2 byte run length whose leading bit is set iff the
BigInteger is negative followed by the byte[] as
returned by BigInteger.toByteArray().
append in interface IKeyBuilderpublic static int byteLength(BigInteger value)
BigInteger value.value - The BigInteger value.public KeyBuilder append(BigDecimal d)
BigDecimal into an unsigned byte[] and append it into
the key buffer.
Note: Precision is NOT preserved by this encoding. Thus 0.0
and 0 are encoded by the same representation and both will
decode to 0.
BigDecimal.scale() indicates the precision of the number, where
'3' is three decimal places and '-3' rounded to '000'
BigDecimal.precision() is the number of unscaled digits therefore
precision - scale is an expression of the exponent of the
normalized number. This means that the exponent could be zero or negative
so the sign of the number cannot be indicated by adding to the exponent.
Instead an explicit sign byte,'0' or '1' is used. The actual
BigDecimal serialization uses the String conversions
supported by BigDecimal, less the '-' sign character if
applicable. The length of this data is terminated by a trailing byte. The
value of that byte depends on the sign of the original BigDecimal
and is used to impose the correct sort order on negative
BigDecimal values which differ only in the digits in the decimal
portion.
The variable encoding of BigNumbers requires this String representation
and negative representations are further encoded using
flipDigits(String) for the equivalent of 2s compliment negative
representation.
There are two cases where scale and trailing zeros interact. The case of "0.000" is represented as precision of 1 and scale of 3, indicating the "0" is shifted down 3 decimal places. While "5.000" is represented as precision of 4 and scale of 3. The special case of zero is allowed because shifting zero to the right leaves a new zero on the left, so a zero value must be checked for explicitly, while if we want to compare "5", "5.00" and "5.0000" as equal we must remove and compensate for trailing zeros.
append in interface IKeyBuilderdecodeBigDecimal(int, byte[])public static int byteLength(BigDecimal value)
BigDecimal value.value - The BigDecimal value.public byte[] getSortKey(Object val)
ISortKeyBuildergetSortKey in interface ISortKeyBuilder<Object>val - Some object (required).public KeyBuilder append(Object val)
IKeyBuilderUUID and Unicode Strings.append in interface IKeyBuilderval - The value.public static byte encodeByte(int v)
v - The signed byte.public static byte decodeByte(int v)
v - The unsigned byte.public static long d2l(double d)
Double.doubleToLongBits(double) and then converting the resulting
long into a two's complement number.
See
Comparing floating point numbers by Bruce Dawson.d - The double precision floating point value.public static int f2i(float f)
Float.floatToIntBits(float) and then converting
the resulting int into a two's complement number.
See
Comparing floating point numbers by Bruce Dawson.f - The floating point value.public static long decodeLong(byte[] buf,
int off)
append(long).buf - The buffer containing the encoded key.off - The offset at which to decode the key.public static UUID decodeUUID(byte[] buf, int off)
UUID as encoded by append(UUID).buf - The buffer containing the encoded key.off - The offset at which to decode the key.UUID.public static int decodeInt(byte[] buf,
int off)
append(int).buf - The buffer containing the encoded key.off - The offset at which to decode the key.public static short decodeShort(byte[] buf,
int off)
append(short).buf - The buffer containing the encoded key.off - The offset at which to decode the key.public static BigInteger decodeBigInteger(int offset, byte[] key)
BigInteger.key - The bytes.public static byte[] decodeBigInteger2(int offset,
byte[] key)
BigInteger key, returning a byte[] which may be used to
construct a BigInteger having the decoded value. The number of
bytes consumed by the key component is 2 + runLength. The
2 is a fixed length field coding the signum of the value and
its runLength. The length of the returned array is the runLength of the
variable length portion of the value. This method may be used to scan
through a key containing BigInteger components.offset - The offset of the start of the BigInteger in the key.key - The key.BigInteger.BigInteger(byte[]).public static BigDecimal decodeBigDecimal(int offset, byte[] key)
BigDecimal key, returning a byte[] which may be used to
construct a BigDecimal having the decoded value.
The number of bytes consumed by the key component is
2 + runLength. The
2 is a fixed length field coding the signum of the value and
its runLength. The length of the returned array is the runLength of the
variable length portion of the value.
This method may be used to scan through a key containing
BigDecimal components.offset - The offset of the start of the BigDecimal in the key.key - The key.BigDecimal#BigInteger(byte[]).public static IKeyBuilder newInstance()
public static IKeyBuilder newInstance(int initialCapacity)
initialCapacity - The initial capacity.public static IKeyBuilder newUnicodeInstance()
IKeyBuilder instances configured using the
system properties. The factory will support Unicode unless
CollatorEnum.ASCII is explicitly specified for the
KeyBuilder.Options.COLLATOR property.properties - The properties to be used (optional). When null
the System properties are used.UnsupportedOperationException -
The ICU library was required but was not located. Make sure
that the ICU JAR is on the classpath. See
KeyBuilder.Options.COLLATOR.
Note: If you are trying to use ICU4JNI then that has to be locatable as a native library. How you do this is different for Windows and Un*x.
KeyBuilder.Optionspublic static IKeyBuilder newUnicodeInstance(Properties properties)
IKeyBuilder instances configured according
to the specified properties. Any properties NOT explicitly given
will be defaulted from System.getProperties(). The pre-defined
properties KeyBuilder.Options.USER_LANGUAGE, KeyBuilder.Options.USER_COUNTRY,
and KeyBuilder.Options.USER_VARIANT MAY be overriden. The factory will
support Unicode unless CollatorEnum.ASCII is explicitly specified
for the KeyBuilder.Options.COLLATOR property.properties - The properties to be used (optional). When null
the System properties are used.UnsupportedOperationException -
The ICU library was required but was not located. Make sure
that the ICU JAR is on the classpath. See
KeyBuilder.Options.COLLATOR.
Note: If you are trying to use ICU4JNI then that has to be locatable as a native library. How you do this is different for Windows and Un*x.
KeyBuilder.Optionspublic static IKeyBuilder newInstance(int capacity, CollatorEnum collatorChoice, Locale locale, Object strength, DecompositionEnum mode)
capacity - The initial capacity of the buffer. When zero (0) the
DEFAULT_INITIAL_CAPACITY will be used.collatorChoice - Identifies the collator that will be used to generate sort
keys from Unicode values.locale - When null the
default locale will be used.strength - Either an Integer or a StrengthEnum specifying
the strength to be set on the collator object (optional). When
null the default strength of the collator will
not be overridden.mode - The decomposition mode to be set on the collator object
(optional). When null the default decomposition
mode of the collator will not be overridden.UnsupportedOperationException - The ICU library was required but was not located. Make sure that the ICU JAR is on the classpath.
Note: If you are trying to use ICUJNI then that has to be locatable as a native library. How you do this is different for Windows and Un*x.
public byte[] toZOrder(int numDimensions)
IKeyBuildertoZOrder in interface IKeyBuilderpublic long[] fromZOrder(int numDimensions)
IKeyBuilderfromZOrder in interface IKeyBuilderCopyright © 2006–2019 SYSTAP, LLC DBA Blazegraph. All rights reserved.