strangedb/src/main/java/org/warp/jcwdb/EntryReference.java

package org.warp.jcwdb;

import java.io.IOException;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * You must have only a maximum of 1 reference for each index
 * @param <T>
 */
public class EntryReference<T> implements Editable<T>, Saveable, Castable {
	private final JCWDatabase.EntryReferenceTools db;
	private final long entryIndex;
	private final DBTypeParser<T> parser;
	private T value;
	private long cachedHash;
	private volatile boolean isHashCached;
	private volatile boolean loaded;
	private volatile boolean closed;
	private volatile boolean isFlushingAllowed;
	private final Object hashCacheLock = new Object();
	private final Object accessLock = new Object();
	private final Object closeLock = new Object();

	public EntryReference(JCWDatabase.EntryReferenceTools db, long entryId, long hash, DBTypeParser<T> parser) {
		this.loaded = false;
		this.isHashCached = false;
		this.db = db;
		this.entryIndex = entryId;
		this.parser = parser;
		this.value = null;
	}

	public EntryReference(JCWDatabase.EntryReferenceTools db, long entryId, long hash, DBTypeParser<T> parser, T value) {
		this.loaded = true;
		this.isHashCached = true;
		this.db = db;
		this.entryIndex = entryId;
		this.parser = parser;
		this.cachedHash = hash;
		this.value = value;
	}

	public DBTypeParser<T> getParser() {
		return parser;
	}

	public long getIndex() {
		return entryIndex;
	}
	
	public long calculateHash() {
		synchronized(accessLock) {
			load();
			synchronized(hashCacheLock) {
				if (isHashCached) {
					return cachedHash;
				}
			}
			return parser.calculateHash(this.value);
		}
	}

	public boolean isClosed() {
		return closed;
	}

	/**
	 * Note that this method won't be called when closing without saving
	 */
	public void save() {
		this.save(false);
	}

	public void saveAndFlush() {
		this.save(true);
	}

	private void save(boolean flush) {
		synchronized(accessLock) {
			if (loaded && !closed) {
				try {
					if (value instanceof Saveable) {
						if (flush) {
							((Saveable)value).saveAndFlush();
						} else {
							((Saveable)value).save();
						}
					}
					IndexDetails returnedDetails = this.db.write(entryIndex, parser.getWriter(value));
					synchronized(hashCacheLock) {
						this.cachedHash = returnedDetails.getHash();
						this.isHashCached = true;
					}
					if (flush) {
						if (!isFlushingAllowed) {
							this.db.setFlushingAllowed(entryIndex, true);
							this.isFlushingAllowed = true;
						}
					}
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * Reccomended way to edit the value
	 * @param editFunction
	 * @throws IOException
	 */
	public void editValue(BiFunction<T, Saveable, T> editFunction) {
		synchronized(accessLock) {
			load();
			this.value = editFunction.apply(this.value, this);
			this.save(true);
		}
	}

	/**
	 * Reccomended way to edit the value
	 * @param editFunction
	 * @throws IOException
	 */
	public void editValue(Function<T, T> editFunction) {
		synchronized(accessLock) {
			load();
			this.value = editFunction.apply(this.value);
			this.save(true);
		}
	}

	/**
	 * Reccomended way to edit the value
	 * @param editFunction
	 * @throws IOException
	 */
	public void editValue(BiConsumer<T, Saveable> editFunction) {
		synchronized(accessLock) {
			load();
			editFunction.accept(this.value, this);
			this.save(true);
		}
	}

	/**
	 * Reccomended way to edit the value
	 * @param editFunction
	 * @throws IOException
	 */
	public void editValue(Consumer<T> editFunction) {
		synchronized(accessLock) {
			load();
			editFunction.accept(this.value);
			this.save(true);
		}
	}

	/**
	 * Reccomended way to edit the value
	 * DO NOT EDIT THE VALUE
	 * @param viewFunction
	 * @throws IOException
	 */
	public void viewValue(Consumer<T> viewFunction) {
		synchronized(accessLock) {
			load();
			viewFunction.accept(this.value);
		}
	}

	/**
	 * Substitute the old value with a new one
	 * @param val
	 * @throws IOException
	 */
	public void setValue(T val) {
		synchronized(accessLock) {
			this.loaded = true;
			this.value = val;
			synchronized(hashCacheLock) {
				this.isHashCached = false;
			}
			this.save(true);
		}
	}

	/**
	 * Use editValue instead. READ ONLY!!
	 * @return
	 */
	@Deprecated()
	public T getValue() {
		return getValueReadOnlyUnsafe();
	}

	/**
	 * DO NOT ATTEMPT TO MODIFY THE VALUE RETURNED
	 * @return
	 */
	public T getValueReadOnlyUnsafe() {
		synchronized(accessLock) {
			load();
			return this.value;
		}
		
	}

	private void load() {
		synchronized(accessLock) {
			if (!loaded) {
				try {
					if (this.isFlushingAllowed) {
						this.db.setFlushingAllowed(entryIndex, false);
						this.isFlushingAllowed = false;
					}
					this.value = db.read(entryIndex, parser.getReader());
					this.loaded = true;
				} catch (IOException e) {
					throw (NullPointerException) new NullPointerException(e.getLocalizedMessage()).initCause(e);
				}
			}
		}
	}

	@SuppressWarnings("unchecked")
	@Override
	public <U> U cast() {
		return (U) this;
	}

	protected void close() throws IOException {
		if (closed) {
			return;
		}
		synchronized (closeLock) {
			if (closed) {
				return;
			}

			save(true);

			closed = true;
		}
	}

	public void closeWithoutSaving() {
		if (closed) {
			return;
		}
		synchronized (closeLock) {
			if (closed) {
				return;
			}

			closed = true;
		}
	}
	
	public Object getAccessLock() {
		return accessLock;
	}
}