com.bigdata.rdf.internal.impl.extensions

Class GeoSpatialLiteralExtension<V extends BigdataValue>

java.lang.Object

com.bigdata.rdf.internal.impl.extensions.GeoSpatialLiteralExtension<V>

All Implemented Interfaces:

IExtension<V>

public class GeoSpatialLiteralExtension<V extends BigdataValue>
extends Object
implements IExtension<V>

Special encoding for GeoSpatial datatypes. We encode literals of the form #...# as BigInteger using the xsd:integer type. The conversion into BigInteger is based on a calculation of the z-order string for the n components. The code to create a literal is, e.g.: "2#4"^^ The two components are first broken down long integers, namely - 2 -> 00000000 00000000 00000010 - 4 -> 00000000 00000000 00000100 The z-order encoding of these two strings is then 00000000 00000000 00000000 00000000 00000000 00000000 00011000 Interpreted as BigInteger, this is the value 24, which is stored as integer literal in the database. The asValue method reverts this (lossless) encoding.

Version:

$Id$

Author:

Michael Schmidt

Constructor Summary

Constructors

Constructor and Description
GeoSpatialLiteralExtension(IDatatypeURIResolver resolver, GeoSpatialDatatypeConfiguration config) Constructor setting up an instance with a default schema description.

Method Summary

Methods

Modifier and Type	Method and Description
long[]	asLongArray(LiteralExtensionIV iv) Decodes an xsd:integer into the long values of the z-order components represented through the xsd:integer.
V	asValue(LiteralExtensionIV iv, BigdataValueFactory vf) Decodes an xsd:integer into an n-dimensional string of the form #...#.
long[]	componentsAsLongArr(Object[] components, GeoSpatialDatatypeConfiguration datatypeConfig) Convert the components into a long array.
LiteralExtensionIV	createIV(Object[] components) Create an IV from a given value (where the value must be a Literal).
LiteralExtensionIV	createIV(org.openrdf.model.Value value) Create an IV from a given value (where the value must be a Literal).
LiteralExtensionIV	createIVFromZOrderByteArray(byte[] zOrderByteArray) Create an IV from a two's complement byte array Implements transformation E->F
protected Long	decodeRangeShift(Long val, Long minValue) Invert encodeRangeShift(Long, Long) operation.
protected Long	encodeRangeShift(Long val, Long minValue) Shift values according to the minValue, making sure that we encode the lowest value in the range as the lowest value 00000000...
long[]	fromZOrderByteArray(byte[] byteArr) Converts a z-order byte array to a long array representing the components.
GeoSpatialDatatypeConfiguration	getDatatypeConfig()
Set<BigdataURI>	getDatatypes() Return the fully resolved datatype(s) handled by this interface in the form of a BigdataURI with the TermId already set.
int	getNumDimensions() Return the number of dimensions of the literal
Object[]	longArrAsComponentArr(long[] arr) Converts a a Long[] reflecting the long values of the individual components back into a component array representing the literal.
byte[]	padLeadingZero(byte[] arr) Pads a leading zero byte to the byte array.
Object[]	toComponentArray(LiteralExtensionIV iv) Conversion of a an IV into its component array.
byte[]	toZOrderByteArray(AbstractLiteralIV<BigdataLiteral,?> literalIV) Converts an IV to a zOrderByte array (without leading zero).
byte[]	toZOrderByteArray(BigInteger bigInt) Decodes a BigInteger into a zOrder byte[] (without leading zero).
byte[]	toZOrderByteArray(long[] componentsAsLongArr, GeoSpatialDatatypeConfiguration datatypeConfig) Converts a long array representing the components to a z-order byte array.
byte[]	toZOrderByteArray(Object[] components) Create a two-components byte[] from a component array.
byte[]	unpadLeadingZero(byte[] arr) Reverts method {padLeadingZero(byte[]).

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

GeoSpatialLiteralExtension

public GeoSpatialLiteralExtension(IDatatypeURIResolver resolver,
                          GeoSpatialDatatypeConfiguration config)

Constructor setting up an instance with a default schema description.

Parameters:

resolver -

Method Detail

getDatatypes

public Set<BigdataURI> getDatatypes()

Description copied from interface: IExtension

Return the fully resolved datatype(s) handled by this interface in the form of a BigdataURI with the TermId already set.

Specified by:

getDatatypes in interface IExtension<V extends BigdataValue>

Returns:

the datatype

createIV

public LiteralExtensionIV createIV(org.openrdf.model.Value value)

Create an IV from a given value (where the value must be a Literal). Implements transformation A->G.

Specified by:

createIV in interface IExtension<V extends BigdataValue>

Parameters:

value - The RDF Value

Returns:

The extension IV -or- null if the Value can not be inlined using this IExtension.

createIV

public LiteralExtensionIV createIV(Object[] components)

Create an IV from a given value (where the value must be a Literal). Implements transformation B->F.

toZOrderByteArray

public byte[] toZOrderByteArray(Object[] components)

Create a two-components byte[] from a component array. Implements transformation B->E

createIVFromZOrderByteArray

public LiteralExtensionIV createIVFromZOrderByteArray(byte[] zOrderByteArray)

Create an IV from a two's complement byte array Implements transformation E->F

componentsAsLongArr

public final long[] componentsAsLongArr(Object[] components,
                         GeoSpatialDatatypeConfiguration datatypeConfig)

Convert the components into a long array. The array is passed as an Object[], in order to allow for unparsed strings as well as Long or Double's (or any convertable) as input. The array must have the same size as the number of dimensions, otherwise a runtime exception is thrown. Longs (or other objects being parseable as Long) are copied to the target array without modification. Floats (or objects being parseable as Float) are converted into Long according to the precision specified in the passed SchemaDescription. Implements step B->C.

toZOrderByteArray

public byte[] toZOrderByteArray(long[] componentsAsLongArr,
                       GeoSpatialDatatypeConfiguration datatypeConfig)

Converts a long array representing the components to a z-order byte array. Thereby, a range shift is performed, if specified. Implements step C->D

encodeRangeShift

protected Long encodeRangeShift(Long val,
                    Long minValue)

Shift values according to the minValue, making sure that we encode the lowest value in the range as the lowest value 00000000... when encoded as byte array. Implements steps C->D1.

padLeadingZero

public byte[] padLeadingZero(byte[] arr)

Pads a leading zero byte to the byte array. This changes the value (which does not harm order, if we do it consistently for all zOrder strings prior to saving them) and makes sure that the array represents an unsigned value, for which the two's complement representation does not differ. More concretely, having padded the zero, we may safely call the BigInteger constructor (which expects a two's complement input). Implements step D->E.

