default byte[] serializeNativeAsWhole(T object, Object... hints) { final byte[] result = new byte[getObjectSize(object, hints)]; serializeNativeObject(object, result, 0, hints); return result; } }
public void serializeNativeObject(T key, byte[] stream, int startPosition, Object... hints) { init(key, hints); stream[startPosition] = binarySerializer.getId(); startPosition += OBinarySerializerFactory.TYPE_IDENTIFIER_SIZE; binarySerializer.serializeNativeObject(key, stream, startPosition); }
@Override public long hashCode(final V value) { final byte[] serializedValue = new byte[valueSerializer.getObjectSize(value)]; valueSerializer.serializeNativeObject(value, serializedValue, 0); return OMurmurHash3.murmurHash3_x64_64(serializedValue, SEED); } }
@Override public long hashCode(V value) { final byte[] serializedValue = new byte[valueSerializer.getObjectSize(value)]; valueSerializer.serializeNativeObject(value, serializedValue, 0); final byte[] digest = MessageDigestHolder.instance().get().digest(serializedValue); return OLongSerializer.INSTANCE.deserializeNative(digest, 0); } }
public void setValue(V value) throws IOException { setByteValue(NEXT_FREE_POSITION, (byte) 1); final int valueSize = valueSerializer.getObjectSize(value); final byte[] serializedValue = new byte[valueSize]; valueSerializer.serializeNativeObject(value, serializedValue, 0); setBinaryValue(NEXT_FREE_POSITION + 1, serializedValue); }
private void serializeEntry(long hashCode, K key, V value, int entryOffset, byte[] encryptedKey) throws IOException { setLongValue(entryOffset, hashCode); entryOffset += OLongSerializer.LONG_SIZE; if (encryptedKey == null) { final int keySize = keySerializer.getObjectSize(key, (Object[]) keyTypes); byte[] binaryKey = new byte[keySize]; keySerializer.serializeNativeObject(key, binaryKey, 0, (Object[]) keyTypes); setBinaryValue(entryOffset, binaryKey); entryOffset += keySize; } else { setIntValue(entryOffset, encryptedKey.length); entryOffset += OIntegerSerializer.INT_SIZE; setBinaryValue(entryOffset, encryptedKey); entryOffset += encryptedKey.length; } final int valueSize = valueSerializer.getObjectSize(value); final byte[] binaryValue = new byte[valueSize]; valueSerializer.serializeNativeObject(value, binaryValue, 0); setBinaryValue(entryOffset, binaryValue); }
public void serializeNativeObject(OCompositeKey compositeKey, byte[] stream, int startPosition, Object... hints) { final OType[] types = getKeyTypes(hints); final List<Object> keys = compositeKey.getKeys(); final int keysSize = keys.size(); final int oldStartPosition = startPosition; startPosition += OIntegerSerializer.INT_SIZE; OIntegerSerializer.INSTANCE.serializeNative(keysSize, stream, startPosition); startPosition += OIntegerSerializer.INT_SIZE; final OBinarySerializerFactory factory = OBinarySerializerFactory.getInstance(); for (int i = 0; i < keys.size(); i++) { final Object key = keys.get(i); OBinarySerializer<Object> binarySerializer; if (key != null) { final OType type; if (types.length > i) type = types[i]; else type = OType.getTypeByClass(key.getClass()); binarySerializer = factory.getObjectSerializer(type); } else binarySerializer = ONullSerializer.INSTANCE; stream[startPosition] = binarySerializer.getId(); startPosition += OBinarySerializerFactory.TYPE_IDENTIFIER_SIZE; binarySerializer.serializeNativeObject(key, stream, startPosition); startPosition += binarySerializer.getObjectSize(key); } OIntegerSerializer.INSTANCE.serializeNative((startPosition - oldStartPosition), stream, oldStartPosition); }
public int updateValue(int index, V value) throws IOException { assert valueSerializer.isFixedLength(); int entryPosition = getIntValue(offset + index * OIntegerSerializer.INT_SIZE + POSITIONS_ARRAY_OFFSET); entryPosition += getObjectSizeInDirectMemory(keySerializer, offset + entryPosition); final int size = valueSerializer.getFixedLength(); byte[] serializedValue = new byte[size]; valueSerializer.serializeNativeObject(value, serializedValue, 0); byte[] oldSerializedValue = getBinaryValue(offset + entryPosition, size); if (ODefaultComparator.INSTANCE.compare(oldSerializedValue, serializedValue) == 0) return 0; setBinaryValue(offset + entryPosition, serializedValue); return 1; }
public boolean addEntry(long hashCode, K key, V value) throws IOException { int entreeSize; byte[] encryptedKey = null; if (encryption == null) { entreeSize = keySerializer.getObjectSize(key, (Object[]) keyTypes) + valueSerializer.getObjectSize(value) + OLongSerializer.LONG_SIZE; } else { final int keySize = keySerializer.getObjectSize(key, (Object[]) keyTypes); final byte[] serializedKey = new byte[keySize]; keySerializer.serializeNativeObject(key, serializedKey, 0, (Object[]) keyTypes); encryptedKey = encryption.encrypt(serializedKey); entreeSize = encryptedKey.length + OIntegerSerializer.INT_SIZE + valueSerializer.getObjectSize(value) + OLongSerializer.LONG_SIZE; } int freePointer = getIntValue(FREE_POINTER_OFFSET); int size = size(); if (freePointer - entreeSize < POSITIONS_ARRAY_OFFSET + (size + 1) * OIntegerSerializer.INT_SIZE) return false; final int index = binarySearch(key, hashCode); if (index >= 0) throw new IllegalArgumentException("Given value is present in bucket."); final int insertionPoint = -index - 1; insertEntry(hashCode, key, value, insertionPoint, entreeSize, encryptedKey); return true; }
public int updateEntry(int index, V value) throws IOException { int entryPosition = getIntValue(POSITIONS_ARRAY_OFFSET + index * OIntegerSerializer.INT_SIZE); entryPosition += OLongSerializer.LONG_SIZE; if (encryption == null) { entryPosition += getObjectSizeInDirectMemory(keySerializer, entryPosition); } else { final int encryptedSize = getIntValue(entryPosition); entryPosition += OIntegerSerializer.INT_SIZE + encryptedSize; } final int newSize = valueSerializer.getObjectSize(value); final int oldSize = getObjectSizeInDirectMemory(valueSerializer, entryPosition); if (newSize != oldSize) return -1; byte[] newSerializedValue = new byte[newSize]; valueSerializer.serializeNativeObject(value, newSerializedValue, 0); byte[] oldSerializedValue = getBinaryValue(entryPosition, oldSize); if (ODefaultComparator.INSTANCE.compare(oldSerializedValue, newSerializedValue) == 0) return 0; setBinaryValue(entryPosition, newSerializedValue); return 1; }
public void setValue(OSBTreeValue<V> value) throws IOException { setByteValue(NEXT_FREE_POSITION, (byte) 1); if (value.isLink()) { setByteValue(NEXT_FREE_POSITION + 1, (byte) 0); setLongValue(NEXT_FREE_POSITION + 2, value.getLink()); } else { final int valueSize = valueSerializer.getObjectSize(value.getValue()); final byte[] serializedValue = new byte[valueSize]; valueSerializer.serializeNativeObject(value.getValue(), serializedValue, 0); setByteValue(NEXT_FREE_POSITION + 1, (byte) 1); setBinaryValue(NEXT_FREE_POSITION + 2, serializedValue); } }
keySerializer.serializeNativeObject(treeEntry.key, serializedKey, 0); valueSerializer.serializeNativeObject(treeEntry.value, serializedValue, 0); setBinaryValue(offset + freePointer, serializedValue); keySerializer.serializeNativeObject(treeEntry.key, serializedKey, 0); setBinaryValue(offset + freePointer, serializedKey);
public void appendEntry(long hashCode, K key, V value) throws IOException { final int positionsOffset = size() * OIntegerSerializer.INT_SIZE + POSITIONS_ARRAY_OFFSET; final int entreeSize; byte[] encryptedKey = null; if (encryption == null) { entreeSize = keySerializer.getObjectSize(key, (Object[]) keyTypes) + valueSerializer.getObjectSize(value) + OLongSerializer.LONG_SIZE; } else { final int keySize = keySerializer.getObjectSize(key, (Object[]) keyTypes); final byte[] serializedKey = new byte[keySize]; keySerializer.serializeNativeObject(key, serializedKey, 0, (Object[]) keyTypes); encryptedKey = encryption.encrypt(serializedKey); entreeSize = OIntegerSerializer.INT_SIZE + encryptedKey.length + valueSerializer.getObjectSize(value) + OLongSerializer.LONG_SIZE; } final int freePointer = getIntValue(FREE_POINTER_OFFSET); final int entreePosition = freePointer - entreeSize; setIntValue(positionsOffset, entreePosition); serializeEntry(hashCode, key, value, entreePosition, encryptedKey); setIntValue(FREE_POINTER_OFFSET, freePointer - entreeSize); setIntValue(SIZE_OFFSET, size() + 1); }
private long createLinkToTheValue(final V value, final OAtomicOperation atomicOperation) throws IOException { final byte[] serializeValue = new byte[valueSerializer.getObjectSize(value)]; valueSerializer.serializeNativeObject(value, serializeValue, 0);
OLongSerializer.INSTANCE.serializeNative(treeEntry.value.getLink(), serializedValue, 0); else valueSerializer.serializeNativeObject(treeEntry.value.getValue(), serializedValue, 0);
valueSerializer.serializeNativeObject(value, serializeValue, 0);