private Geometry toGeometry(byte[] bytes) { if ( bytes == null ) { return null; } final ByteBuffer buffer = ByteBuffer.from( bytes ); final WkbDecoder decoder = Wkb.newDecoder( Wkb.Dialect.MYSQL_WKB ); return decoder.decode( buffer ); }
public static byte[] toEWKB(Geometry<?> geometry) { WkbEncoder encoder = Wkb.newEncoder( Wkb.Dialect.HANA_EWKB ); ByteBuffer bytes = encoder.encode( geometry, ByteOrder.NDR ); return bytes.toByteArray(); } }
private static ByteBuffer addCrsId(byte[] wkb, byte orderByte, int typeCode, int crsId) { ByteBuffer buffer = ByteBuffer.allocate( wkb.length + 4 ); // original capacity + 4 bytes for the CRS ID buffer.setByteOrder( ByteOrder.valueOf( orderByte ) ); buffer.put( orderByte ); // write byte order buffer.putUInt( typeCode | POSTGIS_SRID_FLAG ); // set SRID flag buffer.putInt( crsId ); // write CRS ID // write remaining data for ( int i = 5; i < wkb.length; i++ ) { buffer.put( wkb[i] ); } buffer.rewind(); return buffer; }
private static ByteBuffer toByteBuffer(Object obj) { byte[] raw = null; if ( obj == null ) { return null; } if ( ( obj instanceof byte[] ) ) { raw = (byte[]) obj; } else if ( obj instanceof Blob ) { raw = toByteArray( (Blob) obj ); } else { throw new IllegalArgumentException( "Expected byte array or BLOB" ); } ByteBuffer buffer = ByteBuffer.from( raw ); buffer.setByteOrder( ByteOrder.valueOf( raw[0] ) ); return buffer; }
byte orderByte = buffer.get(); int typeCode = (int) buffer.getUInt(); if ( rsSrid.next() ) { int crsId = rsSrid.getInt( 1 ); buffer = addCrsId( buffer.toByteArray(), orderByte, typeCode, crsId );
@Override public <P extends Position> ByteBuffer encode(Geometry<P> geometry, ByteOrder byteOrder) { if (geometry == null || hasEmpty(geometry)) return null; //size is size for WKB + 4 bytes for the SRID ByteBuffer output = ByteBuffer.allocate(calculateSize(geometry, false) + 4); if (byteOrder != null) { output.setByteOrder(byteOrder); } output.putInt(geometry.getSRID() == -1 ? 0 : geometry.getSRID()); writeGeometry(geometry, output); output.rewind(); return output; }
/** * Encodes a <code>Geometry</code> into a WKB representation using the specified byte-order. * * @param geometry The <code>Geometry</code> to be encoded as WKB. * @param byteOrder The WKB byte order, either {@link org.geolatte.geom.ByteOrder#XDR XDR} or {@link org.geolatte.geom.ByteOrder#NDR NDR} * @return A buffer of bytes that contains the WKB-encoded <code>Geometry</code>. */ @Override public <P extends Position> ByteBuffer encode(Geometry<P> geometry, ByteOrder byteOrder) { ByteBuffer output = ByteBuffer.allocate(calculateSize(geometry, true)); if (byteOrder != null) { output.setByteOrder(byteOrder); } writeGeometry(geometry, output); output.rewind(); return output; }
@Override protected void writeTypeCodeAndSrid(Geometry<P> geometry, ByteBuffer output) { int typeCode = getGeometryType(geometry); CoordinateReferenceSystem<P> crs = geometry.getCoordinateReferenceSystem(); if (!this.hasWrittenSrid) { typeCode |= PostgisWkbTypeMasks.SRID_FLAG; } if (hasMeasureAxis(crs)) { typeCode |= PostgisWkbTypeMasks.M_FLAG; } if (hasVerticalAxis(crs)) { typeCode |= PostgisWkbTypeMasks.Z_FLAG; } output.putUInt(typeCode); if (!this.hasWrittenSrid) { int srid = geometry.getSRID(); // Write the SRID, the HANA default SRID is 0 output.putInt(srid < 0 ? 0 : srid); this.hasWrittenSrid = true; } }
/** * Used for testing purposes. * * @param other another <code>ByteBuffer</code> * @return true if both buffers contain the same bytes, false otherwise */ public boolean hasSameContent(ByteBuffer other) { if (other == null) return false; if (this.limit() != other.limit()) return false; int thisSavedPosition = this.buffer.position(); int otherSavedPosition = other.buffer.position(); this.rewind(); other.rewind(); for (int i = 0; i < this.limit(); i++) { if (this.get() != other.get()) return false; } this.buffer.position(thisSavedPosition); other.buffer.position(otherSavedPosition); return true; }
private void alignByteOrder(ByteBuffer byteBuffer) { byte orderByte = byteBuffer.get(); ByteOrder byteOrder = ByteOrder.valueOf(orderByte); byteBuffer.setByteOrder(byteOrder); } }
protected void writeByteOrder(ByteBuffer output) { output.put(output.getByteOrder().byteValue()); }
private int readByte() { int hexValue = get(); hexValue = (hexValue << 24) >>> 24; return hexValue; }
protected int readTypeCode(ByteBuffer byteBuffer) { return (int) byteBuffer.getUInt(); }
protected void writeTypeCodeAndSrid(Geometry<P> geometry, ByteBuffer output) { int typeCode = getGeometryType(geometry); boolean hasSrid = (geometry.getSRID() > 0); CoordinateReferenceSystem<P> crs = geometry.getCoordinateReferenceSystem(); if (hasSrid && !hasWrittenSrid) { typeCode |= PostgisWkbTypeMasks.SRID_FLAG; } if (hasMeasureAxis(crs)) { typeCode |= PostgisWkbTypeMasks.M_FLAG; } if (hasVerticalAxis(crs)) { typeCode |= PostgisWkbTypeMasks.Z_FLAG; } output.putUInt(typeCode); if (hasSrid && !hasWrittenSrid) { output.putInt(geometry.getSRID()); hasWrittenSrid = true; } }
private static ByteBuffer toByteBuffer(Blob blob) { final ByteArrayOutputStream baos = new ByteArrayOutputStream(); final byte[] buf = new byte[1024]; InputStream in = null; try { in = blob.getBinaryStream(); int n = 0; while ( ( n = in.read( buf ) ) >= 0 ) { baos.write( buf, 0, n ); } } catch (Exception e) { LOGGER.warn( "Could not convert database BLOB object to binary stream.", e ); } finally { try { if ( in != null ) { in.close(); } } catch (IOException e) { LOGGER.warn( "Could not close binary stream." ); } } return ByteBuffer.from( baos.toByteArray() ); } }
/** * Encode the specified {@code Geometry} into a WKB * * @param geometry The value to encode * * @return A byte-array representing the geometry in WKB. */ public static byte[] to(Geometry geometry) { final WkbEncoder encoder = Wkb.newEncoder( Wkb.Dialect.POSTGIS_EWKB_1 ); final ByteBuffer buffer = encoder.encode( geometry, ByteOrder.NDR ); return ( buffer == null ? null : buffer.toByteArray() ); }
public static Geometry<?> toGeometry(Object object) { if ( object == null ) { return null; } ByteBuffer buffer = null; if ( object instanceof PGobject ) { String pgValue = ( (PGobject) object ).getValue(); if ( pgValue.startsWith( "00" ) || pgValue.startsWith( "01" ) ) { //we have a WKB because this pgValue starts with the bit-order byte buffer = ByteBuffer.from( pgValue ); final WkbDecoder decoder = Wkb.newDecoder( Wkb.Dialect.POSTGIS_EWKB_1 ); return decoder.decode( buffer ); } else { return parseWkt( pgValue ); } } throw new IllegalStateException( "Received object of type " + object.getClass().getCanonicalName() ); }
@Override protected void doBind(PreparedStatement st, X value, int index, WrapperOptions options) throws SQLException { final WkbEncoder encoder = Wkb.newEncoder( Wkb.Dialect.MYSQL_WKB ); final Geometry geometry = getJavaDescriptor().unwrap( value, Geometry.class, options ); final ByteBuffer buffer = encoder.encode( geometry, ByteOrder.NDR ); final byte[] bytes = ( buffer == null ? null : buffer.toByteArray() ); st.setBytes( index, bytes ); }
@Override protected Geometry decode(Object o) { return JTS.to( Wkb.fromWkb( ByteBuffer.from( (byte[]) o ) ) ); } }
@Override protected void doBind(CallableStatement st, X value, String name, WrapperOptions options) throws SQLException { final WkbEncoder encoder = Wkb.newEncoder( Wkb.Dialect.MYSQL_WKB ); final Geometry geometry = getJavaDescriptor().unwrap( value, Geometry.class, options ); final ByteBuffer buffer = encoder.encode( geometry, ByteOrder.NDR ); final byte[] bytes = ( buffer == null ? null : buffer.toByteArray() ); st.setBytes( name, bytes ); } };