package org.xvsm.internal;
   
   import java.net.URI;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Properties;
   
   import org.apache.log4j.Logger;
   import org.xvsm.core.ContainerRef;
  import org.xvsm.core.Entry;
  import org.xvsm.core.aspect.AspectContext;
  import org.xvsm.core.aspect.IAspect;
  import org.xvsm.core.aspect.IPoint;
  import org.xvsm.core.aspect.LocalIPoint;
  import org.xvsm.interfaces.ICapi;
  import org.xvsm.interfaces.ICoordinator;
  import org.xvsm.interfaces.container.IContainerEngine;
  import org.xvsm.interfaces.container.ITransactionLayer;
  import org.xvsm.internal.exceptions.AspectNotOkException;
  import org.xvsm.internal.exceptions.AspectRescheduleException;
  import org.xvsm.internal.exceptions.AspectSkipException;
  import org.xvsm.internal.exceptions.ContainerFullException;
  import org.xvsm.internal.exceptions.CountNotMetException;
  import org.xvsm.internal.exceptions.FatalException;
  import org.xvsm.internal.exceptions.InvalidContainerException;
  import org.xvsm.internal.exceptions.InvalidTransactionException;
  import org.xvsm.internal.exceptions.NoSuchCoordinationTypeException;
  import org.xvsm.internal.exceptions.TransactionLockException;
  import org.xvsm.internal.exceptions.XCoreException;
  import org.xvsm.internal.tasks.TransactionTask;
  import org.xvsm.internal.tasks.TransactionTaskType;
  import org.xvsm.selectors.Selector;
  import org.xvsm.transactions.Transaction;
  import org.xvsm.transactions.TransactionManager;
  
  /***
   * Static class used to manage {@link Transaction}s.
   * 
   * @author Christian Schreiber, Michael Proestler
   * 
   */
  public class TransactionLayer implements ITransactionLayer {
  
  	/***
  	 * The logger for this class.
  	 */
  	private static Logger logger = Logger.getLogger(ITransactionLayer.class);
  
  	/***
  	 * The container for this transaction manager.
  	 */
  	private IContainerEngine c;
  
  	/***
  	 * The aspect manager for this container.
  	 */
  	private AspectManager aspectManager = new AspectManager();
  
  	/***
  	 * Default constructor.
  	 */
  	public TransactionLayer() {
  		c = new ContainerEngine();
  	}
  
  	/***
  	 * Default constructor.
  	 * 
  	 * @param size
  	 *            the size of the container.
  	 */
  	public TransactionLayer(int size) {
  		c = new ContainerEngine(size);
  	}
  
  	/***
  	 * Commits a sub transaction and updates the locks (sets the lock to
  	 * tx.getFather()). The commit method of the container is called too.
  	 * 
  	 * @param tx
  	 *            the transaction to commit.
  	 * @throws TransactionLockException
  	 *             thrown if a lock cannot be aquired.
  	 */
  	private void commitSubtransaction(Transaction tx)
  			throws TransactionLockException {
  		if (logger.isDebugEnabled()) {
  			logger.debug("commitSubtransaction(" + tx + ") -- "
  					+ this.getCref());
  		}
  
  		Transaction father = tx.getFather();
  		// if (father == null) {
  		// throw new IllegalArgumentException(tx
  		// + " has not a child transaction");
  		// }
  
  		c.commitSubTransaction(tx);
  
 		// copy the information from the child to the father.
 		for (ContainerRef cref : tx.getModifiedContainers()) {
 			father.addContainerRef(cref);
 		}
 		for (ICoordinator coord : tx.getModifiedCoordinators()) {
 			father.addCoordinator(coord);
 		}
 		TransactionManager.getInstance().removeTransaction(tx);
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("commitSubtransaction() transaction commited -- "
 					+ this.getCref());
 		}
 	}
 
 	/***
 	 * Rolls back a sub transaction.
 	 * 
 	 * @param tx
 	 *            The transaction to roll back.
 	 * @throws TransactionLockException
 	 *             thrown if a lock cannot be aquired.
 	 */
 	private void rollbackSubtransaction(Transaction tx)
 			throws TransactionLockException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("rollbackSubtransaction(" + tx + ") -- "
 					+ this.getCref());
 		}
 
 		// if (tx.getFather() == null) {
 		// throw new IllegalArgumentException(tx
 		// + " has not a child transaction");
 		// }
 
 		c.rollback(tx);
 		TransactionManager.getInstance().removeTransaction(tx);
 		if (logger.isDebugEnabled()) {
 			logger.debug("rollbackSubtransaction() transaction rolled back -- "
 					+ this.getCref());
 		}
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public void commit(Transaction tx) throws TransactionLockException,
 			InvalidTransactionException, AspectRescheduleException,
 			AspectNotOkException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("commit(" + tx + ") -- " + this.getCref());
 		}
 
 		if (tx == null) {
 			throw new IllegalArgumentException("Can not commit transaction "
 					+ tx);
 		}
 		if (tx.getFather() != null) {
 			throw new IllegalArgumentException(
 					"Can not commit a child transaction.");
 		}
 		tx = this.initTransaction(tx);
 		// this.acquireContainerLock(tx);
 
 		this.c.commit(tx);
 
 		// remove this container from the transaction.
 		tx.removeContainerRef(this.getCref());
 
 		// TransactionManager.getInstance().removeTransaction(tx);
 		if (logger.isDebugEnabled()) {
 			logger.debug("commit() transaction commited -- " + this.getCref());
 		}
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public void rollback(Transaction tx) throws InvalidTransactionException,
 			TransactionLockException, AspectRescheduleException,
 			AspectNotOkException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("rollback(" + tx + ") -- " + this.getCref());
 		}
 		if (tx == null) {
 			throw new IllegalArgumentException("Can not rollback transaction "
 					+ tx);
 		}
 		if (tx.getFather() != null) {
 			throw new IllegalArgumentException(
 					"Can not commit a child transaction.");
 		}
 		tx = this.initTransaction(tx);
 		// this.acquireContainerLock(tx);
 
 		c.rollback(tx);
 
 		// remove this container from the transaction.
 		tx.removeContainerRef(this.getCref());
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("rollback() transaction rolled back -- "
 					+ this.getCref());
 		}
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public ICoordinator getCoordTypefromSelector(Class<? extends Selector> s)
 			throws NoSuchCoordinationTypeException {
 		return c.getCoordTypefromSelector(s);
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public int getSize() {
 		return c.getSize();
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public List<Entry> read(Transaction tx, List<Selector> selectors,
 			int retrycount, Properties aspectContext)
 			throws NoSuchCoordinationTypeException, CountNotMetException,
 			InvalidTransactionException, TransactionLockException,
 			AspectRescheduleException, AspectNotOkException {
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("read(" + tx + ", " + selectors + "," + retrycount
 					+ ", " + aspectContext + ") -- " + this.getCref());
 		}
 		Transaction stx = null;
 		try {
 			// Check if the Transaction is valid, or create an implicit one.
 			tx = this.initTransaction(tx);
 
 			boolean skip = false;
 			AspectContext acontext = new AspectContext(LocalIPoint.PreRead,
 					this.getCref(), tx, selectors, null, null, retrycount,
 					aspectContext);
 			try { // PreRead
 				this.executeAspect(acontext);
 			} catch (AspectRescheduleException e) {
 				this.rollbackSubtransaction(acontext.getTx());
 				throw e;
 			} catch (AspectNotOkException e) {
 				try {
 					TransactionManager.getInstance().rollbackTransaction(
 							acontext.getTx());
 				} catch (XCoreException e1) {
 					throw new FatalException(e1);
 				}
 				throw e;
 			} catch (AspectSkipException e) {
 				skip = true;
 			}
 			// the arguments could have been modified in the aspect.
 			tx = acontext.getTx();
 
 			stx = TransactionManager.getInstance().createSubTransaction(tx);
 
 			selectors = acontext.getSelectors();
 			retrycount = acontext.getRetrycount();
 
 			List<Entry> result = new ArrayList<Entry>();
 			if (!skip) {
 				result = c.read(stx, selectors);
 
 				// Set the locks.
 				for (Entry e : result) {
 					for (Selector s : e.getSelectors()) {
 						tx.addCoordinator(c.getCoordTypefromSelector(s
 								.getClass()));
 					}
 				}
 
 			}
 			try { // PostRead
 				acontext.setLocalIPoint(LocalIPoint.PostRead);
 				acontext.setEntries(result);
 				this.executeAspect(acontext);
 			} catch (AspectRescheduleException e) {
 				this.rollbackSubtransaction(stx);
 				throw e;
 			} catch (AspectNotOkException e) {
 				try {
 					TransactionManager.getInstance().rollbackTransaction(
 							acontext.getTx());
 				} catch (XCoreException e1) {
 					throw new FatalException(e1);
 				}
 				throw e;
 			} catch (AspectSkipException e) {
 				try {
 					TransactionManager.getInstance().rollbackTransaction(
 							acontext.getTx());
 				} catch (XCoreException e1) {
 					throw new FatalException(e1);
 				}
 				throw new FatalException(
 						"SKIP not allowed as answer of a post aspect.");
 			}
 			this.commitSubtransaction(stx);
 			tx = acontext.getTx();
 			// commit if we used an implicit transaction.
 			if (tx.isImplicit()) {
 				try {
 					TransactionManager.getInstance().commitTransaction(tx);
 				} catch (XCoreException e) {
 					throw new FatalException(e);
 				}
 			}
 
 			if (logger.isDebugEnabled()) {
 				logger.debug("read() entries read: " + acontext.getEntries()
 						+ " -- " + this.getCref());
 			}
 
 			return acontext.getEntries();
 		} catch (CountNotMetException e) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("read() CountNotMetException was thrown " + e
 						+ " -- " + this.getCref());
 			}
 			this.rollbackSubtransaction(stx);
 			throw e;
 		} catch (TransactionLockException e) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("read() TransactionLockException " + e + " -- "
 						+ this.getCref());
 			}
 			this.rollbackSubtransaction(stx);
 			throw e;
 		}
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public List<Entry> shift(List<Entry> entries, Transaction tx,
 			Properties aspectContext) throws NoSuchCoordinationTypeException,
 			InvalidTransactionException, TransactionLockException,
 			AspectRescheduleException, AspectNotOkException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("shift(" + entries + ", " + tx + ", " + aspectContext
 					+ ") -- " + this.getCref());
 		}
 		Transaction stx = null;
 		try {
 			// Check if the Transaction is valid, or create an implicit one.
 			tx = this.initTransaction(tx);
 
 			AspectContext acontext = new AspectContext(LocalIPoint.PreShift,
 					this.getCref(), tx, null, entries, null, 0, aspectContext);
 			boolean skip = false;
 			try { // PreShift
 				this.executeAspect(acontext);
 			} catch (AspectRescheduleException e) {
 				this.rollbackSubtransaction(acontext.getTx());
 				throw e;
 			} catch (AspectNotOkException e) {
 				try {
 					TransactionManager.getInstance().rollbackTransaction(
 							acontext.getTx());
 				} catch (XCoreException e1) {
 					throw new FatalException(e1);
 				}
 				throw e;
 			} catch (AspectSkipException e) {
 				skip = true;
 			}
 			entries = acontext.getEntries();
 			tx = acontext.getTx();
 
 			stx = TransactionManager.getInstance().createSubTransaction(tx);
 
 			List<Entry> shifted = null;
 			if (!skip) {
 				shifted = new ArrayList<Entry>();
 				for (Entry e : entries) {
 
 					shifted.addAll(this.c.shift(e, stx));
 
 					for (Selector s : e.getSelectors()) {
 						stx.addCoordinator(c.getCoordTypefromSelector(s
 								.getClass()));
 					}
 				}
 
 				// Set the locks on the deleted entries.
 				for (Entry en : shifted) {
 					for (Selector s : en.getSelectors()) {
 						stx.addCoordinator(c.getCoordTypefromSelector(s
 								.getClass()));
 					}
 				}
 			}
 			acontext.setDeleted(shifted);
 
 			try { // PostShift
 				acontext.setLocalIPoint(LocalIPoint.PostShift);
 				this.executeAspect(acontext);
 			} catch (AspectRescheduleException e) {
 				this.rollbackSubtransaction(stx);
 				throw e;
 			} catch (AspectNotOkException e) {
 				try {
 					TransactionManager.getInstance().rollbackTransaction(
 							acontext.getTx());
 				} catch (XCoreException e1) {
 					throw new FatalException(e1);
 				}
 				throw e;
 			} catch (AspectSkipException e) {
 				try {
 					TransactionManager.getInstance().rollbackTransaction(
 							acontext.getTx());
 				} catch (XCoreException e1) {
 					throw new FatalException(e1);
 				}
 				throw new FatalException(
 						"SKIP not allowed as answer of a post aspect.");
 			}
 			this.commitSubtransaction(stx);
 			tx = acontext.getTx();
 			// commit if we used an implicit transaction.
 			if (tx.isImplicit()) {
 				try {
 					TransactionManager.getInstance().commitTransaction(tx);
 				} catch (XCoreException e) {
 					throw new FatalException(e);
 				}
 			}
 
 			if (logger.isDebugEnabled()) {
 				logger.debug("shift() entries shifted: "
 						+ acontext.getDeleted());
 			}
 			return acontext.getDeleted();
 		} catch (TransactionLockException e) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("shift() TransactionLockException " + e + " -- "
 						+ this.getCref());
 			}
 			this.rollbackSubtransaction(stx);
 			throw e;
 		}
 
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public List<Entry> take(boolean isDelete, Transaction tx,
 			List<Selector> selectors, int retrycount, Properties aspectContext)
 			throws NoSuchCoordinationTypeException, CountNotMetException,
 			InvalidTransactionException, TransactionLockException,
 			AspectRescheduleException, AspectNotOkException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("take(" + isDelete + ", " + tx + ", " + selectors
 					+ ", " + retrycount + ", " + aspectContext + ") -- "
 					+ this.getCref());
 		}
 
 		Transaction stx = null;
 		try {
 			tx = this.initTransaction(tx);
 
 			AspectContext acontext = new AspectContext(
 					isDelete ? LocalIPoint.PreDestroy : LocalIPoint.PreTake,
 					this.getCref(), tx, selectors, null, null, retrycount,
 					aspectContext);
 			boolean skip = false;
 			try { // PreTake, PreDelete
 				this.executeAspect(acontext);
 			} catch (AspectRescheduleException e) {
 				this.rollbackSubtransaction(acontext.getTx());
 				throw e;
 			} catch (AspectNotOkException e) {
 				try {
 					TransactionManager.getInstance().rollbackTransaction(
 							acontext.getTx());
 				} catch (XCoreException e1) {
 					throw new FatalException(e1);
 				}
 				throw e;
 			} catch (AspectSkipException e) {
 				skip = true;
 			}
 			tx = acontext.getTx();
 			stx = TransactionManager.getInstance().createSubTransaction(tx);
 			selectors = acontext.getSelectors();
 			retrycount = acontext.getRetrycount();
 
 			List<Entry> entries = null;
 			if (!skip) {
 				// Get the list of entries.
 				entries = c.take(stx, selectors);
 				// Set the locks.
 				for (Entry e : entries) {
 					for (Selector s : e.getSelectors()) {
 						stx.addCoordinator(c.getCoordTypefromSelector(s
 								.getClass()));
 					}
 				}
 			}
 			acontext.setDeleted(entries);
 			try { // PostTake, PostDelete
 				acontext.setLocalIPoint(isDelete ? LocalIPoint.PostDestroy
 						: LocalIPoint.PostTake);
 				this.executeAspect(acontext);
 			} catch (AspectRescheduleException e) {
 				this.rollbackSubtransaction(stx);
 				throw e;
 			} catch (AspectNotOkException e) {
 				try {
 					TransactionManager.getInstance().rollbackTransaction(
 							acontext.getTx());
 				} catch (XCoreException e1) {
 					throw new FatalException(e1);
 				}
 				throw e;
 			} catch (AspectSkipException e) {
 				try {
 					TransactionManager.getInstance().rollbackTransaction(
 							acontext.getTx());
 				} catch (XCoreException e1) {
 					throw new FatalException(e1);
 				}
 				throw new FatalException(
 						"SKIP not allowed as answer of a post aspect.");
 			}
 			this.commitSubtransaction(stx);
 			tx = acontext.getTx();
 			// commit if we used an implicit transaction.
 			if (tx.isImplicit()) {
 				try {
 					TransactionManager.getInstance().commitTransaction(tx);
 				} catch (XCoreException e) {
 					throw new FatalException(e);
 				}
 			}
 
 			if (logger.isDebugEnabled()) {
 				logger.debug("take() entries taken: " + acontext.getDeleted()
 						+ " -- " + this.getCref());
 			}
 
 			return acontext.getDeleted();
 		} catch (CountNotMetException e) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("take() CountNotMetException was thrown: " + e
 						+ " -- " + this.getCref());
 			}
 			this.rollbackSubtransaction(stx);
 			throw e;
 		} catch (TransactionLockException e) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("take() TransactionLockException " + e + " -- "
 						+ this.getCref());
 			}
 			this.rollbackSubtransaction(stx);
 			throw e;
 		}
 	}
 
 	/***
 	 * Writes one Entry. The method uses a sub transaction for writing the entry
 	 * to ensure the all coordinators a rolled back if one coordinator can not
 	 * write the entry.
 	 * 
 	 * @param e
 	 *            the entry to write.
 	 * @param tx
 	 *            the transaction for the operation.
 	 * @throws ContainerFullException
 	 *             thrown when the entry can not be written because there is no
 	 *             free place for it (e.g. full bounded container, vector
 	 *             position already used, key already present).
 	 * @throws NoSuchCoordinationTypeException
 	 *             thrown when there is a selector which needs a coordination
 	 *             type which has not been activated on the container
 	 * @throws TransactionLockException
 	 *             if an entry or container is locked by another transaction.
 	 */
 	private void write(Entry e, Transaction tx) throws ContainerFullException,
 			TransactionLockException, NoSuchCoordinationTypeException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("write(" + e + ", " + tx + ") -- " + this.getCref());
 		}
 
 		// Every entry has to be written under one child tx.
 		// otherwise we could not roll back coordinators if one coordinator can
 		// not write.
 		Transaction stx = TransactionManager.getInstance()
 				.createSubTransaction(tx);
 
 		try {
 			c.write(e, stx);
 		} catch (ContainerFullException e1) {
 			this.rollbackSubtransaction(stx);
 			throw e1;
 		} catch (TransactionLockException e1) {
 			this.rollbackSubtransaction(stx);
 			throw e1;
 		} catch (NoSuchCoordinationTypeException e1) {
 			this.rollbackSubtransaction(stx);
 			throw e1;
 		}
 
 		for (Selector s : e.getSelectors()) {
 			stx.addCoordinator(c.getCoordTypefromSelector(s.getClass()));
 		}
 
 		this.commitSubtransaction(stx);
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("write() entry written -- " + this.getCref());
 		}
 
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public void write(List<Entry> entries, Transaction tx, int retrycount,
 			Properties aspectContext) throws ContainerFullException,
 			TransactionLockException, NoSuchCoordinationTypeException,
 			InvalidTransactionException, AspectRescheduleException,
 			AspectNotOkException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("write(" + entries + ", " + tx + ", " + retrycount
 					+ ", " + aspectContext + ") -- " + this.getCref());
 		}
 
 		// Check if the Transaction is valid, or create an implicit one.
 		tx = this.initTransaction(tx);
 		Transaction stx = null;
 		try {
 			AspectContext acontext = new AspectContext(LocalIPoint.PreWrite,
 					this.getCref(), tx, null, entries, null, retrycount,
 					aspectContext);
 			boolean skip = false;
 			try { // PreWrite
 				this.executeAspect(acontext);
 			} catch (AspectRescheduleException e) {
 				this.rollbackSubtransaction(acontext.getTx());
 				throw e;
 			} catch (AspectNotOkException e) {
 				try {
 					TransactionManager.getInstance().rollbackTransaction(
 							acontext.getTx());
 				} catch (XCoreException e1) {
 					throw new FatalException(e1);
 				}
 				throw e;
 			} catch (AspectSkipException e) {
 				skip = true;
 			}
 			tx = acontext.getTx();
 			entries = acontext.getEntries();
 			retrycount = acontext.getRetrycount();
 			// A bulk operation has to be performed under ONE child
 			// transaction.
 			stx = TransactionManager.getInstance().createSubTransaction(tx);
 
 			if (!skip) {
 				for (Entry e : entries) {
 					this.write(e, stx);
 				}
 			}
 			try { // PostWrite
 				acontext.setLocalIPoint(LocalIPoint.PostWrite);
 				this.executeAspect(acontext);
 			} catch (AspectRescheduleException e) {
 				this.rollbackSubtransaction(stx);
 				throw e;
 			} catch (AspectNotOkException e) {
 				try {
 					TransactionManager.getInstance().rollbackTransaction(
 							acontext.getTx());
 				} catch (XCoreException e1) {
 					throw new FatalException(e1);
 				}
 				throw e;
 			} catch (AspectSkipException e) {
 				// FIXME: what is to do here??
 				try {
 					TransactionManager.getInstance().rollbackTransaction(
 							acontext.getTx());
 				} catch (XCoreException e1) {
 					throw new FatalException(e1);
 				}
 				throw new FatalException(
 						"SKIP not allowed as answer of a post aspect.");
 			}
 			tx = acontext.getTx();
 			// commit the subtransaction.
 			this.commitSubtransaction(stx);
 
 			if (tx.isImplicit()) {
 				try {
 					TransactionManager.getInstance().commitTransaction(tx);
 				} catch (XCoreException e) {
 					throw new FatalException(e);
 				}
 			}
 		} catch (ContainerFullException e1) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("write() NoPlaceLeftException was thrown: " + e1
 						+ " -- " + this.getCref());
 			}
 			this.rollbackSubtransaction(stx);
 			if (tx.isImplicit()) {
 				try {
 					TransactionManager.getInstance().rollbackTransaction(tx);
 				} catch (XCoreException e) {
 					throw new FatalException(e);
 				}
 			}
 			throw e1;
 		} catch (TransactionLockException e) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("write() TransactionLockException " + e + " -- "
 						+ this.getCref() + " Reason: " + e.getReason());
 			}
 			this.rollbackSubtransaction(stx);
 			throw e;
 		}
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("write() entries written -- " + this.getCref());
 		}
 
 	}
 
 	/***
 	 * Checks if the transaction is valid. If tx is <code>null</code> a new
 	 * implicit transaction will be created and returned.<br>
 	 * The returned transaction has to be used for the work.
 	 * 
 	 * @param tx
 	 *            the transaction to check.
 	 * @return the transaction which has to be used.
 	 * @throws InvalidTransactionException
 	 *             if tx is invalid
 	 */
 	private Transaction initTransaction(Transaction tx)
 			throws InvalidTransactionException {
 		// check if we have to use an implicit transaction.
 		if (tx == null) {
 			tx = TransactionManager.getInstance().createImplicitTransaction(
 					ICapi.INFINITE_TIMEOUT);
 		}
 
 		// is this a valid transaction?
 		if (!TransactionManager.getInstance().isValid(tx)) {
 			throw new InvalidTransactionException("Unknown Transaction: " + tx);
 
 		}
 
 		tx.addContainerRef(this.getCref());
 
 		return tx;
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public ContainerRef getCref() {
 		return c.getCref();
 	}
 
 	/***
 	 * {@inheritDoc}.
 	 */
 	public void setCref(ContainerRef cref) {
 		c.setCref(cref);
 	}
 
 	/***
 	 * Creates an AspectContext and executes the aspects.
 	 * 
 	 * @param context
 	 *            the aspect context.
 	 * @throws AspectNotOkException
 	 *             thrown if the operation has to be rescheduled.
 	 * @throws AspectRescheduleException
 	 *             thrown if the operation has to be undone and the transaction
 	 *             has to be rolled back.
 	 * @throws AspectSkipException
 	 *             thrown if the operation shall be skiped.
 	 */
 	private void executeAspect(AspectContext context)
 			throws AspectNotOkException, AspectRescheduleException,
 			AspectSkipException {
 		// remember the tx.
 		Transaction tx = context.getTx();
                 
 		// give the aspect the "highest" transaction and make sure that it is
 		// not implicit (it would be committed when it is used to write into a
 		// container).
 		Transaction ntx = context.getTx();
 		while (ntx.getFather() != null) {
 			ntx = ntx.getFather();
 		}
 		boolean implicit = tx.isImplicit();
 		ntx.setImplicit(false);
 		context.setTx(ntx);
 
                 // put the originall Transaction into the AspectContext
                 Properties aspectContext = context.getAspectContext();
             
                 if (aspectContext == null) {
                     aspectContext = new Properties();
                     context.setAspectContext(aspectContext);
                 }
                 
                 aspectContext.put("Transaction", tx);
                 aspectContext.put("TxnIsImplicit", new Boolean(implicit));
                 
 
                 try {
 			this.aspectManager.execute(context);
 		} finally {
 			// if the tx has not been modified in the aspect
 			//if (!context.getTx().equals(ntx)) {
 				// reset the tx in the context.
 				context.setTx(tx);
 			//}
                         
 			// reset implicit
 			tx.setImplicit(implicit);
                         
             // remove the Transaction again from the AspectContext
             context.getAspectContext().remove("Transaction");
             context.getAspectContext().remove("TxnIsImplicit");
 		}
 	}
 
 	/***
 	 * 
 	 * {@inheritDoc}.
 	 */
 	// @Override
 	public String addAspects(List<IPoint> points, IAspect aspect,
 			Properties aspectContext) {
 		AspectContext acontext = new AspectContext(LocalIPoint.PreAddAspect,
 				points, aspect, aspectContext);
 		boolean skip = false;
 		String id = null;
 		try {
 			this.aspectManager.execute(acontext);
 		} catch (AspectNotOkException e) {
 			// TODO realy have to throw the exception?
 			throw new FatalException(
 					"Aspect is not allowed to answer NotOk here.");
 		} catch (AspectRescheduleException e) {
 			throw new FatalException(
 					"Aspect is not allowed to answer Delay here.");
 		} catch (AspectSkipException e) {
 			skip = true;
 		}
 		if (!skip) {
 			for (IPoint p : acontext.getIpoints()) {
 				id = this.aspectManager.addAspect(p, acontext.getAspect());
 			}
 		}
 		acontext.setLocalIPoint(LocalIPoint.PostAddAspect);
 		try {
 			this.aspectManager.execute(acontext);
 		} catch (Exception e) {
 			throw new FatalException(
 					"Aspect is not allowed to answer with something else then OK!");
 		}
 		return id;
 	}
 
 	/***
 	 * 
 	 * {@inheritDoc}.
 	 */
 	// @Override
 	public void removeAspect(IPoint p, URI uri, Properties aspectContext) {
 		AspectContext acontext = new AspectContext(LocalIPoint.PreRemoveAspect,
 				java.util.Arrays.asList(new IPoint[] { p }), uri, aspectContext);
 		boolean skip = false;
 		try {
 			this.aspectManager.execute(acontext);
 		} catch (AspectNotOkException e) {
 			// TODO really have to throw the exception?
 			throw new FatalException(
 					"Aspect is not allowed to answer NotOk here.");
 		} catch (AspectRescheduleException e) {
 			throw new FatalException(
 					"Aspect is not allowed to answer Delay here.");
 		} catch (AspectSkipException e) {
 			skip = true;
 		}
 		if (!skip) {
 			for (IPoint pp : acontext.getIpoints()) {
 				this.aspectManager.removeAspect(pp, acontext.getAspectURI());
 			}
 		}
 		try {
 			acontext.setLocalIPoint(LocalIPoint.PostRemoveAspect);
 			this.aspectManager.execute(acontext);
 		} catch (Exception e) {
 			// TODO realy have to throw the exception?
 
 			throw new FatalException(
 					"Aspect is not allowed to answer with something else then OK!");
 		}
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public void addCoordinator(Class<? extends Selector> s, ICoordinator coord) {
 		this.c.addCoordinator(s, coord);
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public List<ICoordinator> getCoordinators() {
 		// TODO Auto-generated method stub
 		return null;
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public int currentSize() {
 		return c.currentSize();
 	}
 }