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); } }