public int getObjectSize(byte[] stream, int startPosition) { final byte serializerId = stream[startPosition]; init(serializerId); return OBinarySerializerFactory.TYPE_IDENTIFIER_SIZE + binarySerializer .getObjectSize(stream, startPosition + OBinarySerializerFactory.TYPE_IDENTIFIER_SIZE); }
default byte[] serializeNativeAsWhole(T object, Object... hints) { final byte[] result = new byte[getObjectSize(object, hints)]; serializeNativeObject(object, result, 0, hints); return result; } }
public int getObjectSize(T key, Object... hints) { init(key, hints); return OBinarySerializerFactory.TYPE_IDENTIFIER_SIZE + binarySerializer.getObjectSize(key); }
private <K, V> void serialize(Map<K, V> map, byte[] stream, int offset, OBinarySerializer<K> keySerializer, OBinarySerializer<V> valueSerializer) { OIntegerSerializer.INSTANCE.serializeLiteral(map.size(), stream, offset); offset += OIntegerSerializer.INT_SIZE; for (Map.Entry<K, V> entry : map.entrySet()) { keySerializer.serialize(entry.getKey(), stream, offset); offset += keySerializer.getObjectSize(entry.getKey()); valueSerializer.serialize(entry.getValue(), stream, offset); offset += valueSerializer.getObjectSize(entry.getValue()); } } }
private <K, V> void serialize(Map<K, V> map, byte[] stream, int offset, OBinarySerializer<K> keySerializer, OBinarySerializer<V> valueSerializer) { OIntegerSerializer.INSTANCE.serialize(map.size(), stream, offset); offset += OIntegerSerializer.INT_SIZE; for (Map.Entry<K, V> entry : map.entrySet()) { keySerializer.serialize(entry.getKey(), stream, offset); offset += keySerializer.getObjectSize(entry.getKey()); valueSerializer.serialize(entry.getValue(), stream, offset); offset += valueSerializer.getObjectSize(entry.getValue()); } }
@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); } }
public <K extends OIdentifiable> void serializeChanges(Map<K, Change> changes, OBinarySerializer<K> keySerializer, byte[] stream, int offset) { OIntegerSerializer.INSTANCE.serializeLiteral(changes.size(), stream, offset); offset += OIntegerSerializer.INT_SIZE; for (Map.Entry<K, Change> entry : changes.entrySet()) { K key = entry.getKey(); if (key.getIdentity().isTemporary()) //noinspection unchecked key = key.getRecord(); keySerializer.serialize(key, stream, offset); offset += keySerializer.getObjectSize(key); offset += entry.getValue().serialize(stream, offset); } }
private void writeNameIdEntry(final FileChannel nameIdMapHolder, final NameFileIdEntry nameFileIdEntry, final boolean sync) throws IOException { final int nameSize = stringSerializer.getObjectSize(nameFileIdEntry.name); final int fileNameSize = stringSerializer.getObjectSize(nameFileIdEntry.fileSystemName); //file id size + file name size + file name + file system name size + file system name final ByteBuffer serializedRecord = ByteBuffer.allocate(3 * OIntegerSerializer.INT_SIZE + nameSize + fileNameSize); //serialize file id OIntegerSerializer.INSTANCE.serializeInByteBufferObject(nameFileIdEntry.fileId, serializedRecord, 0); //serialize file name OIntegerSerializer.INSTANCE.serializeInByteBufferObject(nameSize, serializedRecord, OIntegerSerializer.INT_SIZE); stringSerializer.serializeInByteBufferObject(nameFileIdEntry.name, serializedRecord, 2 * OIntegerSerializer.INT_SIZE); //serialize file system name OIntegerSerializer.INSTANCE .serializeInByteBufferObject(fileNameSize, serializedRecord, 2 * OIntegerSerializer.INT_SIZE + nameSize); stringSerializer .serializeInByteBufferObject(nameFileIdEntry.fileSystemName, serializedRecord, 3 * OIntegerSerializer.INT_SIZE + nameSize); serializedRecord.position(0); OIOUtils.writeByteBuffer(serializedRecord, nameIdMapHolder, nameIdMapHolder.size()); nameIdMapHolder.write(serializedRecord); if (sync) { nameIdMapHolder.force(true); } }
@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); }
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); }
public int getObjectSize(OCompositeKey compositeKey, Object... hints) { final OType[] types = getKeyTypes(hints); final List<Object> keys = compositeKey.getKeys(); int size = 2 * OIntegerSerializer.INT_SIZE; final OBinarySerializerFactory factory = OBinarySerializerFactory.getInstance(); for (int i = 0; i < keys.size(); i++) { final Object key = keys.get(i); if (key != null) { final OType type; if (types.length > i) type = types[i]; else type = OType.getTypeByClass(key.getClass()); size += OBinarySerializerFactory.TYPE_IDENTIFIER_SIZE + factory.getObjectSerializer(type).getObjectSize(key); } else { size += OBinarySerializerFactory.TYPE_IDENTIFIER_SIZE + ONullSerializer.INSTANCE.getObjectSize(null); } } return size; }
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 serialize(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.serializeLiteral(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.serialize(key, stream, startPosition); startPosition += binarySerializer.getObjectSize(key); } OIntegerSerializer.INSTANCE.serializeLiteral((startPosition - oldStartPosition), stream, oldStartPosition); }
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); }
@SuppressWarnings("unchecked") public OCompositeKey deserialize(byte[] stream, int startPosition) { final OCompositeKey compositeKey = new OCompositeKey(); startPosition += OIntegerSerializer.INT_SIZE; final int keysSize = OIntegerSerializer.INSTANCE.deserializeLiteral(stream, startPosition); startPosition += OIntegerSerializer.INSTANCE.getObjectSize(keysSize); final OBinarySerializerFactory factory = OBinarySerializerFactory.getInstance(); for (int i = 0; i < keysSize; i++) { final byte serializerId = stream[startPosition]; startPosition += OBinarySerializerFactory.TYPE_IDENTIFIER_SIZE; OBinarySerializer<Object> binarySerializer = (OBinarySerializer<Object>) factory.getObjectSerializer(serializerId); final Object key = binarySerializer.deserialize(stream, startPosition); compositeKey.addKey(key); startPosition += binarySerializer.getObjectSize(key); } return compositeKey; }
public OCompositeKey deserializeNativeObject(byte[] stream, int startPosition) { final OCompositeKey compositeKey = new OCompositeKey(); startPosition += OIntegerSerializer.INT_SIZE; final int keysSize = OIntegerSerializer.INSTANCE.deserializeNative(stream, startPosition); startPosition += OIntegerSerializer.INSTANCE.getObjectSize(keysSize); final OBinarySerializerFactory factory = OBinarySerializerFactory.getInstance(); for (int i = 0; i < keysSize; i++) { final byte serializerId = stream[startPosition]; startPosition += OBinarySerializerFactory.TYPE_IDENTIFIER_SIZE; @SuppressWarnings("unchecked") OBinarySerializer<Object> binarySerializer = (OBinarySerializer<Object>) factory.getObjectSerializer(serializerId); final Object key = binarySerializer.deserializeNativeObject(stream, startPosition); compositeKey.addKey(key); startPosition += binarySerializer.getObjectSize(key); } return compositeKey; }
/** * {@inheritDoc} */ @Override public OCompositeKey deserializeFromByteBufferObject(ByteBuffer buffer, OWALChanges walChanges, int offset) { final OCompositeKey compositeKey = new OCompositeKey(); offset += OIntegerSerializer.INT_SIZE; final int keysSize = walChanges.getIntValue(buffer, offset); offset += OIntegerSerializer.INT_SIZE; final OBinarySerializerFactory factory = OBinarySerializerFactory.getInstance(); for (int i = 0; i < keysSize; i++) { final byte serializerId = walChanges.getByteValue(buffer, offset); offset += OBinarySerializerFactory.TYPE_IDENTIFIER_SIZE; @SuppressWarnings("unchecked") OBinarySerializer<Object> binarySerializer = (OBinarySerializer<Object>) factory.getObjectSerializer(serializerId); final Object key = binarySerializer.deserializeFromByteBufferObject(buffer, walChanges, offset); compositeKey.addKey(key); offset += binarySerializer.getObjectSize(key); } return compositeKey; }
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); } }