/** * This method sets the subnetwork if of the specified nodeId. Default is 0 and means subnetwork * was too small to be useful to be stored. */ public void setSubnetwork(int nodeId, int subnetwork) { if (subnetwork > 127) throw new IllegalArgumentException("Number of subnetworks is currently limited to 127 but requested " + subnetwork); byte[] bytes = new byte[1]; bytes[0] = (byte) subnetwork; da.setBytes(nodeId, bytes, bytes.length); }
@Override public synchronized void flush() { try { StringWriter sw = new StringWriter(); saveProperties(map, sw); // TODO at the moment the size is limited to da.segmentSize() ! byte[] bytes = sw.toString().getBytes(UTF_CS); da.setBytes(0, bytes, bytes.length); da.flush(); } catch (IOException ex) { throw new RuntimeException(ex); } }
/** * @return the byte pointer to the name */ public long put(String name) { if (name == null || name.isEmpty()) { return 0; } if (name.equals(lastName)) { return lastIndex; } byte[] bytes = getBytes(name); long oldPointer = bytePointer; names.ensureCapacity(bytePointer + 1 + bytes.length); byte[] sizeBytes = new byte[]{ (byte) bytes.length }; names.setBytes(bytePointer, sizeBytes, sizeBytes.length); bytePointer++; names.setBytes(bytePointer, bytes, bytes.length); bytePointer += bytes.length; lastName = name; lastIndex = oldPointer; return oldPointer; }
private void setWayGeometryAtGeoRef(PointList pillarNodes, long edgePointer, boolean reverse, long geoRef) { int len = pillarNodes.getSize(); int dim = nodeAccess.getDimension(); long geoRefPosition = (long) geoRef * 4; int totalLen = len * dim * 4 + 4; ensureGeometry(geoRefPosition, totalLen); byte[] wayGeometryBytes = createWayGeometryBytes(pillarNodes, reverse); wayGeometry.setBytes(geoRefPosition, wayGeometryBytes, wayGeometryBytes.length); edges.setInt(edgePointer + E_GEO, Helper.toSignedInt(geoRef)); }
@Override public int put(long key, int value) { if (key <= lastKey) { long oldValueIndex = binarySearch(keys, 0, getSize(), key); if (oldValueIndex < 0) { throw new IllegalStateException("Cannot insert keys lower than " + "the last key " + key + " < " + lastKey + ". Only updating supported"); } oldValueIndex *= 4; int oldValue = values.getInt(oldValueIndex); values.setInt(oldValueIndex, value); return oldValue; } values.ensureCapacity(size + 4); values.setInt(size, value); long doubleSize = size * 2; keys.ensureCapacity(doubleSize + 8); // store long => double of the orig size byte[] longBytes = bitUtil.fromLong(key); keys.setBytes(doubleSize, longBytes, 8); lastKey = key; size += 4; return -1; }
@Override public DataAccess copyTo(DataAccess da) { copyHeader(da); da.ensureCapacity(getCapacity()); long cap = getCapacity(); // currently get/setBytes does not support copying more bytes then segmentSize int segSize = Math.min(da.getSegmentSize(), getSegmentSize()); byte[] bytes = new byte[segSize]; boolean externalIntBased = ((AbstractDataAccess) da).isIntBased(); for (long bytePos = 0; bytePos < cap; bytePos += segSize) { // read if (isIntBased()) { for (int offset = 0; offset < segSize; offset += 4) { bitUtil.fromInt(bytes, getInt(bytePos + offset), offset); } } else { getBytes(bytePos, bytes, segSize); } // write if (externalIntBased) { for (int offset = 0; offset < segSize; offset += 4) { da.setInt(bytePos + offset, bitUtil.toInt(bytes, offset)); } } else { da.setBytes(bytePos, bytes, segSize); } } return da; }
@Test public void testSet_GetBytes() { DataAccess da = createDataAccess(name); da.create(300); assertEquals(128, da.getSegmentSize()); byte[] bytes = BitUtil.BIG.fromInt(Integer.MAX_VALUE / 3); da.setBytes(8, bytes, bytes.length); bytes = new byte[4]; da.getBytes(8, bytes, bytes.length); assertEquals(Integer.MAX_VALUE / 3, BitUtil.BIG.toInt(bytes)); da.setBytes(127, bytes, bytes.length); da.getBytes(127, bytes, bytes.length); assertEquals(Integer.MAX_VALUE / 3, BitUtil.BIG.toInt(bytes)); da.close(); long bytePos = 4294967296L + 11111; int segmentSizePower = 24; int segmentSizeInBytes = 1 << segmentSizePower; int indexDivisor = segmentSizeInBytes - 1; int bufferIndex = (int) (bytePos >>> segmentSizePower); int index = (int) (bytePos & indexDivisor); assertEquals(256, bufferIndex); assertEquals(11111, index); }
@Override public synchronized void setBytes( long bytePos, byte[] values, int length ) { inner.setBytes(bytePos, values, length); }
@Override public synchronized void setBytes(long bytePos, byte[] values, int length) { inner.setBytes(bytePos, values, length); }
/** * This method sets the subnetwork if of the specified nodeId. Default is 0 and means subnetwork * was too small to be useful to be stored. */ public void setSubnetwork(int nodeId, int subnetwork) { if (subnetwork > 127) throw new IllegalArgumentException("Number of subnetworks is currently limited to 127 but requested " + subnetwork); byte[] bytes = new byte[1]; bytes[0] = (byte) subnetwork; da.setBytes(nodeId, bytes, bytes.length); }
/** * This method sets the subnetwork if of the specified nodeId. Default is 0 and means subnetwork * was too small to be useful to be stored. */ public void setSubnetwork(int nodeId, int subnetwork) { if (subnetwork > 127) throw new IllegalArgumentException("Number of subnetworks is currently limited to 127 but requested " + subnetwork); byte[] bytes = new byte[1]; bytes[0] = (byte) subnetwork; da.setBytes(nodeId, bytes, bytes.length); }
@Override public synchronized void flush() { try { StringWriter sw = new StringWriter(); Helper.saveProperties(map, sw); // TODO at the moment the size is limited to da.segmentSize() ! byte[] bytes = sw.toString().getBytes(Helper.UTF_CS); da.setBytes(0, bytes, bytes.length); da.flush(); } catch (IOException ex) { throw new RuntimeException(ex); } }
@Override public synchronized void flush() { try { StringWriter sw = new StringWriter(); saveProperties(map, sw); // TODO at the moment the size is limited to da.segmentSize() ! byte[] bytes = sw.toString().getBytes(UTF_CS); da.setBytes(0, bytes, bytes.length); da.flush(); } catch (IOException ex) { throw new RuntimeException(ex); } }
/** * @return the byte pointer to the name */ public long put(String name) { if (name == null || name.isEmpty()) { return 0; } if (name.equals(lastName)) { return lastIndex; } byte[] bytes = getBytes(name); long oldPointer = bytePointer; names.ensureCapacity(bytePointer + 1 + bytes.length); byte[] sizeBytes = new byte[]{ (byte) bytes.length }; names.setBytes(bytePointer, sizeBytes, sizeBytes.length); bytePointer++; names.setBytes(bytePointer, bytes, bytes.length); bytePointer += bytes.length; lastName = name; lastIndex = oldPointer; return oldPointer; }
/** * @return the byte pointer to the name */ public long put(String name) { if (name == null || name.isEmpty()) { return 0; } if (name.equals(lastName)) { return lastIndex; } byte[] bytes = getBytes(name); long oldPointer = bytePointer; names.ensureCapacity(bytePointer + 1 + bytes.length); byte[] sizeBytes = new byte[]{ (byte) bytes.length }; names.setBytes(bytePointer, sizeBytes, sizeBytes.length); bytePointer++; names.setBytes(bytePointer, bytes, bytes.length); bytePointer += bytes.length; lastName = name; lastIndex = oldPointer; return oldPointer; }
@Override public void flush() { try { StringWriter sw = new StringWriter(); Helper.saveProperties(map, sw); // TODO at the moment the size is limited to da.segmentSize() ! byte[] bytes = sw.toString().getBytes(Helper.UTF_CS); da.setBytes(0, bytes, bytes.length); da.flush(); } catch (IOException ex) { throw new RuntimeException(ex); } }
private void setWayGeometryAtGeoRef(PointList pillarNodes, long edgePointer, boolean reverse, long geoRef) { int len = pillarNodes.getSize(); int dim = nodeAccess.getDimension(); long geoRefPosition = (long) geoRef * 4; int totalLen = len * dim * 4 + 4; ensureGeometry(geoRefPosition, totalLen); byte[] wayGeometryBytes = createWayGeometryBytes(pillarNodes, reverse); wayGeometry.setBytes(geoRefPosition, wayGeometryBytes, wayGeometryBytes.length); edges.setInt(edgePointer + E_GEO, Helper.toSignedInt(geoRef)); }
private void setWayGeometryAtGeoRef(PointList pillarNodes, long edgePointer, boolean reverse, long geoRef) { int len = pillarNodes.getSize(); int dim = nodeAccess.getDimension(); long geoRefPosition = (long) geoRef * 4; int totalLen = len * dim * 4 + 4; ensureGeometry(geoRefPosition, totalLen); byte[] wayGeometryBytes = createWayGeometryBytes(pillarNodes, reverse); wayGeometry.setBytes(geoRefPosition, wayGeometryBytes, wayGeometryBytes.length); edges.setInt(edgePointer + E_GEO, Helper.toSignedInt(geoRef)); }
@Override public int put(long key, int value) { if (key <= lastKey) { long oldValueIndex = binarySearch(keys, 0, getSize(), key); if (oldValueIndex < 0) { throw new IllegalStateException("Cannot insert keys lower than " + "the last key " + key + " < " + lastKey + ". Only updating supported"); } oldValueIndex *= 4; int oldValue = values.getInt(oldValueIndex); values.setInt(oldValueIndex, value); return oldValue; } values.ensureCapacity(size + 4); values.setInt(size, value); long doubleSize = size * 2; keys.ensureCapacity(doubleSize + 8); // store long => double of the orig size byte[] longBytes = bitUtil.fromLong(key); keys.setBytes(doubleSize, longBytes, 8); lastKey = key; size += 4; return -1; }
@Override public int put(long key, int value) { if (key <= lastKey) { long oldValueIndex = binarySearch(keys, 0, getSize(), key); if (oldValueIndex < 0) { throw new IllegalStateException("Cannot insert keys lower than " + "the last key " + key + " < " + lastKey + ". Only updating supported"); } oldValueIndex *= 4; int oldValue = values.getInt(oldValueIndex); values.setInt(oldValueIndex, value); return oldValue; } values.ensureCapacity(size + 4); values.setInt(size, value); long doubleSize = size * 2; keys.ensureCapacity(doubleSize + 8); // store long => double of the orig size byte[] longBytes = bitUtil.fromLong(key); keys.setBytes(doubleSize, longBytes, 8); lastKey = key; size += 4; return -1; }