949 lines
32 KiB
Java
949 lines
32 KiB
Java
package org.warp.cowdb;
|
|
|
|
import com.esotericsoftware.kryo.Kryo;
|
|
import com.esotericsoftware.kryo.io.Input;
|
|
import com.esotericsoftware.kryo.io.Output;
|
|
import it.unimi.dsi.fastutil.booleans.BooleanArrayList;
|
|
import it.unimi.dsi.fastutil.bytes.ByteArrayList;
|
|
import it.unimi.dsi.fastutil.chars.CharArrayList;
|
|
import it.unimi.dsi.fastutil.ints.IntArrayList;
|
|
import it.unimi.dsi.fastutil.longs.LongArrayList;
|
|
import it.unimi.dsi.fastutil.shorts.ShortArrayList;
|
|
import org.apache.commons.lang3.reflect.FieldUtils;
|
|
import org.warp.jcwdb.ann.*;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.channels.SeekableByteChannel;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.StandardOpenOption;
|
|
import java.util.*;
|
|
import java.util.function.Supplier;
|
|
|
|
import static org.warp.cowdb.IBlocksMetadata.EMPTY_BLOCK_ID;
|
|
|
|
public class Database implements IDatabase {
|
|
|
|
private final DatabaseFileIO fileIO;
|
|
private final DatabaseBlocksIO blocksIO;
|
|
private final DatabaseBlocksMetadata blocksMetadata;
|
|
private final DatabaseReferencesIO referencesIO;
|
|
private final DatabaseReferencesMetadata referencesMetadata;
|
|
private final DatabaseObjectsIO objectsIO;
|
|
private final DatabaseDataInitializer dataInitializer;
|
|
private EnhancedObject loadedRootObject;
|
|
|
|
public Database(Path dataFile, Path blocksMetaFile, Path referencesMetaFile) throws IOException {
|
|
if (Files.notExists(dataFile)) {
|
|
Files.createFile(dataFile);
|
|
}
|
|
if (Files.notExists(blocksMetaFile)) {
|
|
Files.createFile(blocksMetaFile);
|
|
}
|
|
if (Files.notExists(referencesMetaFile)) {
|
|
Files.createFile(referencesMetaFile);
|
|
}
|
|
this.fileIO = new DatabaseFileIO(dataFile);
|
|
this.blocksMetadata = new DatabaseBlocksMetadata(blocksMetaFile);
|
|
this.blocksIO = new DatabaseBlocksIO(fileIO, blocksMetadata);
|
|
this.referencesMetadata = new DatabaseReferencesMetadata(referencesMetaFile);
|
|
this.referencesIO = new DatabaseReferencesIO(blocksIO, referencesMetadata);
|
|
this.objectsIO = new DatabaseObjectsIO(this, referencesIO);
|
|
this.dataInitializer = new DatabaseDataInitializer(objectsIO);
|
|
}
|
|
|
|
@Override
|
|
public IDataInitializer getDataInitializer() {
|
|
return dataInitializer;
|
|
}
|
|
|
|
@Override
|
|
public IObjectsIO getObjectsIO() {
|
|
return objectsIO;
|
|
}
|
|
|
|
@Override
|
|
public void close() throws IOException {
|
|
this.objectsIO.setEnhancedObject(0, loadedRootObject);
|
|
this.referencesMetadata.close();
|
|
this.blocksMetadata.close();
|
|
this.fileIO.close();
|
|
}
|
|
|
|
public <T extends EnhancedObject> T loadRoot(Class<T> type) throws IOException {
|
|
return loadRoot(type, () -> {
|
|
T obj = objectsIO.instantiateEnhancedObject(type);
|
|
dataInitializer.initializeDBObject(obj);
|
|
return obj;
|
|
});
|
|
}
|
|
|
|
public <T extends EnhancedObject> T loadRoot(Class<T> type, SupplierWithIO<T> ifAbsent) throws IOException {
|
|
if (loadedRootObject != null) {
|
|
throw new RuntimeException("Root already set!");
|
|
}
|
|
T root;
|
|
if (referencesMetadata.firstFreeReference > 0) {
|
|
root = objectsIO.loadEnhancedObject(0, type);
|
|
} else {
|
|
if (objectsIO.newNullObject() != 0) {
|
|
throw new IOException("Can't allocate root!");
|
|
} else {
|
|
root = ifAbsent.getWithIO();
|
|
objectsIO.setEnhancedObject(0, root);
|
|
}
|
|
}
|
|
loadedRootObject = root;
|
|
return root;
|
|
}
|
|
|
|
protected void registerClass(Class<?> type, int id) {
|
|
this.objectsIO.registerClass(type, id);
|
|
}
|
|
|
|
public static class DatabaseDataInitializer implements IDataInitializer {
|
|
|
|
private final DatabaseObjectsIO objectsIO;
|
|
|
|
public DatabaseDataInitializer(DatabaseObjectsIO objectsIO) {
|
|
this.objectsIO = objectsIO;
|
|
}
|
|
|
|
@Override
|
|
public void initializeDBObject(EnhancedObject obj) throws IOException {
|
|
initializeDBObjectFields(obj);
|
|
initializeDBObjectProperties(obj);
|
|
obj.initialize();
|
|
}
|
|
|
|
private void initializeDBObjectFields(EnhancedObject obj) throws IOException {
|
|
// Declare the variables needed to get the biggest field Id
|
|
Field[] unorderedFields = objectsIO.getFields(obj);
|
|
// Find the biggest field Id
|
|
int biggestFieldId = objectsIO.getBiggestFieldId(unorderedFields);
|
|
|
|
// Allocate new UIDs
|
|
long[] fieldUIDs = objectsIO.allocateNewUIDs(biggestFieldId + 1);
|
|
|
|
// Declare the other variables
|
|
Field[] fields = new Field[biggestFieldId + 1];
|
|
DBDataType[] orderedFieldTypes = new DBDataType[biggestFieldId + 1];
|
|
|
|
// Load all fields metadata and load them
|
|
for (Field field : unorderedFields) {
|
|
DBField fieldAnnotation = field.getAnnotation(DBField.class);
|
|
int fieldId = fieldAnnotation.id();
|
|
DBDataType fieldType = fieldAnnotation.type();
|
|
objectsIO.loadField(obj, field, fieldType, fieldUIDs[fieldId]);
|
|
fields[fieldId] = field;
|
|
orderedFieldTypes[fieldId] = fieldType;
|
|
}
|
|
// Set fields metadata
|
|
obj.setFields(fields, orderedFieldTypes, fieldUIDs);
|
|
}
|
|
|
|
private void initializeDBObjectProperties(EnhancedObject obj) throws IOException {
|
|
// Declare the variables needed to get the biggest property Id
|
|
Method[] unorderedPropertyGetters = obj.getPropertyGetters();
|
|
Method[] unorderedPropertySetters = obj.getPropertySetters();
|
|
|
|
// Find the biggest property Id
|
|
int biggestGetter = objectsIO.getBiggestPropertyGetterId(unorderedPropertyGetters);
|
|
int biggestSetter = objectsIO.getBiggestPropertySetterId(unorderedPropertySetters);
|
|
int biggestPropertyId = biggestGetter > biggestSetter ? biggestGetter : biggestSetter;
|
|
|
|
// Allocate new UIDs
|
|
long[] propertyUIDs = objectsIO.allocateNewUIDs(biggestPropertyId + 1);
|
|
|
|
for (Method property : unorderedPropertySetters) {
|
|
DBPropertySetter fieldAnnotation = property.getAnnotation(DBPropertySetter.class);
|
|
int propertyId = fieldAnnotation.id();
|
|
if (propertyId > biggestPropertyId) {
|
|
biggestPropertyId = propertyId;
|
|
}
|
|
}
|
|
|
|
// Declare the other variables
|
|
DBDataType[] propertyTypes = new DBDataType[biggestPropertyId + 1];
|
|
Method[] propertyGetters = new Method[biggestPropertyId + 1];
|
|
Method[] propertySetters = new Method[biggestPropertyId + 1];
|
|
Map<String, DBPropertySetter> setterMethods = new LinkedHashMap<>();
|
|
Map<String, DBPropertyGetter> getterMethods = new LinkedHashMap<>();
|
|
|
|
// Load the properties metadata
|
|
for (Method property : unorderedPropertyGetters) {
|
|
DBPropertyGetter propertyAnnotation = property.getAnnotation(DBPropertyGetter.class);
|
|
int propertyId = propertyAnnotation.id();
|
|
DBDataType propertyType = propertyAnnotation.type();
|
|
propertyTypes[propertyId] = propertyType;
|
|
propertyGetters[propertyId] = property;
|
|
getterMethods.put(property.getName(), propertyAnnotation);
|
|
}
|
|
for (Method property : unorderedPropertySetters) {
|
|
DBPropertySetter propertyAnnotation = property.getAnnotation(DBPropertySetter.class);
|
|
int propertyId = propertyAnnotation.id();
|
|
DBDataType propertyType = propertyAnnotation.type();
|
|
propertyTypes[propertyId] = propertyType;
|
|
propertySetters[propertyId] = property;
|
|
setterMethods.put(property.getName(), propertyAnnotation);
|
|
}
|
|
// Set properties metadata
|
|
obj.setProperties(propertyGetters, propertySetters, propertyTypes, propertyUIDs, setterMethods, getterMethods);
|
|
}
|
|
}
|
|
|
|
public static class DatabaseObjectsIO implements IObjectsIO {
|
|
|
|
private final IDatabase database;
|
|
private final DatabaseReferencesIO referencesIO;
|
|
|
|
private final Object accessLock = new Object();
|
|
|
|
private Kryo kryo = new Kryo();
|
|
|
|
private DatabaseObjectsIO(IDatabase database, DatabaseReferencesIO referencesIO) {
|
|
this.database = database;
|
|
this.referencesIO = referencesIO;
|
|
kryo.setRegistrationRequired(false);
|
|
int id = -90;
|
|
registerClass(boolean[].class, id++);
|
|
registerClass(byte[].class, id++);
|
|
registerClass(short[].class, id++);
|
|
registerClass(char[].class, id++);
|
|
registerClass(int[].class, id++);
|
|
registerClass(long[].class, id++);
|
|
registerClass(Boolean[].class, id++);
|
|
registerClass(Byte[].class, id++);
|
|
registerClass(Short[].class, id++);
|
|
registerClass(Character[].class, id++);
|
|
registerClass(Integer[].class, id++);
|
|
registerClass(Long[].class, id++);
|
|
registerClass(String.class, id++);
|
|
registerClass(String[].class, id++);
|
|
registerClass(Boolean.class, id++);
|
|
registerClass(Byte.class, id++);
|
|
registerClass(Short.class, id++);
|
|
registerClass(Character.class, id++);
|
|
registerClass(Integer.class, id++);
|
|
registerClass(Class.class, id++);
|
|
registerClass(Object.class, id++);
|
|
registerClass(Object[].class, id++);
|
|
registerClass(Long.class, id++);
|
|
registerClass(String.class, id++);
|
|
registerClass(String[].class, id++);
|
|
registerClass(boolean[][].class, id++);
|
|
registerClass(byte[][].class, id++);
|
|
registerClass(short[][].class, id++);
|
|
registerClass(char[][].class, id++);
|
|
registerClass(int[][].class, id++);
|
|
registerClass(long[][].class, id++);
|
|
registerClass(String[][].class, id++);
|
|
registerClass(List.class, id++);
|
|
registerClass(ArrayList.class, id++);
|
|
registerClass(LinkedList.class, id++);
|
|
registerClass(Set.class, id++);
|
|
registerClass(HashSet.class, id++);
|
|
registerClass(LinkedHashSet.class, id++);
|
|
registerClass(Map.class, id++);
|
|
registerClass(HashMap.class, id++);
|
|
registerClass(LinkedHashMap.class, id++);
|
|
registerClass(TreeMap.class, id++);
|
|
registerClass(BooleanArrayList.class, id++);
|
|
registerClass(ByteArrayList.class, id++);
|
|
registerClass(ShortArrayList.class, id++);
|
|
registerClass(CharArrayList.class, id++);
|
|
registerClass(IntArrayList.class, id++);
|
|
registerClass(LongArrayList.class, id++);
|
|
registerClass(TreeSet.class, id++);
|
|
registerClass(SortedSet.class, id++);
|
|
registerClass(SortedMap.class, id++);
|
|
}
|
|
|
|
@Override
|
|
public <T extends EnhancedObject> T loadEnhancedObject(long reference, Class<T> objectType) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = referencesIO.readFromReference(reference);
|
|
if (buffer.limit() == 0) {
|
|
return null;
|
|
}
|
|
int fieldsCount = buffer.getInt();
|
|
int methodsCount = buffer.getInt();
|
|
long[] fieldRefs = new long[fieldsCount];
|
|
long[] methodRefs = new long[methodsCount];
|
|
for (int i = 0; i < fieldsCount; i++) {
|
|
fieldRefs[i] = buffer.getLong();
|
|
}
|
|
for (int i = 0; i < methodsCount; i++) {
|
|
methodRefs[i] = buffer.getLong();
|
|
}
|
|
return preloadEnhancedObject(objectType, fieldRefs, methodRefs);
|
|
}
|
|
}
|
|
|
|
|
|
@SuppressWarnings("unchecked")
|
|
private Object loadData(DBDataType propertyType, long dataReference, Supplier<Class<?>> returnType) throws IOException {
|
|
switch (propertyType) {
|
|
case ENHANCED_OBJECT:
|
|
return loadEnhancedObject(dataReference, (Class<? extends EnhancedObject>) returnType.get());
|
|
case OBJECT:
|
|
return loadObject(dataReference);
|
|
case REFERENCES_LIST:
|
|
return loadReferencesList(dataReference);
|
|
case BOOLEAN:
|
|
return loadBoolean(dataReference);
|
|
case BYTE:
|
|
return loadByte(dataReference);
|
|
case SHORT:
|
|
return loadShort(dataReference);
|
|
case CHAR:
|
|
return loadChar(dataReference);
|
|
case INTEGER:
|
|
return loadInt(dataReference);
|
|
case LONG:
|
|
return loadLong(dataReference);
|
|
default:
|
|
throw new NullPointerException("Unknown data type");
|
|
}
|
|
}
|
|
|
|
private <T> void setData(long reference, DBDataType propertyType, T loadedPropertyValue) throws IOException {
|
|
switch (propertyType) {
|
|
case BOOLEAN:
|
|
setBoolean(reference, loadedPropertyValue != null && (boolean) loadedPropertyValue);
|
|
break;
|
|
case BYTE:
|
|
setByte(reference, loadedPropertyValue == null ? 0 : (byte) loadedPropertyValue);
|
|
break;
|
|
case SHORT:
|
|
setShort(reference, loadedPropertyValue == null ? 0 : (short) loadedPropertyValue);
|
|
break;
|
|
case CHAR:
|
|
setChar(reference, loadedPropertyValue == null ? 0 : (char) loadedPropertyValue);
|
|
break;
|
|
case INTEGER:
|
|
setInt(reference, loadedPropertyValue == null ? 0 : (int) loadedPropertyValue);
|
|
break;
|
|
case LONG:
|
|
setLong(reference, loadedPropertyValue == null ? 0 : (long) loadedPropertyValue);
|
|
break;
|
|
case OBJECT:
|
|
setObject(reference, loadedPropertyValue);
|
|
break;
|
|
case REFERENCES_LIST:
|
|
setReferencesList(reference, (LongArrayList) loadedPropertyValue);
|
|
break;
|
|
case ENHANCED_OBJECT:
|
|
setEnhancedObject(reference, (EnhancedObject) loadedPropertyValue);
|
|
break;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public <T extends EnhancedObject> void setEnhancedObject(long reference, T value) throws IOException {
|
|
synchronized (accessLock) {
|
|
if (value != null) {
|
|
EnhancedObjectFullInfo objectFullInfo = value.getAllInfo();
|
|
int totalSize = Integer.BYTES * 2 + objectFullInfo.getFieldReferences().length * Long.BYTES + objectFullInfo.getPropertyReferences().length * Long.BYTES;
|
|
ByteBuffer buffer = ByteBuffer.allocate(totalSize);
|
|
buffer.putInt(objectFullInfo.getFieldReferences().length);
|
|
buffer.putInt(objectFullInfo.getPropertyReferences().length);
|
|
for (int i = 0; i < objectFullInfo.getFieldReferences().length; i++) {
|
|
buffer.putLong(objectFullInfo.getFieldReferences()[i]);
|
|
}
|
|
for (int i = 0; i < objectFullInfo.getPropertyReferences().length; i++) {
|
|
buffer.putLong(objectFullInfo.getPropertyReferences()[i]);
|
|
}
|
|
for (int i = 0; i < objectFullInfo.getFieldReferences().length; i++) {
|
|
try {
|
|
setData(objectFullInfo.getFieldReferences()[i], objectFullInfo.getFieldTypes()[i], objectFullInfo.getFields()[i].get(value));
|
|
} catch (IllegalAccessException e) {
|
|
throw new IOException(e);
|
|
}
|
|
}
|
|
for (int i = 0; i < objectFullInfo.getPropertyReferences().length; i++) {
|
|
setData(objectFullInfo.getPropertyReferences()[i], objectFullInfo.getPropertyTypes()[i], objectFullInfo.getLoadedPropertyValues()[i]);
|
|
}
|
|
buffer.flip();
|
|
referencesIO.writeToReference(reference, totalSize, buffer);
|
|
} else {
|
|
referencesIO.writeToReference(reference, 0, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
@Override
|
|
public <T> T loadObject(long reference) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = referencesIO.readFromReference(reference);
|
|
if (buffer.limit() == 0) {
|
|
return null;
|
|
}
|
|
buffer.rewind();
|
|
byte[] data = buffer.array();
|
|
return (T) kryo.readClassAndObject(new Input(data));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public LongArrayList loadReferencesList(long reference) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = referencesIO.readFromReference(reference);
|
|
if (buffer.limit() == 0) {
|
|
return null;
|
|
}
|
|
int itemsCount = buffer.getInt();
|
|
LongArrayList arrayList = new LongArrayList();
|
|
for (int i = 0; i < itemsCount; i++) {
|
|
arrayList.add(buffer.getLong());
|
|
}
|
|
return arrayList;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean loadBoolean(long reference) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = referencesIO.readFromReference(reference);
|
|
if (buffer.limit() == 0) {
|
|
return false;
|
|
}
|
|
return buffer.get() == 1;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public byte loadByte(long reference) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = referencesIO.readFromReference(reference);
|
|
if (buffer.limit() == 0) {
|
|
return 0;
|
|
}
|
|
return buffer.get();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public short loadShort(long reference) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = referencesIO.readFromReference(reference);
|
|
if (buffer.limit() == 0) {
|
|
return 0;
|
|
}
|
|
return buffer.getShort();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public char loadChar(long reference) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = referencesIO.readFromReference(reference);
|
|
if (buffer.limit() == 0) {
|
|
return 0;
|
|
}
|
|
return buffer.getChar();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int loadInt(long reference) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = referencesIO.readFromReference(reference);
|
|
if (buffer.limit() == 0) {
|
|
return 0;
|
|
}
|
|
return buffer.getInt();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public long loadLong(long reference) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = referencesIO.readFromReference(reference);
|
|
if (buffer.limit() == 0) {
|
|
return 0;
|
|
}
|
|
return buffer.getLong();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public <T> void setObject(long reference, T value) throws IOException {
|
|
synchronized (accessLock) {
|
|
if (value != null) {
|
|
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
|
|
Output output = new Output(outputStream);
|
|
kryo.writeClassAndObject(output, value);
|
|
output.flush();
|
|
byte[] data = outputStream.toByteArray();
|
|
ByteBuffer dataByteBuffer = ByteBuffer.wrap(data);
|
|
referencesIO.writeToReference(reference, data.length, dataByteBuffer);
|
|
} else {
|
|
referencesIO.writeToReference(reference, 0, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setReferencesList(long reference, LongArrayList value) throws IOException {
|
|
synchronized (accessLock) {
|
|
if (value != null) {
|
|
int items = value.size();
|
|
ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES * items + Integer.BYTES);
|
|
buffer.putInt(items);
|
|
for (int i = 0; i < items; i++) {
|
|
buffer.putLong(value.getLong(i));
|
|
}
|
|
buffer.flip();
|
|
referencesIO.writeToReference(reference, buffer.limit(), buffer);
|
|
} else {
|
|
referencesIO.writeToReference(reference, 0, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setBoolean(long reference, boolean value) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = ByteBuffer.allocate(Byte.BYTES);
|
|
buffer.put(value ? (byte) 1 : (byte) 0);
|
|
buffer.flip();
|
|
referencesIO.writeToReference(reference, Byte.BYTES, buffer);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setByte(long reference, byte value) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = ByteBuffer.allocate(Byte.BYTES);
|
|
buffer.put(value);
|
|
buffer.flip();
|
|
referencesIO.writeToReference(reference, Byte.BYTES, buffer);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setShort(long reference, short value) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = ByteBuffer.allocate(Short.BYTES);
|
|
buffer.putShort(value);
|
|
buffer.flip();
|
|
referencesIO.writeToReference(reference, Short.BYTES, buffer);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setChar(long reference, char value) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = ByteBuffer.allocate(Character.BYTES);
|
|
buffer.putChar(value);
|
|
buffer.flip();
|
|
referencesIO.writeToReference(reference, Character.BYTES, buffer);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setInt(long reference, int value) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);
|
|
buffer.putInt(value);
|
|
buffer.flip();
|
|
referencesIO.writeToReference(reference, Integer.BYTES, buffer);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setLong(long reference, long value) throws IOException {
|
|
synchronized (accessLock) {
|
|
ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
|
|
buffer.putLong(value);
|
|
buffer.flip();
|
|
referencesIO.writeToReference(reference, Long.BYTES, buffer);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public long newNullObject() throws IOException {
|
|
synchronized (accessLock) {
|
|
return referencesIO.allocateReference();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void loadProperty(EnhancedObject obj, int propertyId, Method property, DBDataType propertyType, long propertyUID) throws IOException {
|
|
synchronized (accessLock) {
|
|
obj.setProperty(propertyId, loadData(propertyType, propertyUID, property::getReturnType));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void registerClass(Class<?> type, int id) {
|
|
if (id < -100) {
|
|
throw new IllegalArgumentException();
|
|
}
|
|
kryo.register(type, 100 + id);
|
|
}
|
|
|
|
private <T extends EnhancedObject> void preloadEnhancedObjectProperties(T obj, long[] propertyReferences) {
|
|
// Declare the variables needed to get the biggest property Id
|
|
Method[] unorderedPropertyGetters = obj.getPropertyGetters();
|
|
Method[] unorderedPropertySetters = obj.getPropertySetters();
|
|
|
|
// Find the biggest property Id
|
|
int biggestGetter = getBiggestPropertyGetterId(unorderedPropertyGetters);
|
|
int biggestSetter = getBiggestPropertySetterId(unorderedPropertySetters);
|
|
int biggestPropertyId = biggestGetter > biggestSetter ? biggestGetter : biggestSetter;
|
|
|
|
for (Method property : unorderedPropertySetters) {
|
|
DBPropertySetter fieldAnnotation = property.getAnnotation(DBPropertySetter.class);
|
|
int propertyId = fieldAnnotation.id();
|
|
if (propertyId > biggestPropertyId) {
|
|
biggestPropertyId = propertyId;
|
|
}
|
|
}
|
|
|
|
// Declare the other variables
|
|
DBDataType[] propertyTypes = new DBDataType[biggestPropertyId + 1];
|
|
Method[] propertyGetters = new Method[biggestPropertyId + 1];
|
|
Method[] propertySetters = new Method[biggestPropertyId + 1];
|
|
Map<String, DBPropertySetter> setterMethods = new LinkedHashMap<>();
|
|
Map<String, DBPropertyGetter> getterMethods = new LinkedHashMap<>();
|
|
|
|
// Load the properties metadata
|
|
for (Method property : unorderedPropertyGetters) {
|
|
DBPropertyGetter propertyAnnotation = property.getAnnotation(DBPropertyGetter.class);
|
|
int propertyId = propertyAnnotation.id();
|
|
DBDataType propertyType = propertyAnnotation.type();
|
|
propertyTypes[propertyId] = propertyType;
|
|
propertyGetters[propertyId] = property;
|
|
getterMethods.put(property.getName(), propertyAnnotation);
|
|
}
|
|
for (Method property : unorderedPropertySetters) {
|
|
DBPropertySetter propertyAnnotation = property.getAnnotation(DBPropertySetter.class);
|
|
int propertyId = propertyAnnotation.id();
|
|
DBDataType propertyType = propertyAnnotation.type();
|
|
propertyTypes[propertyId] = propertyType;
|
|
propertySetters[propertyId] = property;
|
|
setterMethods.put(property.getName(), propertyAnnotation);
|
|
}
|
|
// Set properties metadata
|
|
obj.setProperties(propertyGetters, propertySetters, propertyTypes, propertyReferences, setterMethods, getterMethods);
|
|
}
|
|
|
|
private int getBiggestPropertyGetterId(Method[] unorderedPropertyGetters) {
|
|
int biggestPropertyId = -1;
|
|
for (Method property : unorderedPropertyGetters) {
|
|
DBPropertyGetter fieldAnnotation = property.getAnnotation(DBPropertyGetter.class);
|
|
int propertyId = fieldAnnotation.id();
|
|
if (propertyId > biggestPropertyId) {
|
|
biggestPropertyId = propertyId;
|
|
}
|
|
}
|
|
return biggestPropertyId;
|
|
}
|
|
|
|
private int getBiggestPropertySetterId(Method[] unorderedPropertySetters) {
|
|
int biggestPropertyId = -1;
|
|
for (Method property : unorderedPropertySetters) {
|
|
DBPropertySetter fieldAnnotation = property.getAnnotation(DBPropertySetter.class);
|
|
int propertyId = fieldAnnotation.id();
|
|
if (propertyId > biggestPropertyId) {
|
|
biggestPropertyId = propertyId;
|
|
}
|
|
}
|
|
return biggestPropertyId;
|
|
}
|
|
|
|
private <T extends EnhancedObject> void preloadEnhancedObjectFields(T obj, long[] fieldReferences) throws IOException {
|
|
// Declare the variables needed to get the biggest field Id
|
|
Field[] unorderedFields = getFields(obj);
|
|
// Find the biggest field Id
|
|
int biggestFieldId = getBiggestFieldId(unorderedFields);
|
|
|
|
// Declare the other variables
|
|
Field[] fields = new Field[biggestFieldId + 1];
|
|
DBDataType[] orderedFieldTypes = new DBDataType[biggestFieldId + 1];
|
|
|
|
// Load all fields metadata and load them
|
|
for (Field field : unorderedFields) {
|
|
DBField fieldAnnotation = field.getAnnotation(DBField.class);
|
|
int fieldId = fieldAnnotation.id();
|
|
DBDataType fieldType = fieldAnnotation.type();
|
|
loadField(obj, field, fieldType, fieldReferences[fieldId]);
|
|
fields[fieldId] = field;
|
|
orderedFieldTypes[fieldId] = fieldType;
|
|
}
|
|
// Set fields metadata
|
|
obj.setFields(fields, orderedFieldTypes, fieldReferences);
|
|
}
|
|
|
|
private <T extends EnhancedObject> void loadField(T obj, Field field, DBDataType fieldType, long fieldReference) throws IOException {
|
|
Object data = loadData(fieldType, fieldReference, field::getType);
|
|
try {
|
|
if (fieldType == DBDataType.OBJECT && data != null) {
|
|
if (!field.getType().isInstance(data)) {
|
|
throw new IOException("There is an attempt to load an object of type " + data.getClass() + " into a field of type " + field.getType());
|
|
}
|
|
}
|
|
FieldUtils.writeField(field, obj, data, true);
|
|
} catch (IllegalAccessException e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
|
|
private <T extends EnhancedObject> Field[] getFields(T obj) {
|
|
return FieldUtils.getFieldsWithAnnotation(obj.getClass(), DBField.class);
|
|
}
|
|
|
|
private int getBiggestFieldId(Field[] unorderedFields) {
|
|
int biggestFieldId = -1;
|
|
for (Field field : unorderedFields) {
|
|
DBField fieldAnnotation = field.getAnnotation(DBField.class);
|
|
int propertyId = fieldAnnotation.id();
|
|
if (propertyId > biggestFieldId) {
|
|
biggestFieldId = propertyId;
|
|
}
|
|
}
|
|
return biggestFieldId;
|
|
}
|
|
|
|
private <T extends EnhancedObject> T instantiateEnhancedObject(Class<T> type) throws IOException {
|
|
try {
|
|
T obj = type.getConstructor().newInstance();
|
|
obj.database = database;
|
|
return obj;
|
|
} catch (NoSuchMethodException e) {
|
|
throw new IOException("You must declare a public empty constructor in class " + type + ": public " + type.getSimpleName() + "()", e);
|
|
} catch (IllegalAccessException | InvocationTargetException | InstantiationException e) {
|
|
throw new IOException(e);
|
|
}
|
|
}
|
|
|
|
private <T extends EnhancedObject> T preloadEnhancedObject(Class<T> objectType, long[] fieldRefs, long[] methodRefs) throws IOException {
|
|
T obj = instantiateEnhancedObject(objectType);
|
|
preloadEnhancedObjectFields(obj, fieldRefs);
|
|
preloadEnhancedObjectProperties(obj, methodRefs);
|
|
return obj;
|
|
}
|
|
|
|
public long[] allocateNewUIDs(int quantity) throws IOException {
|
|
long[] ids = new long[quantity];
|
|
for (int i = 0; i < quantity; i++) {
|
|
ids[i] = newNullObject();
|
|
}
|
|
return ids;
|
|
}
|
|
}
|
|
|
|
public static class DatabaseReferencesIO implements IReferencesIO {
|
|
|
|
private final DatabaseBlocksIO blocksIO;
|
|
private final DatabaseReferencesMetadata referencesMetadata;
|
|
|
|
public DatabaseReferencesIO(DatabaseBlocksIO blocksIO, DatabaseReferencesMetadata referencesMetadata) {
|
|
this.blocksIO = blocksIO;
|
|
this.referencesMetadata = referencesMetadata;
|
|
}
|
|
|
|
@Override
|
|
public long allocateReference() throws IOException {
|
|
return referencesMetadata.newReference(EMPTY_BLOCK_ID);
|
|
}
|
|
|
|
@Override
|
|
public long allocateReference(int size, ByteBuffer data) throws IOException {
|
|
long blockId = (size == 0) ? EMPTY_BLOCK_ID : blocksIO.newBlock(size, data);
|
|
return referencesMetadata.newReference(blockId);
|
|
}
|
|
|
|
@Override
|
|
public void writeToReference(long reference, int size, ByteBuffer data) throws IOException {
|
|
long blockId = (size == 0) ? EMPTY_BLOCK_ID : blocksIO.newBlock(size, data);
|
|
referencesMetadata.editReference(reference, blockId);
|
|
}
|
|
|
|
@Override
|
|
public ByteBuffer readFromReference(long reference) throws IOException {
|
|
long blockId = referencesMetadata.getReference(reference);
|
|
return blocksIO.readBlock(blockId);
|
|
}
|
|
}
|
|
|
|
public static class DatabaseReferencesMetadata implements IReferencesMetadata {
|
|
private final SeekableByteChannel metaFileChannel;
|
|
private final int REF_META_BYTES_COUNT = Long.BYTES;
|
|
private long firstFreeReference;
|
|
|
|
private DatabaseReferencesMetadata(Path refMetaFile) throws IOException {
|
|
metaFileChannel = Files.newByteChannel(refMetaFile, StandardOpenOption.READ, StandardOpenOption.WRITE);
|
|
firstFreeReference = metaFileChannel.size() / REF_META_BYTES_COUNT;
|
|
}
|
|
|
|
@Override
|
|
public long getReference(long reference) throws IOException {
|
|
ByteBuffer buffer = ByteBuffer.allocate(REF_META_BYTES_COUNT);
|
|
if (reference >= firstFreeReference) {
|
|
return EMPTY_BLOCK_ID;
|
|
}
|
|
SeekableByteChannel currentFileChannel = metaFileChannel.position(reference * REF_META_BYTES_COUNT);
|
|
currentFileChannel.read(buffer);
|
|
buffer.flip();
|
|
long block = buffer.getLong();
|
|
if (buffer.limit() == 0 || block == 0xFFFFFFFFFFFFFFFFL) {
|
|
return EMPTY_BLOCK_ID;
|
|
}
|
|
return block;
|
|
}
|
|
|
|
@Override
|
|
public long newReference(long blockId) throws IOException {
|
|
long newReference = firstFreeReference++;
|
|
editReference(newReference, blockId);
|
|
return newReference;
|
|
}
|
|
|
|
@Override
|
|
public void editReference(long reference, long blockId) throws IOException {
|
|
ByteBuffer data = ByteBuffer.allocate(REF_META_BYTES_COUNT);
|
|
data.putLong(blockId);
|
|
SeekableByteChannel currentFileChannel = metaFileChannel.position(reference * REF_META_BYTES_COUNT);
|
|
data.flip();
|
|
currentFileChannel.write(data);
|
|
}
|
|
|
|
@Override
|
|
public void close() throws IOException {
|
|
metaFileChannel.close();
|
|
}
|
|
}
|
|
|
|
public static class DatabaseBlocksIO implements IBlocksIO {
|
|
|
|
private final DatabaseFileIO fileIO;
|
|
private final IBlocksMetadata blocksMetadata;
|
|
|
|
private DatabaseBlocksIO(DatabaseFileIO fileIO, IBlocksMetadata blocksMetadata) {
|
|
this.fileIO = fileIO;
|
|
this.blocksMetadata = blocksMetadata;
|
|
}
|
|
|
|
@Override
|
|
public long newBlock(int size, ByteBuffer data) throws IOException {
|
|
long index = fileIO.writeAtEnd(size, data);
|
|
return blocksMetadata.newBlock(index, size);
|
|
}
|
|
|
|
@Override
|
|
public ByteBuffer readBlock(long blockId) throws IOException {
|
|
if (blockId == EMPTY_BLOCK_ID) {
|
|
return ByteBuffer.wrap(new byte[0]);
|
|
}
|
|
BlockInfo blockInfo = blocksMetadata.getBlockInfo(blockId);
|
|
return fileIO.readAt(blockInfo.getIndex(), blockInfo.getSize());
|
|
}
|
|
|
|
@Override
|
|
public void close() {
|
|
|
|
}
|
|
}
|
|
|
|
public static class DatabaseBlocksMetadata implements IBlocksMetadata {
|
|
private final SeekableByteChannel metaFileChannel;
|
|
private final int BLOCK_META_BYTES_COUNT = Long.BYTES + Integer.BYTES;
|
|
private long firstFreeBlock;
|
|
|
|
private DatabaseBlocksMetadata(Path metaFile) throws IOException {
|
|
metaFileChannel = Files.newByteChannel(metaFile, StandardOpenOption.READ, StandardOpenOption.WRITE);
|
|
firstFreeBlock = metaFileChannel.size() / BLOCK_META_BYTES_COUNT;
|
|
}
|
|
|
|
@Override
|
|
public BlockInfo getBlockInfo(long blockId) throws IOException {
|
|
if (blockId == EMPTY_BLOCK_ID) {
|
|
return EMPTY_BLOCK_INFO;
|
|
}
|
|
ByteBuffer buffer = ByteBuffer.allocate(BLOCK_META_BYTES_COUNT);
|
|
metaFileChannel.position(blockId * BLOCK_META_BYTES_COUNT).read(buffer);
|
|
buffer.flip();
|
|
long index = buffer.getLong();
|
|
int size = buffer.getInt();
|
|
return new BlockInfo(index, size);
|
|
}
|
|
|
|
@Override
|
|
public long newBlock(long index, int size) throws IOException {
|
|
long newBlockId = firstFreeBlock++;
|
|
ByteBuffer data = ByteBuffer.allocate(BLOCK_META_BYTES_COUNT);
|
|
data.putLong(index);
|
|
data.putInt(size);
|
|
data.flip();
|
|
metaFileChannel.position(newBlockId * BLOCK_META_BYTES_COUNT).write(data);
|
|
return newBlockId;
|
|
}
|
|
|
|
@Override
|
|
public void close() throws IOException {
|
|
metaFileChannel.close();
|
|
}
|
|
}
|
|
|
|
public static class DatabaseFileIO implements IFileIO {
|
|
|
|
private final SeekableByteChannel dataFileChannel;
|
|
private final Object dataAccessLock = new Object();
|
|
private long firstFreeIndex;
|
|
|
|
private DatabaseFileIO(Path dataFile) throws IOException {
|
|
synchronized (dataAccessLock) {
|
|
dataFileChannel = Files.newByteChannel(dataFile, StandardOpenOption.READ, StandardOpenOption.WRITE);
|
|
firstFreeIndex = dataFileChannel.size();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ByteBuffer readAt(long index, int length) throws IOException {
|
|
ByteBuffer dataBuffer = ByteBuffer.allocate(length);
|
|
dataFileChannel.position(index).read(dataBuffer);
|
|
dataBuffer.flip();
|
|
return dataBuffer;
|
|
}
|
|
|
|
@Override
|
|
public void writeAt(long index, int length, ByteBuffer data) throws IOException {
|
|
synchronized (dataAccessLock) {
|
|
if (data.position() != 0) {
|
|
throw new IOException("You didn't flip the ByteBuffer!");
|
|
}
|
|
if (firstFreeIndex < index + length) {
|
|
firstFreeIndex = index + length;
|
|
}
|
|
dataFileChannel.position(index).write(data);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public long writeAtEnd(int length, ByteBuffer data) throws IOException {
|
|
synchronized (dataAccessLock) {
|
|
long index = firstFreeIndex;
|
|
firstFreeIndex += length;
|
|
writeAt(index, length, data);
|
|
return index;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void close() throws IOException {
|
|
synchronized (dataAccessLock) {
|
|
dataFileChannel.close();
|
|
}
|
|
}
|
|
}
|
|
}
|