Capsule.java

package org.prevayler.implementation;

import org.prevayler.foundation.Chunk;
import org.prevayler.foundation.serialization.Serializer;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Serializable;
import java.util.Date;

public abstract class Capsule implements Serializable {

	private final byte[] _serialized;

	protected Capsule(Object transaction, Serializer journalSerializer) {
		try {
			ByteArrayOutputStream bytes = new ByteArrayOutputStream();
			journalSerializer.writeObject(bytes, transaction);
			_serialized = bytes.toByteArray();
		} catch (Exception exception) {
			throw new Error("Unable to serialize transaction", exception);
		}
	}

	protected Capsule(byte[] serialized) {
		_serialized = serialized;
	}

	/**
	 * Get the serialized representation of the transaction. Callers must not modify the returned array.
	 */
	public byte[] serialized() {
		return _serialized;
	}

	/**
	 * Deserialize the contained Transaction or TransactionWithQuery.
	 */
	public Object deserialize(Serializer journalSerializer) {
		try {
			return journalSerializer.readObject(new ByteArrayInputStream(_serialized));
		} catch (Exception exception) {
			throw new Error("Unable to deserialize transaction", exception);
		}
	}

	/**
	 * Execute a freshly deserialized copy of the transaction. This method will synchronize on the prevalentSystem
	 * while running the transaction but after deserializing it.
	 */
	public void executeOn(Object prevalentSystem, Date executionTime, Serializer journalSerializer) {
		Object transaction = deserialize(journalSerializer);

		synchronized (prevalentSystem) {
			justExecute(transaction, prevalentSystem, executionTime);
		}
	}

	/**
	 * Actually execute the Transaction or TransactionWithQuery. The caller
	 * is responsible for synchronizing on the prevalentSystem.
	 */
	protected abstract void justExecute(Object transaction, Object prevalentSystem, Date executionTime);

	/**
	 * Make a clean copy of this capsule that will have its own query result fields.
	 */
	public abstract Capsule cleanCopy();

	Chunk toChunk() {
		Chunk chunk = new Chunk(_serialized);
		chunk.setParameter("withQuery", String.valueOf(this instanceof TransactionWithQueryCapsule));
		return chunk;
	}

	static Capsule fromChunk(Chunk chunk) {
		boolean withQuery = Boolean.valueOf(chunk.getParameter("withQuery")).booleanValue();
		if (withQuery) {
			return new TransactionWithQueryCapsule(chunk.getBytes());
		} else {
			return new TransactionCapsule(chunk.getBytes());
		}
	}

}