public <K, V> int length(Map<K, V> map, OBinarySerializer<K> keySerializer, OBinarySerializer<V> valueSerializer) { int mapSize = map.size(); int length = OIntegerSerializer.INT_SIZE; assert keySerializer.isFixedLength(); length += mapSize * keySerializer.getFixedLength(); assert valueSerializer.isFixedLength(); length += mapSize * valueSerializer.getFixedLength(); return length; } }
default byte[] serializeNativeAsWhole(T object, Object... hints) { final byte[] result = new byte[getObjectSize(object, hints)]; serializeNativeObject(object, result, 0, hints); return result; } }
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()); } } }
public boolean addEntry(int index, SBTreeEntry<K, V> treeEntry, boolean updateNeighbors) throws IOException { final int keySize = keySerializer.getObjectSize(treeEntry.key); int valueSize = 0; int entrySize = keySize; assert valueSerializer.isFixedLength(); valueSize = valueSerializer.getFixedLength(); 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);
key = keySerializer.preprocess(key, (Object[]) keyTypes); final byte[] serializedKey = keySerializer.serializeNativeAsWhole(key, (Object[]) keyTypes); oldValue = null; } else { oldValue = valueSerializer.deserializeNativeObject(oldRawValue, 0); final int valueSize = valueSerializer.getObjectSize(value); final byte[] serializeValue = new byte[valueSize]; valueSerializer.serializeNativeObject(value, serializeValue, 0); if (updatedValue.isChange()) { final V value = updatedValue.getValue(); final int valueSize = valueSerializer.getObjectSize(value); final boolean createLinkToTheValue = valueSize > MAX_EMBEDDED_VALUE_SIZE;
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 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); }
@Override public String toString() { return "ORuntimeKeyIndexDefinition{" + "serializer=" + serializer.getId() + '}'; }
private K deserializeKey(final byte[] serializedKey) { if (encryption == null) { return keySerializer.deserializeNativeObject(serializedKey, 0); } final byte[] decrypted = encryption .decrypt(serializedKey, OIntegerSerializer.INT_SIZE, serializedKey.length - OIntegerSerializer.INT_SIZE); return keySerializer.deserializeNativeObject(decrypted, 0); }
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); } }
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); }
@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; }
private boolean put(K key, V value, OBaseIndexEngine.Validator<K, V> validator) throws IOException { boolean rollback = false; final OAtomicOperation atomicOperation = startAtomicOperation(true); try { acquireExclusiveLock(); try { checkNullSupport(key); if (key != null) { final int keySize = keySerializer.getObjectSize(key, (Object[]) keyTypes); if (keySize > MAX_KEY_SIZE) { throw new OTooBigIndexKeyException( "Key size is more than allowed, operation was canceled. Current key size " + keySize + ", allowed " + MAX_KEY_SIZE, getName()); } } key = keySerializer.preprocess(key, (Object[]) keyTypes); final boolean putResult = doPut(key, value, validator, atomicOperation); return putResult; } finally { releaseExclusiveLock(); } } catch (final Exception e) { rollback = true; throw e; } finally { endAtomicOperation(rollback); } }
public boolean addEntry(final int index, final SBTreeEntry<K> treeEntry, final boolean updateNeighbors) { final byte[] serializedKey = keySerializer.serializeNativeAsWhole(treeEntry.key, (Object[]) keyTypes); final int keySize; byte[] encryptedKey = null; keySize = keySerializer.getObjectSize(treeEntry.key, (Object[]) keyTypes); } else { encryptedKey = encryption.encrypt(serializedKey);
/** * {@inheritDoc} */ @Override public void serializeInByteBufferObject(T object, ByteBuffer buffer, Object... hints) { init(object, hints); buffer.put(binarySerializer.getId()); binarySerializer.serializeInByteBufferObject(object, buffer); }
public boolean isFixedLength() { return binarySerializer.isFixedLength(); }