public static Value GetRightArray(Pair <sbyte[], sbyte[]> data)
{
sbyte[] header = data.First();
sbyte[] bArray = data.Other();
sbyte typeId = header[0];
if (typeId == PropertyType.String.intValue())
{
ByteBuffer headerBuffer = ByteBuffer.wrap(header, 1, header.Length - 1);
int arrayLength = headerBuffer.Int;
string[] result = new string[arrayLength];
ByteBuffer dataBuffer = ByteBuffer.wrap(bArray);
for (int i = 0; i < arrayLength; i++)
{
int byteLength = dataBuffer.Int;
sbyte[] stringByteArray = new sbyte[byteLength];
dataBuffer.get(stringByteArray);
result[i] = PropertyStore.DecodeString(stringByteArray);
}
return(Values.stringArray(result));
}
else if (typeId == PropertyType.Geometry.intValue())
{
GeometryType.GeometryHeader geometryHeader = GeometryType.GeometryHeader.fromArrayHeaderBytes(header);
return(GeometryType.decodeGeometryArray(geometryHeader, bArray));
}
else if (typeId == PropertyType.Temporal.intValue())
{
TemporalType.TemporalHeader temporalHeader = TemporalType.TemporalHeader.fromArrayHeaderBytes(header);
return(TemporalType.decodeTemporalArray(temporalHeader, bArray));
}
else
{
ShortArray type = ShortArray.typeOf(typeId);
int bitsUsedInLastByte = header[1];
int requiredBits = header[2];
if (requiredBits == 0)
{
return(type.createEmptyArray());
}
if (type == ShortArray.Byte && requiredBits == (sizeof(sbyte) * 8))
{ // Optimization for byte arrays (probably large ones)
return(Values.byteArray(bArray));
}
else
{ // Fallback to the generic approach, which is a slower
Bits bits = Bits.bitsFromBytes(bArray);
int length = (bArray.Length * 8 - (8 - bitsUsedInLastByte)) / requiredBits;
return(type.createArray(length, bits, requiredBits));
}
}
}
public static ArrayValue ReadArrayFromBuffer(ByteBuffer buffer)
{
if (buffer.limit() <= 0)
{
throw new System.InvalidOperationException("Given buffer is empty");
}
sbyte typeId = buffer.get();
buffer.order(ByteOrder.BIG_ENDIAN);
try
{
if (typeId == PropertyType.String.intValue())
{
int arrayLength = buffer.Int;
string[] result = new string[arrayLength];
for (int i = 0; i < arrayLength; i++)
{
int byteLength = buffer.Int;
result[i] = UTF8.decode(buffer.array(), buffer.position(), byteLength);
buffer.position(buffer.position() + byteLength);
}
return(Values.stringArray(result));
}
else if (typeId == PropertyType.Geometry.intValue())
{
GeometryType.GeometryHeader header = GeometryType.GeometryHeader.fromArrayHeaderByteBuffer(buffer);
sbyte[] byteArray = new sbyte[buffer.limit() - buffer.position()];
buffer.get(byteArray);
return(GeometryType.decodeGeometryArray(header, byteArray));
}
else if (typeId == PropertyType.Temporal.intValue())
{
TemporalType.TemporalHeader header = TemporalType.TemporalHeader.fromArrayHeaderByteBuffer(buffer);
sbyte[] byteArray = new sbyte[buffer.limit() - buffer.position()];
buffer.get(byteArray);
return(TemporalType.decodeTemporalArray(header, byteArray));
}
else
{
ShortArray type = ShortArray.typeOf(typeId);
int bitsUsedInLastByte = buffer.get();
int requiredBits = buffer.get();
if (requiredBits == 0)
{
return(type.createEmptyArray());
}
if (type == ShortArray.Byte && requiredBits == (sizeof(sbyte) * 8))
{ // Optimization for byte arrays (probably large ones)
sbyte[] byteArray = new sbyte[buffer.limit() - buffer.position()];
buffer.get(byteArray);
return(Values.byteArray(byteArray));
}
else
{ // Fallback to the generic approach, which is a slower
Bits bits = Bits.bitsFromBytes(buffer.array(), buffer.position());
int length = ((buffer.limit() - buffer.position()) * 8 - (8 - bitsUsedInLastByte)) / requiredBits;
return(type.createArray(length, bits, requiredBits));
}
}
}
finally
{
buffer.order(ByteOrder.LITTLE_ENDIAN);
}
}