asValue

public V asValue(LiteralExtensionIV iv,
        BigdataValueFactory vf)

Decodes an xsd:integer into an n-dimensional string of the form #...#. Implements transformation G->A.

Specified by:

asValue in interface IExtension<V extends BigdataValue>

Parameters:

iv - The extension IV

vf - The bigdata value factory

Returns:

The RDF Value

asLongArray

public long[] asLongArray(LiteralExtensionIV iv)

Decodes an xsd:integer into the long values of the z-order components represented through the xsd:integer. Implements transformation G->C

Parameters:

iv -

Returns:

toComponentArray

public Object[] toComponentArray(LiteralExtensionIV iv)

Conversion of a an IV into its component array.

toZOrderByteArray

public byte[] toZOrderByteArray(BigInteger bigInt)

Decodes a BigInteger into a zOrder byte[] (without leading zero). Implements transformation F->E.

toZOrderByteArray

public byte[] toZOrderByteArray(AbstractLiteralIV<BigdataLiteral,?> literalIV)

Converts an IV to a zOrderByte array (without leading zero). Entry point for query service, somewhat outside the pipeline described above.

fromZOrderByteArray

public long[] fromZOrderByteArray(byte[] byteArr)

Converts a z-order byte array to a long array representing the components. As part of this transformation, a possible range shift is reverted. Implements transformation D2 -> C.

decodeRangeShift

protected Long decodeRangeShift(Long val,
                    Long minValue)

Invert encodeRangeShift(Long, Long) operation. Implements steps D1->C.

longArrAsComponentArr

public final Object[] longArrAsComponentArr(long[] arr)

Converts a a Long[] reflecting the long values of the individual components back into a component array representing the literal. Implements step C->B.

unpadLeadingZero

public byte[] unpadLeadingZero(byte[] arr)

Reverts method {padLeadingZero(byte[]). Implements step E->D.

getNumDimensions

public int getNumDimensions()

Return the number of dimensions of the literal

Returns:

getDatatypeConfig

public GeoSpatialDatatypeConfiguration getDatatypeConfig()