package org.xvsm.internal;
   
   import java.net.URI;
   import java.util.ArrayList;
   import java.util.List;
   import java.util.Properties;
   import java.util.concurrent.ConcurrentHashMap;
   import java.util.concurrent.ScheduledFuture;
   
  import org.apache.log4j.Logger;
  import org.xvsm.coordinators.KeyCoordinator;
  import org.xvsm.coordinators.LindaCoordinator;
  import org.xvsm.core.AtomicEntry;
  import org.xvsm.core.Capi;
  import org.xvsm.core.ContainerRef;
  import org.xvsm.core.Entry;
  import org.xvsm.core.Tuple;
  import org.xvsm.core.aspect.IPoint;
  import org.xvsm.core.aspect.LocalAspect;
  import org.xvsm.core.aspect.LocalIPoint;
  import org.xvsm.interfaces.ICapi;
  import org.xvsm.interfaces.IContainerManager;
  import org.xvsm.interfaces.ICoordinator;
  import org.xvsm.interfaces.container.IContainer;
  import org.xvsm.internal.exceptions.AspectNotOkException;
  import org.xvsm.internal.exceptions.AspectRescheduleException;
  import org.xvsm.internal.exceptions.AspectSkipException;
  import org.xvsm.internal.exceptions.ContainerNameOccupiedException;
  import org.xvsm.internal.exceptions.CountNotMetException;
  import org.xvsm.internal.exceptions.FatalException;
  import org.xvsm.internal.exceptions.InvalidContainerException;
  import org.xvsm.internal.exceptions.XCoreException;
  import org.xvsm.selectors.KeySelector;
  import org.xvsm.selectors.LindaSelector;
  import org.xvsm.selectors.RandomSelector;
  import org.xvsm.selectors.Selector;
  import org.xvsm.transactions.Transaction;
  
  /***
   * 
   * @author Christian Schreiber, Michael Proestler
   * 
   */
  public final class ContainerManager implements IContainerManager {
  
  	/***
  	 * Updates the timeout of blocking events in a container.
  	 * 
  	 * @author Christian Schreiber, Michael Proestler
  	 * 
  	 */
  	private class TimeoutHandler implements Runnable {
  
  		/***
  		 * The container.
  		 */
  		private IContainer c;
  
  		/***
  		 * Creates a new UpdateTimeoutThread.
  		 * 
  		 * @param c
  		 *            the container to update.
  		 */
  		public TimeoutHandler(IContainer c) {
  			this.c = c;
  		}
  
  		/***
  		 * 
  		 * {@inheritDoc}.
  		 */
  		// @Override
  		public void run() {
  			Thread.currentThread().setName(this.getClass().getName());
  			c.updateTimeouts();
  		}
  
  		/***
  		 * @return the ccontainer
  		 */
  		public IContainer getC() {
  			return c;
  		}
  
  		/***
  		 * 
  		 * {@inheritDoc}.
  		 */
  		@Override
  		public int hashCode() {
  			final int prime = 31;
  			int result = 1;
  			result = prime * result + ((c == null) ? 0 : c.hashCode());
  			return result;
  		}
  
  		/***
  		 * 
 		 * {@inheritDoc}.
 		 */
 		@Override
 		public boolean equals(Object obj) {
 			if (this == obj) {
 				return true;
 			}
 			if (obj == null) {
 				return false;
 			}
 			if (getClass() != obj.getClass()) {
 				return false;
 			}
 			final TimeoutHandler other = (TimeoutHandler) obj;
 			if (c == null) {
 				if (other.c != null) {
 					return false;
 				}
 			} else if (!c.equals(other.c)) {
 				return false;
 			}
 			return true;
 		}
 
 	}
 
 	/***
 	 * Contains all timeout handler.
 	 */
 	private ConcurrentHashMap<ContainerRef, ScheduledFuture<?>> timeoutHandler;
 
 	/***
 	 * The logger of this class.
 	 */
 	private static Logger logger = Logger.getLogger(ContainerManager.class);
 
 	/***
 	 * An Instance of the ContainerManager. Singleton-Pattern.
 	 */
 	private static ContainerManager mngr;
 
 	/***
 	 * The Container which has all ContainerRefs.
 	 */
 	private IContainer containerContainer;
 
 	/***
 	 * The container which is used for management of named container.
 	 */
 	private IContainer lookupContainer;
 
 	/***
 	 * The Capi to access the containerContainer.
 	 */
 	private ICapi capi;
 
 	/***
 	 * Private default constructor.
 	 */
 	private ContainerManager() {
 		// Create the containercontainer
 		ContainerRef cccref = new ContainerRef();
 		cccref.setSite(null);
 		this.containerContainer = new BlockingLayer(IContainer.INFINITE_SIZE);
 		this.containerContainer.setCref(cccref);
 		ICoordinator keyCoord = new KeyCoordinator(new KeyCoordinator.KeyType(
 				"system", Object.class));
 		ICoordinator lindaCoord = new LindaCoordinator();
 		this.containerContainer.addCoordinator(keyCoord.getDefaultSelector(),
 				keyCoord);
 		this.containerContainer.addCoordinator(lindaCoord.getDefaultSelector(),
 				lindaCoord);
 
 		// create the lookupcontainer
 		ContainerRef lccref = new ContainerRef();
 		lccref.setSite(null);
 		this.lookupContainer = new BlockingLayer(IContainer.INFINITE_SIZE);
 		this.lookupContainer.setCref(lccref);
 		ICoordinator lckeyCoord = new KeyCoordinator(
 				new KeyCoordinator.KeyType("lookup", String.class));
 		ICoordinator lclindaCoord = new LindaCoordinator();
 		this.lookupContainer.addCoordinator(lckeyCoord.getDefaultSelector(),
 				lckeyCoord);
 		this.lookupContainer.addCoordinator(lindaCoord.getDefaultSelector(),
 				lclindaCoord);
 		// Add an aspect to the lookup Container which writes the name of a
 		// published container into its meta container and remote the name from
 		// the meta container when the container is unpublished.
 		this.lookupContainer.addAspects(java.util.Arrays.asList(new IPoint[] {
 				LocalIPoint.PostWrite, LocalIPoint.PostDestroy }),
 				new LocalAspect() {
 
 					private ContainerRef metaCref;
 					private KeySelector<?> ks = null;
 
 					private void prepare(ContainerRef cref, Transaction tx,
 							List<Entry> entries, Properties contextProperties) {
 						try {
 							if (entries.size() == 1
 									&& entries.get(0) instanceof AtomicEntry<?>) {
 								AtomicEntry<?> e = (AtomicEntry<?>) entries
 										.get(0);
 								ks = null;
 								for (Selector s : e.getSelectors()) {
 									if (s instanceof KeySelector
 											&& ((KeySelector<?>) s)
 													.getKeyName().equals(
 															"lookup")) {
 										ks = (KeySelector<?>) s;
 									}
 								}
 								// Store the name in the meta container of the
 								// container:
 								String containerUri = ((URI) ((AtomicEntry<?>) entries
 										.get(0)).getValue()).toASCIIString();
 								metaCref = new ContainerRef(new URI(
 										containerUri + "/meta"));
 								// TODO is the lookup container realy always on
 								// the same site as the container?
 								metaCref.setSite(cref.getSite());
 							}
 						} catch (Exception e) {
 							throw new FatalException(e);
 						}
 					}
 
 					public void postWrite(ContainerRef cref, Transaction tx,
 							List<Entry> entries, Properties contextProperties)
 							throws AspectNotOkException,
 							AspectRescheduleException, AspectSkipException {
 						try {
 							this.prepare(cref, tx, entries, contextProperties);
 							capi.shift(metaCref, tx, new AtomicEntry<String>(
 									(String) ks.getKeyValue(), String.class,
 									new KeySelector<String>("system", "name")));
 						} catch (Exception e) {
 							throw new FatalException(e);
 						}
 					}
 
 					public void postDestroy(ContainerRef cref, Transaction tx,
 							List<Selector> selectors, List<Entry> deleted,
 							Properties contextProperties)
 							throws AspectNotOkException,
 							AspectRescheduleException, AspectSkipException {
 						try {
 							this.prepare(cref, tx, deleted, contextProperties);
 							capi.destroy(metaCref, 0, tx,
 									new KeySelector<String>("system", "name"));
 						} catch (Exception e) {
 							// the container has been removed, therefore the
 							// meta container has also been removed -> we do not
 							// have to remove anything.
 						}
 					}
 				}, null);
 		TimeoutSchedulerPool.schedule(new TimeoutHandler(lookupContainer));
 
 		try {
 			this.capi = new Capi();
 		} catch (XCoreException e) {
 			throw new FatalException(e);
 		}
 		this.timeoutHandler = new ConcurrentHashMap<ContainerRef, ScheduledFuture<?>>();
 	}
 
 	/***
 	 * Singleton-Pattern. Returns an Instance of the ContainerManager.
 	 * 
 	 * @return an Instance of ContainerManager.
 	 */
 	public static synchronized ContainerManager getInstance() {
 		if (mngr == null) {
 			mngr = new ContainerManager();
 		}
 		return mngr;
 	}
 
 	public static synchronized boolean hasInstance() {
 		return (mngr != null);
 	}
 
 	/***
 	 * Removes the instance.
 	 * 
 	 */
 	public static synchronized void removeInstance() {
 		mngr = null;
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public synchronized ContainerRef createContainer(Transaction tx, int size)
 			throws ContainerNameOccupiedException {
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("createContainer(" + tx + ", " + size + ")");
 		}
 
 		if (tx != null && tx.isImplicit()) {
 			tx = null;
 		}
 
 		ContainerRef cref = new ContainerRef();
 		IContainer c = new BlockingLayer(size);
 		cref.setContainer(c);
 		c.setCref(cref);
 
 		ContainerRef metaCref = new ContainerRef();
 		IContainer metaC = new BlockingLayer(IContainer.INFINITE_SIZE);
 		metaC.addCoordinator(KeySelector.class, new KeyCoordinator(
 				new KeyCoordinator.KeyType("system", Object.class)));
 		metaC.setCref(metaCref);
 
 		Tuple tuple = new Tuple();
 		// [cref,container,metaCref]
 		// the cref of the container
 		tuple.add(new AtomicEntry<ContainerRef>(cref));
 		// the container
 		tuple.add(new AtomicEntry<IContainer>(c));
 		// the meta container of this container.
 		tuple.add(new AtomicEntry<ContainerRef>(metaCref));
 
 		Tuple metaTuple = new Tuple();
 		metaTuple.add(new AtomicEntry<ContainerRef>(metaCref));
 		metaTuple.add(new AtomicEntry<IContainer>(metaC));
 		// meta container of a meta container is the meta container itself
 		metaTuple.add(new AtomicEntry<ContainerRef>(metaCref));
 
 		try {
 			if (logger.isDebugEnabled()) {
 				logger.debug("createContainer() write new container "
 						+ "into the containterContainer");
 			}
 			capi.write(this.containerContainer.getCref(), 0, tx, tuple,
 					metaTuple);
 		} catch (XCoreException e) {
 			throw new FatalException(e);
 		}
 
 		TimeoutHandler th = new TimeoutHandler(c);
 		this.timeoutHandler.put(cref, TimeoutSchedulerPool.schedule(th));
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("createContainer() container created: " + cref);
 		}
 
 		// add the aspect which handles the retrieval of the number of currently
 		// available entries.
 		LocalAspect aspect = new LocalAspect() {
 			public void preRead(ContainerRef cref, Transaction tx,
 					List<Selector> selectors, int retrycount,
 					java.util.Properties contextProperties)
 					throws AspectNotOkException, AspectRescheduleException,
 					AspectSkipException {
 				for (Selector s : selectors) {
 					if (s instanceof KeySelector) {
 						KeySelector<?> ks = (KeySelector<?>) s;
 						if (ks.getKeyName().equals("system")
 								&& ks.getKeyValue().equals("current_size")) {
 							throw new AspectSkipException();
 						}
 					}
 				}
 			}
 
 			public void postRead(ContainerRef cref, Transaction tx,
 					List<Entry> entries, List<Selector> selectors,
 					java.util.Properties contextProperties)
 					throws AspectNotOkException, AspectRescheduleException,
 					AspectSkipException {
 				for (Selector s : selectors) {
 					if (s instanceof KeySelector) {
 						KeySelector<?> ks = (KeySelector<?>) s;
 						if (ks.getKeyName().equals("system")
 								&& ks.getKeyValue().equals("current_size")) {
 							ContainerManager cm = ContainerManager
 									.getInstance();
 							IContainer c = cm.getContainer(cref);
 							Integer currentSize = c.currentSize();
 							entries.add(new AtomicEntry<Integer>(currentSize));
 						}
 					}
 				}
 			}
 
 			public Properties getProperties() {
 				return new Properties();
 			}
 
 			public void setProperties(Properties props) {
 				// not necessary
 			}
 		};
 		metaC.addAspects(java.util.Arrays.asList(new IPoint[] {
 				LocalIPoint.PreRead, LocalIPoint.PostRead }), aspect, null);
 
 		return cref;
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public synchronized ContainerRef createContainer(Transaction tx, int size,
 			ICoordinator... coordinators) throws ContainerNameOccupiedException {
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("createContainer(" + tx + ", " + size + coordinators
 					+ ")");
 		}
 		try {
 			IContainer c = this
 					.getContainer(tx, this.createContainer(tx, size));
 			for (ICoordinator coord : coordinators) {
 				c.addCoordinator(coord.getDefaultSelector(), coord);
 			}
 
 			// write information in the meta container
 			// the name, maximum size and the coordinators are written into the
 			// space. The current size can be queried with an key selector but
 			// it is realized with an aspect. The aspect is added in
 			// createContainer
 			Tuple template = new Tuple();
 			template.add(new AtomicEntry<ContainerRef>(c.getCref()));
 			template.add((Entry) null);
 			template.add((Entry) null);
 
 			Entry[] entries = this.capi.read(this.containerContainer.getCref(),
 					0, tx, new LindaSelector(template));
 			ContainerRef metaCref = (ContainerRef) ((AtomicEntry<?>) ((Tuple) entries[0])
 					.getEntryAt(2)).getValue();
 
 			Tuple cTuple = new Tuple();
 			for (ICoordinator co : coordinators) {
 				cTuple.add(new AtomicEntry<String>(co.getClass()
 						.getSimpleName()));
 			}
 			cTuple.addSelectors(new KeySelector<String>("system",
 					"coordinators"));
 			capi.write(metaCref, 0, tx, cTuple);
 			capi.write(metaCref, 0, tx, new AtomicEntry<Integer>(size,
 					Integer.class,
 					new KeySelector<String>("system", "max_size")));
 			if (logger.isDebugEnabled()) {
 				logger.debug("createContainer() container created: "
 						+ c.getCref());
 			}
 
 			return c.getCref();
 		} catch (XCoreException e) {
 			throw new FatalException(e);
 		}
 
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	public void deleteContainer(Transaction tx, ContainerRef cref) {
 		if (logger.isDebugEnabled()) {
 			logger.debug("deleteContainer(" + tx + "," + cref + ")");
 		}
 
 		if (cref.equals(this.containerContainer.getCref())) {
 			logger.warn("Sombody tries to "
 					+ "remote the containercontainer ... abort");
 			return;
 		}
 
 		if (tx != null && tx.isImplicit()) {
 			tx = null;
 		}
 
 		Tuple template = new Tuple();
 		template.add(new AtomicEntry<ContainerRef>(cref));
 		template.add((Entry) null);
 		template.add((Entry) null);
 
 		Selector selector = new LindaSelector(template);
 		try {
 			// search for the container to delete.
 			Entry[] entries = capi.take(this.containerContainer.getCref(), 0,
 					tx, selector);
 			if (entries != null && entries.length > 0 && entries[0] != null) {
 				ContainerRef metaCref = (ContainerRef) ((AtomicEntry<?>) ((Tuple) entries[0])
 						.getEntryAt(2)).getValue();
 				// destroy the container. (the container has to free all
 				// resources and abort blocking tasks).
 				IContainer cc = (IContainer) ((AtomicEntry<?>) ((Tuple) entries[0])
 						.getEntryAt(1)).getValue();
 				cc.destroy();
 
 				if (!metaCref.equals(cref)) {
 					// remove the scheduler
 					this.timeoutHandler.get(cref).cancel(true);
 					this.timeoutHandler.remove(cref);
 					// destroy the meta container
 					this.deleteContainer(tx, metaCref);
 					cref.setContainer(null);
 					if (logger.isDebugEnabled()) {
 						logger.debug("deleteContainer() removed the"
 								+ " timeout scheduler for the container.");
 					}
 				}
 			}
 			// delete the container from the lookup container:
 			capi.destroy(this.lookupContainer.getCref(), 0, tx,
 					new LindaSelector(new AtomicEntry<String>(cref.asURI()
 							.toASCIIString())));
 		} catch (CountNotMetException e) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("deleteContainer() container (" + cref
 						+ ") can not be found. (" + e + ")");
 			}
 		} catch (XCoreException e) {
 			throw new FatalException(e);
 		}
 		if (logger.isDebugEnabled()) {
 			logger.debug("deleteContainer() container (" + cref + ") deleted");
 		}
 	}
 
 	/***
 	 * {@inheritDoc}
 	 */
 	// @Override
 	public IContainer getContainer(Transaction tx, ContainerRef cref)
 			throws InvalidContainerException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("getContainer(" + tx + ", " + cref + ")");
 		}
 
 		// Check whether the container or the metacontainer shall be returned:
 		String path = cref.asURI().getPath();
 		if (path.endsWith("/meta")) {
 			IContainer cc = this.getContainer(tx, this.getMetaContainer(tx,
 					new ContainerRef(path.substring("/containers/".length(),
 							path.lastIndexOf("/meta")))));
 			return cc;
 		}
 		// Check whether the lookupcontainer shall be returned:
 		if (path.endsWith("/lookup")
 				|| cref.getId().equals(this.lookupContainer.getCref().getId())) {
 			return this.lookupContainer;
 		}
 
 		// check if the cref already has reference to the container.
 		if (cref.getContainer() != null) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("getContainer() the container is cached."
 						+ "Do not have to read from the container.");
 			}
 			return cref.getContainer();
 		}
 
 		if (tx != null && tx.isImplicit()) {
 			tx = null;
 		}
 
 		if (cref.getId().equals(this.containerContainer.getCref().getId())) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("getCotainer() asked for \"ContainerContainer\": "
 						+ this.containerContainer);
 			}
 			return this.containerContainer;
 		}
 		Tuple template = new Tuple();
 		template.add(new AtomicEntry<ContainerRef>(cref));
 		template.add((Entry) null);
 		template.add((Entry) null);
 
 		Selector selector = new LindaSelector(1, template);
 		try {
 			// try to read the container -> if it does not exist return null.
 			Entry[] entries;
 			try {
 				// it is possible that we have to lookup a container when the
 				// transaction is rolled back
 				boolean underRollback = false;
 				if (tx != null) {
 					underRollback = tx.isUnderRollback();
 					tx.setUnderRollback(false);
 				}
 				entries = capi.read(this.containerContainer.getCref(), 0, tx,
 						selector);
 				if (tx != null) {
 					tx.setUnderRollback(underRollback);
 				}
 			} catch (CountNotMetException e) {
 				return null;
 			}
 
 			if (logger.isDebugEnabled()) {
 				logger.debug("getContainer() "
 						+ (IContainer) ((AtomicEntry<?>) ((Tuple) entries[0])
 								.getEntryAt(1)).getValue());
 			}
 			// return the container.
 			return (IContainer) ((AtomicEntry<?>) ((Tuple) entries[0])
 					.getEntryAt(1)).getValue();
 		} catch (XCoreException e) {
 			throw new FatalException(e);
 		}
 	}
 
 	/***
 	 * 
 	 * {@inheritDoc}.
 	 */
 	public ContainerRef getContainer(Transaction tx, String name)
 			throws InvalidContainerException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("getContainer(" + tx + ", " + name + ")");
 		}
 
 		if (tx != null && tx.isImplicit()) {
 			tx = null;
 		}
 
 		Selector selector = new KeySelector<String>("names", name);
 		Entry[] entries;
 		try {
 			entries = capi.read(this.containerContainer.getCref(), 0, tx,
 					selector);
 			if (entries == null || entries.length < 1 || entries[0] == null) {
 				throw new XCoreException();
 			}
 		} catch (XCoreException e) {
 			throw new InvalidContainerException(
 					"There is no container with name: " + name);
 		}
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("getContainer() returns: "
 					+ (ContainerRef) ((AtomicEntry<?>) ((Tuple) entries[0])
 							.getEntryAt(0)).getValue());
 		}
 		return (ContainerRef) ((AtomicEntry<?>) ((Tuple) entries[0])
 				.getEntryAt(0)).getValue();
 
 	}
 
 	/***
 	 * 
 	 * {@inheritDoc}.
 	 */
 	public ContainerRef getMetaContainer(Transaction tx, ContainerRef cref)
 			throws InvalidContainerException {
 		if (logger.isDebugEnabled()) {
 			logger.debug("getMetaContainer(" + tx + ", " + cref + ")");
 		}
 
 		if (tx != null && tx.isImplicit()) {
 			tx = null;
 		}
 
 		Tuple template = new Tuple();
 		template.add(new AtomicEntry<ContainerRef>(cref));
 		template.add((Entry) null);
 		template.add((Entry) null);
 
 		Entry[] entries = null;
 		try {
 			entries = this.capi.read(this.containerContainer.getCref(), 0, tx,
 					new LindaSelector(template));
 		} catch (XCoreException e) {
 			if (e instanceof CountNotMetException) {
 				throw new InvalidContainerException(
 						"The meta container does not exist");
 			}
 			throw new FatalException(e);
 		}
 		if (entries != null && entries.length > 0 && entries[0] != null) {
 			if (logger.isDebugEnabled()) {
 				logger.debug("getMetaContainer() "
 						+ (ContainerRef) ((AtomicEntry<?>) ((Tuple) entries[0])
 								.getEntryAt(0)).getValue());
 			}
 
 			return (ContainerRef) ((AtomicEntry<?>) ((Tuple) entries[0])
 					.getEntryAt(2)).getValue();
 		}
 
 		return null;
 	}
 
 	/***
 	 * 
 	 * {@inheritDoc}.
 	 */
 	@SuppressWarnings("unchecked")
 	public List<ContainerRef> getAllContainer(Transaction tx) {
 		if (logger.isDebugEnabled()) {
 			logger.debug("getAllContainer(" + tx + ")");
 		}
 
 		if (tx != null && tx.isImplicit()) {
 			tx = null;
 		}
 
 		List<ContainerRef> crefs = new ArrayList<ContainerRef>();
 		try {
 			Entry[] entries = this.capi.read(this.containerContainer.getCref(),
 					0, tx, new RandomSelector(Selector.CNT_ALL));
 
 			// Copy the crefs into a list.
 			for (Entry e : entries) {
 				Tuple t = (Tuple) e;
 				// is this a meta container?
 				if (!(((AtomicEntry<ContainerRef>) t.getEntryAt(0)).getValue()
 						.equals(((AtomicEntry<ContainerRef>) t.getEntryAt(2))
 								.getValue()))) {
 					// if not add it to the crefs
 					// you can get the meta container with getMetaContainer
 					crefs.add((ContainerRef) ((AtomicEntry) ((Tuple) e)
 							.getEntryAt(0)).getValue());
 				}
 			}
 		} catch (XCoreException e) {
 			// ignore
 		}
 
 		if (logger.isDebugEnabled()) {
 			logger.debug("getAllContainer() returns (" + crefs.size()
 					+ ") crefs: " + crefs);
 		}
 		return crefs;
 	}
 
 	/***
 	 * Get the Container which has all ContainerRefs.
 	 * 
 	 * @return the Container which has the overview over all existing
 	 *         ContainerRefs.
 	 */
 	public IContainer getContainerContainer() {
 		return this.containerContainer;
 	}
 
 	/***
 	 * Returns the container to which the cref of the meta container belongs.
 	 * 
 	 * @param metaCref
 	 * @return
 	 */
 	private IContainer getContainer(ContainerRef metaCref) {
 		if (metaCref.equals(this.containerContainer.getCref())) {
 			return this.containerContainer;
 		}
 
 		Tuple template = new Tuple();
 		template.add((Entry) null);
 		template.add((Entry) null);
 		template.add(new AtomicEntry<ContainerRef>(metaCref));
 
 		Selector selector = new LindaSelector(2, template);
 		try {
 			// try to read the container -> if it does not exist return null.
 			Entry[] entries;
 			try {
 				entries = capi.read(this.containerContainer.getCref(), 0, null,
 						selector);
 			} catch (CountNotMetException e) {
 				return null;
 			}
 			for (Entry e : entries) {
 				Tuple t = (Tuple) e;
 				if (t.getEntryAt(0).equals(t.getEntryAt(2))) {
 					// if the first and the third entry in the tuple are equals
 					// this is the normal container and not the meta container.
 					continue;
 				} else {
 					return (IContainer) ((AtomicEntry<?>) t.getEntryAt(1))
 							.getValue();
 				}
 			}
 			return (IContainer) ((AtomicEntry<?>) ((Tuple) entries[0])
 					.getEntryAt(1)).getValue();
 		} catch (XCoreException e) {
 			throw new FatalException(e);
 		}
 	}
 }