package org.xvsm.core;
   
   import java.io.IOException;
   import java.io.Serializable;
   import java.util.ArrayList;
   import java.util.Collections;
   import java.util.List;
   import java.util.Map;
   import java.util.TreeMap;
  import java.util.UUID;
  
  import org.apache.log4j.Logger;
  import org.xvsm.interfaces.ICoordinator;
  import org.xvsm.internal.exceptions.EntryLockedException;
  import org.xvsm.selectors.Selector;
  import org.xvsm.transactions.Transaction;
  
  /***
   * An entry is the basic entity which can be stored in a container.
   * 
   * @author Christian Schreiber, Michael Proestler
   * 
   */
  public abstract class Entry implements Serializable {
  
  	/***
  	 * The logger of this class.
  	 */
  	private static Logger logger = Logger.getLogger(Entry.class);
  
  	/***
  	 * Defines all possible types of entries (TUPLE and ATOMICENTRY).<br>
  	 * This is used to avoid the instanceof operator.
  	 * 
  	 * @author Christian Schreiber, Michael Proestler
  	 * 
  	 */
  	public static enum EntryTypes {
  		/***
  		 * The entry is a {@link Tuple}.
  		 */
  		TUPLE,
  		/***
  		 * The entry is an {@link AtomicEntry}.
  		 */
  		ATOMICENTRY,
  		/***
  		 * The entry is an {@link VoidEntry}.
  		 */
  		VOID,
  		/***
  		 * The entry is an {@link ExceptionEntry}.
  		 */
  		EXCEPTION;
  	}
  
  	/***
  	 * Generated serial version UID.
  	 */
  	private static final long serialVersionUID = 7961524563053473111L;
  
  	/***
  	 * A basis uuid string used for the generation of the entry id.
  	 */
  	private static String baseUUID = UUID.randomUUID().toString();
  
  	/***
  	 * A Count which is used for the generation of the entry id.
  	 */
  	private static long entryCount = 0;
  
  	/***
  	 * The internal id of the entry. This id does not need to be globally unique
  	 * It needs to be unique on this core instance (site) only.
  	 */
  	private String id;
  
  	/***
  	 * The type of this entry.<br>
  	 * If entryTypes is EntryTypes.TUPLE you can cast this entry to a
  	 * {@link tuple} otherwise (set to EntryTypes.ATOMICENTRY) this entry can be
  	 * cast to {@link AtomicEntry}.
  	 */
  	private EntryTypes entryType;
  
  	/***
  	 * A List of {@link Selector}s used to write the entry. This field is null
  	 * when the entry has been written from the container.
  	 */
  	private List<Selector> selectors = new ArrayList<Selector>();
  
  	/***
  	 * Stores a {@link List} of coordination types in which this entry is
  	 * referenced.
  	 */
  	private List<ICoordinator> coordinationType = new ArrayList<ICoordinator>();
  
  	// ##################################################### LOCKS
  	/***
 	 * This lock is set if the entry has been deleted by a transaction which has
 	 * not been committed or rolled back.
 	 */
 	private Transaction deleteLock;
 
 	/***
 	 * This lock is set if the entry has been written by a transaction which has
 	 * not been committed or rolled back.
 	 */
 	private Transaction writeLock;
 
 	/***
 	 * A shared object used to synchronize the locking mechanisms.
 	 */
 	private Object lockObject = new String("lockString");
 
 	/***
 	 * A map containing all readLocks.
 	 */
 	private Map<String, Transaction> readLocks = Collections
 			.synchronizedMap(new TreeMap<String, Transaction>());
 
 	// ##################################################### LOCKS
 
 	/***
 	 * Creates a new Entry and generates a id for it.
 	 */
 	protected Entry() {
 		this.generateId();
 	}
 
 	/***
 	 * Creates a new Entry and generates a id for it.
 	 * 
 	 * @param sels
 	 *            the selectors used to write the entry.
 	 */
 	protected Entry(Selector... sels) {
 		this();
 		this.addSelectors(sels);
 	}
 
 	/***
 	 * Creates a flat copy of this entry.<br>
 	 * NOTE: The content will not be copied.
 	 * 
 	 * @return a flat copy of this entry.
 	 */
 	public abstract Entry getFlatCopy();
 
 	// /***
 	// * Creates a copy of the Entry with the same content.<br>
 	// * The meta information of the entry (selector, locks, ...) will not be
 	// * copied.
 	// *
 	// * @return a copy of the the entry.
 	// */
 	// public abstract Entry getPlainEntry();
 
 	/***
 	 * Get the EntryTypes of this Entry.
 	 * 
 	 * @return the entryType
 	 */
 	public EntryTypes getEntryType() {
 		return entryType;
 	}
 
 	/***
 	 * Set the EntryTypes of this Entry.
 	 * 
 	 * @param entryType
 	 *            the entryType to set
 	 */
 	protected void setEntryType(EntryTypes entryType) {
 		this.entryType = entryType;
 	}
 
 	/***
 	 * Get the String of this Entry.
 	 * 
 	 * @return the id
 	 */
 	public String getId() {
 		return id;
 	}
 
 	/***
 	 * Set the Id of this Entry.
 	 * 
 	 * @param id
 	 *            the id to set
 	 */
 	public void setId(String id) {
 		this.id = id;
 	}
 
 	/***
 	 * Generate and set an id for this entry.
 	 * 
 	 */
 	public void generateId() {
 		synchronized (Entry.baseUUID) {
 			if (Entry.entryCount == Long.MAX_VALUE) {
 				// reset the counter and generate a new randomUUID.
 				Entry.entryCount = 0;
 				Entry.baseUUID = UUID.randomUUID().toString();
 			}
 
 			this.setId(Entry.baseUUID + "--" + (Entry.entryCount++));
 		}
 	}
 
 	/***
 	 * Get the the coordination Types of this Entry.
 	 * 
 	 * @return the coordinationType
 	 */
 	public ICoordinator[] getCoordinationType() {
 		synchronized (this.lockObject) {
 			return coordinationType.toArray(new ICoordinator[0]);
 		}
 	}
 
 	/***
 	 * Adds the given coordination types to the the list of coordination types
 	 * of this entry.
 	 * 
 	 * @param cts
 	 *            the new coordination types.
 	 */
 	public void addCoordinationTypes(ICoordinator... cts) {
 		synchronized (this.lockObject) {
 			for (ICoordinator ct : cts) {
 				this.coordinationType.add(ct);
 			}
 		}
 	}
 
 	/***
 	 * Get the delete Lock of this Entry.
 	 * 
 	 * @return the deleteLock
 	 */
 	public Transaction getDeleteLock() {
 		synchronized (this.lockObject) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("getDeleteLock()");
 			}
 			synchronized (this.lockObject) {
 				if (logger.isDebugEnabled()) {
 					logger.debug("getDeleteLock() returns: " + this.deleteLock);
 				}
 				return deleteLock;
 			}
 		}
 	}
 
 	/***
 	 * <code>true</code> if this entry has been deleted with tx.
 	 * 
 	 * @param tx
 	 *            the transaction to check
 	 * @return <code>true</code> if this entry has been deleted with tx,
 	 *         otherwise <code>false</code>.
 	 */
 	public boolean hasDeleteLock(Transaction tx) {
 		synchronized (this.lockObject) {
 			return this.deleteLock != null && this.deleteLock.isAncestorOf(tx);
 		}
 	}
 
 	/***
 	 * Determines if the entry can be read with the given transaction.<br>
 	 * More formal, the method returns <code>true</code> if the entry has no
 	 * write or delete lock from another transaction or a delete lock from the
 	 * same transaction.
 	 * 
 	 * @param tx
 	 *            the transaction to check.
 	 * @return <code>true</code> if the entry can be read with this tx otherwise
 	 *         <code>false</code>.
 	 */
 	public boolean canBeRead(Transaction tx) {
 		if (logger.isDebugEnabled()) {
 			logger.debug("canBeRead()");
 
 		}
 		synchronized (this.lockObject) {
 			if (this.writeLock != null) {
 				if (!this.writeLock.isAncestorOf(tx)) {
 					if (logger.isDebugEnabled()) {
 						logger.debug("canBeRead() returns: false");
 					}
 					return false;
 				}
 			}
 			if (this.deleteLock != null) {
 				if (logger.isDebugEnabled()) {
 					logger.debug("canBeRead() returns: false");
 				}
 				return false;
 			}
 			if (logger.isDebugEnabled()) {
 				logger.debug("canBeRead() returns: true");
 			}
 			return true;
 		}
 
 	}
 
 	public boolean canBeWritten(Transaction tx) {
 		if (logger.isDebugEnabled()) {
 			logger.debug("canBeWritten()");
 		}
 		synchronized (this.lockObject) {
 			return canBeRead(tx)
 					&& this.readLocks.size() == 0
 					| (this.readLocks.size() == 1 && this.readLocks
 							.containsKey(tx.getId()));
 		}
 	}
 
 	/***
 	 * Remove the delete Lock of this Entry.
 	 * 
 	 */
 	public void removeDeleteLock() {
 		if (logger.isDebugEnabled()) {
 			logger.debug("removeDeleteLock()");
 		}
 		synchronized (this.lockObject) {
 			this.deleteLock = null;
 			if (logger.isDebugEnabled()) {
 				logger.debug("removeDeleteLock() set deleteLock: null");
 			}
 		}
 	}
 
 	/***
 	 * Set the delete Lock of this Entry.
 	 * 
 	 * @param deleteLock
 	 *            the deleteLock to set
 	 * @throws EntryLockedException
 	 *             thrown if the lock can not be aquired.
 	 */
 	public void setDeleteLock(Transaction deleteLock)
 			throws EntryLockedException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("setDeleteLock()");
 		}
 
 		synchronized (this.lockObject) {
 			this.checkLocks(deleteLock);
 			// finally set the lock
 			this.deleteLock = deleteLock;
 			if (logger.isDebugEnabled()) {
 				logger.debug("setDeleteLock() set deleteLock: " + deleteLock);
 			}
 		}
 	}
 
 	/***
 	 * Checks if any lock is set. If delete-, write or read lock is set by
 	 * another transaction and the other transaction is either father nor child
 	 * of txn EntryLockedException will be thrown
 	 * 
 	 * @param txn
 	 *            the transaction for which the locks have to be checked.
 	 * @throws EntryLockedException
 	 *             thrown if any lock is set and can not be used with txn.
 	 */
 	private void checkLocks(Transaction txn) throws EntryLockedException {
 		try {
 			if (logger.isDebugEnabled()) {
 				logger
 						.debug("checkLocks() " + this.getId() + " for tx: "
 								+ txn);
 			}
 			synchronized (this.lockObject) {
 				// Check if the delete lock can be set.
 				if (this.deleteLock != null && txn != null
 						&& !this.deleteLock.isAncestorOf(txn)
 						&& !txn.isAncestorOf(this.deleteLock)) {
 					// if this.deleteLock is set from another transaction we can
 					// not set the lock.
 					throw new EntryLockedException(this.deleteLock);
 				}
 				if (this.writeLock != null && txn != null
 						&& !this.writeLock.isAncestorOf(txn)
 						&& !txn.isAncestorOf(this.writeLock)) {
 					// if this.writeLock is set from another transaction we can
 					// not set the lock.
 					throw new EntryLockedException(this.writeLock);
 				}
 				if (this.readLocks.size() != 0 && txn != null) {
 					// if there is a readLock from another transaction we can
 					// not set the lock
 					for (Transaction tx : this.readLocks.values()) {
 						if (!tx.isAncestorOf(txn) && !txn.isAncestorOf(tx)) {
 							throw new EntryLockedException(tx);
 						}
 					}
 				}
 			}
 		} catch (EntryLockedException e) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("setDeleteLock() entry locked with "
 						+ e.getReason());
 			}
 			throw e;
 		}
 	}
 
 	/***
 	 * Get the write lock of this Entry.
 	 * 
 	 * @return the writeLock
 	 */
 	public Transaction getWriteLock() {
 		if (logger.isDebugEnabled()) {
 			logger.debug("getWriteLock()");
 		}
 		synchronized (this.lockObject) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("getWriteLock() returns " + writeLock);
 			}
 			return writeLock;
 		}
 	}
 
 	/***
 	 * <code>true</code> if this entry has been written with tx and therefore
 	 * has to be committed or rolled back.
 	 * 
 	 * @param tx
 	 *            the transaction to check
 	 * @return <code>true</code> if this entry has been written with tx,
 	 *         otherwise <code>false</code>.
 	 */
 	public boolean hasWriteLock(Transaction tx) {
 		if (logger.isDebugEnabled()) {
 			logger.debug("hasWriteLock()");
 		}
 		synchronized (this.lockObject) {
 			boolean ret = this.writeLock != null
 					&& this.writeLock.isAncestorOf(tx);
 			if (logger.isDebugEnabled()) {
 				logger.debug("hasWriteLock() returns :" + ret);
 			}
 			return ret;
 		}
 	}
 
 	/***
 	 * Set the write lock of this Entry.
 	 * 
 	 * @param writeLock
 	 *            the writeLock to set
 	 * @throws EntryLockedException
 	 *             thrown if the write lock can not be aquired.
 	 */
 	public void setWriteLock(Transaction writeLock) throws EntryLockedException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("setWriteLock()");
 		}
 		synchronized (this.lockObject) {
 			this.checkLocks(writeLock);
 			this.writeLock = writeLock;
 			if (logger.isDebugEnabled()) {
 				logger.debug("setWriteLock() set writeLock: " + this.writeLock);
 			}
 		}
 	}
 
 	/***
 	 * Remove the write lock of this Entry.
 	 * 
 	 */
 	public void removeWriteLock() {
 		if (logger.isDebugEnabled()) {
 			logger.debug("removeWriteLock()");
 		}
 		synchronized (this.lockObject) {
 			this.writeLock = null;
 			if (logger.isDebugEnabled()) {
 				logger.debug("removeWriteLock() set writeLock: null");
 			}
 		}
 	}
 
 	/***
 	 * Adds tx to the readLocks.
 	 * 
 	 * @param tx
 	 *            the new lock.
 	 * @throws EntryLockedException
 	 *             if the readLock can not be set because another tx wrote or
 	 *             deleted this entry.
 	 */
 	public void addReadLock(Transaction tx) throws EntryLockedException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("addReadLock()");
 		}
 		synchronized (this.lockObject) {
 			if (tx != null) {
 				// we can not use checkLocks(tx) because the read lock can be
 				// set when there are already read locks.
 
 				// Check if the delete lock can be set.
 				if (this.deleteLock != null && tx != null
 						&& !this.deleteLock.isAncestorOf(tx)
 						&& !tx.isAncestorOf(this.deleteLock)) {
 					throw new EntryLockedException(tx);
 				}
 				if (this.writeLock != null && tx != null
 						&& !this.writeLock.isAncestorOf(tx)
 						&& !tx.isAncestorOf(this.writeLock)) {
 					throw new EntryLockedException(tx);
 				}
 				this.readLocks.put(tx.getId(), tx);
 			}
 		}
 		if (logger.isDebugEnabled()) {
 			logger.debug("addReadLock() added: " + tx);
 		}
 	}
 
 	/***
 	 * Checks if the entry has been read with the tx.
 	 * 
 	 * @return <code>true</code> if the entry has been read with tx, otherwise
 	 *         <code>false</code>
 	 * @param tx
 	 *            the lock to check.
 	 */
 	public boolean hasReadLock(Transaction tx) {
 		if (logger.isDebugEnabled()) {
 			logger.debug("hasReadLock()");
 		}
 		synchronized (this.lockObject) {
 			boolean ret = this.readLocks.get(tx.getId()) != null;
 			if (logger.isDebugEnabled()) {
 				logger.debug("hasReadLock() returns: " + ret);
 			}
 			return ret;
 		}
 	}
 
 	/***
 	 * Removes tx from the readLocks.
 	 * 
 	 * @param tx
 	 *            the new lock.
 	 */
 	public void removeReadLock(Transaction tx) {
 		if (logger.isDebugEnabled()) {
 			logger.debug("removeReadLock()");
 		}
 		synchronized (this.lockObject) {
 			this.readLocks.remove(tx.getId());
 			if (logger.isDebugEnabled()) {
 				logger.debug("removeReadLock() removed: " + tx);
 			}
 		}
 	}
 
 	// TODO removeOnRollback and addOnRollback good names? can they be used on
 	// every coordinator? Now used in RandomCoordinator.rollback(Transaction tx)
 
 	/***
 	 * Determines if the entry has to be removed when tx is rolled back.<br>
 	 * <code>true</code> if this entry has been written with tx and NOT been
 	 * deleted with the same tx.
 	 * 
 	 * @param tx
 	 *            the transaction to check.
 	 * @return <code>true</code> if the entry has to be removed on the rollback
 	 *         of tx.
 	 */
 	public boolean removeOnRollback(Transaction tx) {
 		if (logger.isDebugEnabled()) {
 			logger.debug("removeOnRollback()");
 		}
 		synchronized (this.lockObject) {
 			boolean ret = this.hasWriteLock(tx) && !this.hasDeleteLock(tx);
 			if (logger.isDebugEnabled()) {
 				logger.debug("removeOnRollback() returns: " + ret);
 			}
 			return ret;
 		}
 	}
 
 	/***
 	 * Determines if the entry has to be added when tx is rolled back.<br>
 	 * <code>true</code> if the entry has not been written with tx but has been
 	 * deleted with tx.
 	 * 
 	 * @param tx
 	 *            the transaction to check.
 	 * @return <code>true</code> if the entry has to be added on the rollback of
 	 *         tx.
 	 */
 	public boolean addOnRollback(Transaction tx) {
 		if (logger.isDebugEnabled()) {
 			logger.debug("addOnRollback()");
 		}
 		synchronized (this.lockObject) {
 			boolean ret = !this.hasWriteLock(tx) && this.hasDeleteLock(tx);
 			if (logger.isDebugEnabled()) {
 				logger.debug("addOnRollback() returns: " + ret);
 			}
 			return ret;
 		}
 	}
 
 	/***
 	 * Get the selectors of this Entry.
 	 * 
 	 * @return the selectors
 	 */
 	public List<Selector> getSelectors() {
 		return selectors;
 	}
 
 	/***
 	 * Add the selectors to this Entry.
 	 * 
 	 * @param sels
 	 *            the selectors to add
 	 */
 	public void addSelectors(Selector... sels) {
 		for (Selector s : sels) {
 			this.selectors.add(s);
 		}
 	}
 
 	/***
 	 * Set the selectors to this Entry.
 	 * 
 	 * @param sels
 	 *            the selectors to set
 	 */
 	public void setSelectors(List<Selector> sels) {
 		this.selectors = sels;
 	}
 
 	/***
 	 * 
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public String toString() {
 		return "<selectors: " + this.selectors + ">";
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public int hashCode() {
 		final int prime = 31;
 		int result = 1;
 		result = prime * result
 				+ ((entryType == null) ? 0 : entryType.hashCode());
 		result = prime * result + ((id == null) ? 0 : id.hashCode());
 		return result;
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	@Override
 	public boolean equals(Object obj) {
 		if (obj == null || this.id == null) {
 			return false;
 		}
 		return obj instanceof Entry && this.id.equals(((Entry) obj).id);
 	}
 
 	/***
 	 * Method is used for serializing the entry.<br>
 	 * Remove all unnecessary information form the entry before sending to the
 	 * client.
 	 * 
 	 * @param out
 	 *            the ObjectOutputStream used for writing.
 	 * @throws IOException
 	 *             thrown if an error occurs while writing the entry.
 	 */
 	private void writeObject(java.io.ObjectOutputStream out) throws IOException {
 		synchronized (this.lockObject) {
 			// remove all locks.
 			Transaction dLock = this.deleteLock;
 			this.deleteLock = null;
 			Transaction wLock = this.writeLock;
 			this.writeLock = null;
 			Map<String, Transaction> rLocks = this.readLocks;
 			this.readLocks = null;
 			List<ICoordinator> myCoordinationTypes = this.coordinationType;
 			this.coordinationType = new ArrayList<ICoordinator>();
 
 			out.defaultWriteObject();
 
 			this.coordinationType = myCoordinationTypes;
 			this.lockObject = new String("lockString");
 			this.readLocks = rLocks;
 			this.deleteLock = dLock;
 			this.writeLock = wLock;
 		}
 	}
 
 	/***
 	 * Method is used for deserializing the object.<br>
 	 * Initializes the readLocks list and the lockObject.
 	 * 
 	 * @param in
 	 *            the ObjectInputStream used for reading.
 	 * @throws IOException
 	 *             thrown if an error occurs while reading the entry.
 	 * @throws ClassNotFoundException
 	 *             thrown if a class can not be found.
 	 */
 	private void readObject(java.io.ObjectInputStream in) throws IOException,
 			ClassNotFoundException {
 		in.defaultReadObject();
 		this.lockObject = new String("lockObject");
 		this.readLocks = Collections
 				.synchronizedMap(new TreeMap<String, Transaction>());
 	}
 }