rework model containers

49 files changed, 1639 insertions, 2014 deletions

diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/JpaModel.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/JpaModel.java
index 10924b7838..3f2efdd9c2 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/JpaModel.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/JpaModel.java
@@ -55,6 +55,9 @@ public interface JpaModel
 	 * Fire a state change event. Implied by this behavior is that any change
 	 * to any JPA model in a JPA project will trigger the JPA project to fire a
 	 * state change event.
+	 * <p>
+	 * The intent is for this method to be called by the JPA model's children
+	 * whenever their state has changed.
 	 * 
 	 * @see Model#addStateChangeListener(org.eclipse.jpt.common.utility.model.listener.StateChangeListener)
 	 * @see org.eclipse.jpt.common.utility.model.event.StateChangeEvent
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/AbstractJpaModel.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/AbstractJpaModel.java
index 5cb80eeb49..ffe925f0fd 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/AbstractJpaModel.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/AbstractJpaModel.java
@@ -9,25 +9,17 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal;
 
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.Set;
-import java.util.Vector;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jpt.common.core.internal.utility.PlatformTools;
-import org.eclipse.jpt.common.core.internal.utility.jdt.JDTModifiedDeclaration.Adapter;
 import org.eclipse.jpt.common.utility.internal.ObjectTools;
-import org.eclipse.jpt.common.utility.internal.collection.CollectionTools;
-import org.eclipse.jpt.common.utility.internal.iterable.IterableTools;
-import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools;
 import org.eclipse.jpt.common.utility.internal.model.AbstractModel;
 import org.eclipse.jpt.common.utility.internal.model.AspectChangeSupport;
 import org.eclipse.jpt.common.utility.internal.model.ChangeSupport;
-import org.eclipse.jpt.common.utility.iterable.ListIterable;
 import org.eclipse.jpt.jpa.core.JpaDataSource;
 import org.eclipse.jpt.jpa.core.JpaFactory;
 import org.eclipse.jpt.jpa.core.JpaFile;
@@ -35,7 +27,6 @@ import org.eclipse.jpt.jpa.core.JpaModel;
 import org.eclipse.jpt.jpa.core.JpaPlatform;
 import org.eclipse.jpt.jpa.core.JpaPlatformVariation;
 import org.eclipse.jpt.jpa.core.JpaProject;
-import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.jpa2.JpaFactory2_0;
 import org.eclipse.jpt.jpa.core.jpa2.JpaProject2_0;
 import org.eclipse.jpt.jpa.core.jpa2_1.JpaFactory2_1;
@@ -91,11 +82,19 @@ public abstract class AbstractJpaModel<P extends JpaModel>
 	}
 
 	protected AspectChangeSupport.Listener buildChangeSupportListener() {
-		return new AspectChangeSupport.Listener() {
-			public void aspectChanged(String aspectName) {
-				AbstractJpaModel.this.aspectChanged(aspectName);
-			}
-		};
+		return new AspectChangeSupportListener();
+	}
+
+	public class AspectChangeSupportListener
+		implements AspectChangeSupport.Listener
+	{
+		public void aspectChanged(String aspectName) {
+			AbstractJpaModel.this.aspectChanged(aspectName);
+		}
+		@Override
+		public String toString() {
+			return ObjectTools.toString(this);
+		}
 	}
 
 
@@ -107,18 +106,30 @@ public abstract class AbstractJpaModel<P extends JpaModel>
 	}
 
 
-	// ********** JpaNode implementation **********
+	// ********** JpaModel implementation **********
 
 	public P getParent() {
 		return this.parent;
 	}
 
+	/**
+	 * Overridden in:<ul>
+	 * <li>{@link AbstractJpaProject#getResource() AbstractJpaProject}
+	 * <li>{@link org.eclipse.jpt.jpa.core.internal.jpa1.context.GenericContextModelRoot#getResource() GenericContextModelRoot}
+	 * <li>{@link org.eclipse.jpt.jpa.core.internal.jpa1.context.java.GenericJarFile#getResource() GenericJarFile}
+	 * <li>{@link org.eclipse.jpt.jpa.core.internal.jpa1.context.orm.GenericOrmXml#getResource() GenericOrmXml}
+	 * <li>{@link org.eclipse.jpt.jpa.core.internal.jpa1.context.persistence.GenericPersistenceXml#getResource() GenericPersistenceXml}
+	 * <li>{@link org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaManagedType#getResource() AbstractJavaManagedType}
+	 * </ul>
+	 */
 	public IResource getResource() {
 		return this.parent.getResource();
 	}
 
 	/**
-	 * @see AbstractJpaProject#getJpaProject()
+	 * Overridden in:<ul>
+	 * <li>{@link AbstractJpaProject#getJpaProject() AbstractJpaProject}
+	 * </ul>
 	 */
 	public JpaProject getJpaProject() {
 		return this.parent.getJpaProject();
@@ -203,6 +214,10 @@ public abstract class AbstractJpaModel<P extends JpaModel>
 
 	// ********** AspectChangeSupport.Listener support **********
 
+	/**
+	 * The specified aspect name will be <code>null</code> for <em>state</em>
+	 * changes.
+	 */
 	protected void aspectChanged(String aspectName) {
 		if (this.aspectTriggersUpdate(aspectName)) {
 //			String msg = Thread.currentThread() + " aspect change: " + this + ": " + aspectName;
@@ -212,10 +227,18 @@ public abstract class AbstractJpaModel<P extends JpaModel>
 		}
 	}
 
+	/**
+	 * The specified aspect name will be <code>null</code> for <em>state</em>
+	 * changes.
+	 */
 	protected boolean aspectTriggersUpdate(String aspectName) {
 		return ! this.aspectDoesNotTriggerUpdate(aspectName);
 	}
 
+	/**
+	 * The specified aspect name will be <code>null</code> for <em>state</em>
+	 * changes.
+	 */
 	protected boolean aspectDoesNotTriggerUpdate(String aspectName) {
 		// ignore state changes so we don't get a stack overflow :-)
 		// (and we don't use state changes except here)
@@ -224,494 +247,50 @@ public abstract class AbstractJpaModel<P extends JpaModel>
 	}
 
 	protected final Set<String> nonUpdateAspectNames() {
+		@SuppressWarnings("unchecked")
+		Class<? extends AbstractJpaModel<?>> thisClass = (Class<? extends AbstractJpaModel<?>>) this.getClass();
 		synchronized (NON_UPDATE_ASPECT_NAME_SETS) {
-			HashSet<String> nonUpdateAspectNames = NON_UPDATE_ASPECT_NAME_SETS.get(this.getClass());
+			HashSet<String> nonUpdateAspectNames = NON_UPDATE_ASPECT_NAME_SETS.get(thisClass);
 			if (nonUpdateAspectNames == null) {
 				nonUpdateAspectNames = new HashSet<String>();
 				this.addNonUpdateAspectNamesTo(nonUpdateAspectNames);
-				@SuppressWarnings("unchecked")
-				Class<? extends AbstractJpaModel<?>> thisClass = (Class<? extends AbstractJpaModel<?>>) this.getClass();
 				NON_UPDATE_ASPECT_NAME_SETS.put(thisClass, nonUpdateAspectNames);
 			}
 			return nonUpdateAspectNames;
 		}
 	}
 
+	/**
+	 * Map sub-classes to the names of the aspects that should <em>not</em>
+	 * trigger a {@link AbstractJpaProject#update() JPA project update}.
+	 * This map is populated on-demand (i.e. as changes occur to instances of
+	 * the sub-classes).
+	 */
 	private static final HashMap<Class<? extends AbstractJpaModel<?>>, HashSet<String>> NON_UPDATE_ASPECT_NAME_SETS = new HashMap<Class<? extends AbstractJpaModel<?>>, HashSet<String>>();
 
+	/**
+	 * Extend this method to add (to the specified collection) the names of
+	 * aspects that should <em>not</em> trigger a JPA project <em>update</em>.
+	 * This list will be effective for <em>all</em> instances of the model's
+	 * class and will be built only once (per class loader).
+	 * <p>
+	 * To disable the JPA project <em>update</em> for changes to a particular
+	 * <em>instance</em>, override {@link #aspectTriggersUpdate(String)}.
+	 */
 	protected void addNonUpdateAspectNamesTo(@SuppressWarnings("unused") Set<String> nonUpdateAspectNames) {
 	// when you override this method, don't forget to include:
 	//	super.addNonUpdateAspectNamesTo(nonUpdateAspectNames);
 	}
 
+	/**
+	 * @see #aspectChanged(String)
+	 * @see AbstractJpaProject#stateChanged()
+	 * @see org.eclipse.jpt.jpa.core.internal.jpa1.context.GenericContextModelRoot#stateChanged()
+	 */
 	public void stateChanged() {
 		this.fireStateChanged();
 		if (this.parent != null) {
 			this.parent.stateChanged();
 		}
 	}
-
-
-	// ********** convenience stuff **********
-
-	/**
-	 * Adapter used to synchronize a context collection container with its corresponding
-	 * resource container.
-	 * @param <C> the type of context elements
-	 * @param <R> the type of resource elements
-	 */
-	protected abstract class CollectionContainer<C, R>
-		implements Iterable<C>
-	{
-		protected final Vector<C> contextElements = new Vector<C>();
-
-		protected CollectionContainer() {
-			super();
-		}
-
-		/**
-		 * Return the container's current set of resource elements.
-		 * These are what the context elements will be synchronized to.
-		 */
-		protected abstract Iterable<R> getResourceElements();
-
-		/**
-		 * Return the resource element corresponding to the specified context
-		 * element.
-		 */
-		protected abstract R getResourceElement(C contextElement);
-
-		/**
-		 * Build and return a context element for the given resource element
-		 */
-		protected abstract C buildContextElement(R resourceElement);
-
-		/**
-		 * Return the property name for event notification when the collection is changed.
-		 */
-		protected abstract String getContextElementsPropertyName();
-
-		/**
-		 * clients needs to call initialize if necessary
-		 */
-		public void initialize() {
-			for (R resourceElement : this.getResourceElements()) {
-				this.contextElements.add(this.buildContextElement(resourceElement));
-			}
-		}
-
-		/**
-		 * Return an Iterable of the context elements
-		 */
-		public Iterable<C> getContextElements() {
-			return IterableTools.cloneLive(this.contextElements);
-		}
-
-		public C get(int index) {
-			return this.contextElements.get(index);
-		}
-
-		public Iterator<C> iterator() {
-			return IteratorTools.clone(this.contextElements);
-		}
-
-		/**
-		 * Return the size of the context elements collection
-		 */
-		public int getContextElementsSize() {
-			return this.contextElements.size();
-		}
-
-		/**
-		 * Add a context element for the specified resource element at the
-		 * specified index.
-		 */
-		public C addContextElement(int index, R resourceElement) {
-			return this.addContextElement_(index, this.buildContextElement(resourceElement));
-		}
-
-		/**
-		 * Add the specified context element to the container at the specified
-		 * index.
-		 */
-		protected abstract C addContextElement_(int index, C element);
-
-		/**
-		 * Add context elements for the specified resource elements at the
-		 * specified index.
-		 */
-		public Iterable<C> addContextElements(int index, Iterable<R> resourceElements) {
-			ArrayList<C> newContextElements = new ArrayList<C>();
-			for (R resourceElement : resourceElements) {
-				newContextElements.add(this.buildContextElement(resourceElement));
-			}
-			return this.addAll(index, newContextElements);
-		}
-
-		/**
-		 * Add the specified context elements to the collection.
-		 */
-		protected abstract Iterable<C> addAll(int index, Iterable<C> elements);
-
-		/**
-		 * Remove the specified context element from the container.
-		 */
-		public abstract void removeContextElement(C element);
-
-		/**
-		 * Remove the specified context elements from the container.
-		 */
-		public abstract void removeAll(Iterable<C> elements);
-
-		protected abstract void moveContextElement(int index, C element);
-
-		protected void disposeElement(C element) {
-			//override if you need to dispose an element when it is removed
-		}
-
-		@Override
-		public String toString() {
-			return this.contextElements.toString();
-		}
-	}
-
-
-	/**
-	 * Adapter used to synchronize a context collection container with its corresponding
-	 * resource container.
-	 * @param <C> the type of context elements
-	 * @param <R> the type of resource elements
-	 */
-	protected abstract class AbstractContextCollectionContainer<C extends JpaContextModel, R>
-		extends CollectionContainer<C, R>
-	{
-		protected AbstractContextCollectionContainer() {
-			super();
-		}
-
-		/**
-		 * Using the specified adapter, synchronize a context container with its
-		 * corresponding resource container: moving, removing, and adding elements
-		 * as necessary.
-		 * <p>
-		 * We can do this because:<ul>
-		 * <li>the XML translators will <em>move</em> the EMF elements when
-		 * appropriate (as opposed to simply rebuilding them in place).
-		 * <li>the Java resource model will re-use existing annotations when
-		 * appropriate (as opposed to simply rebuilding them in place).
-		 * </ul>
-		 */
-		public void synchronizeWithResourceModel() {
-			sync(true);  // true = sync
-		}
-
-		/**
-		 * @see #synchronizeWithResourceModel(Adapter)
-		 */
-		public void update() {
-			sync(false);  // false = update
-		}
-
-		/**
-		 * The specified <code>sync</code> flag controls whether any surviving
-		 * context nodes are either <em>synchronized</em> (<code>true</code>) or
-		 * <em>updated</em> (<code>false</code>).
-		 */
-		protected void sync(boolean sync) {
-			HashSet<C> contextElements = CollectionTools.set(this.getContextElements());
-			ArrayList<C> contextElementsToSync = new ArrayList<C>(contextElements.size());
-			int resourceIndex = 0;
-
-			for (R resourceElement : this.getResourceElements()) {
-				boolean match = false;
-				for (Iterator<C> stream = contextElements.iterator(); stream.hasNext(); ) {
-					C contextElement = stream.next();
-					if (ObjectTools.equals(this.getResourceElement(contextElement), resourceElement)) {
-						// we don't know the source index because the element has been moved by previously moved elements
-						this.moveContextElement(resourceIndex, contextElement);
-						stream.remove();
-						// TODO perform update here someday...
-						contextElementsToSync.add(contextElement);
-						match = true;
-						break;
-					}
-				}
-				if ( ! match) {
-					// added elements are sync'ed during construction or will be
-					// updated during the next "update" (which is triggered by
-					// their addition to the model)
-					this.addContextElement(resourceIndex, resourceElement);
-				}
-				resourceIndex++;
-			}
-			// remove any leftover context elements
-			for (C contextElement : contextElements) {
-				removeContextElement(contextElement);
-			}
-			// TODO bjv
-			// take care of the structural changes before sync'ing the remaining elements;
-			// we might be able to do this inline once we get rid of the "list change" events
-			// and go with only add, remove, etc. list events
-			// (these syncs will trigger "list change" events with list aspect adapters, which
-			// trigger refreshes of UI adapters (e.g. TableModelAdapter) which will prematurely
-			// discover any structural changes... :( )
-			// see ItemAspectListValueModelAdapter.itemAspectChanged(EventObject)
-			for (C contextElement : contextElementsToSync) {
-				if (sync) {
-					contextElement.synchronizeWithResourceModel();
-				} else {
-					contextElement.update();
-				}
-			}
-		}
-	}
-
-
-	/**
-	 * Adapter used to synchronize a context collection container with its corresponding
-	 * resource container.
-	 * @param <C> the type of context elements
-	 * @param <R> the type of resource elements
-	 */
-	protected abstract class ContextCollectionContainer<C extends JpaContextModel, R>
-		extends AbstractContextCollectionContainer<C, R>
-	{
-		protected ContextCollectionContainer() {
-			super();
-		}
-
-		@Override
-		protected C addContextElement_(int index, C element) {
-			// ignore the index - not a list
-			AbstractJpaModel.this.addItemToCollection(element, this.contextElements, this.getContextElementsPropertyName());
-			return element;
-		}
-
-		@Override
-		protected Iterable<C> addAll(int index, Iterable<C> elements) {
-			// ignore the index - not a list
-			AbstractJpaModel.this.addItemsToCollection(elements, this.contextElements, this.getContextElementsPropertyName());
-			return elements;
-		}
-
-		@Override
-		public void removeContextElement(C contextElement) {
-			AbstractJpaModel.this.removeItemFromCollection(contextElement, this.contextElements, this.getContextElementsPropertyName());
-			this.disposeElement(contextElement);
-		}
-
-		@Override
-		public void removeAll(Iterable<C> elements) {
-			AbstractJpaModel.this.removeItemsFromCollection(elements, this.contextElements, this.getContextElementsPropertyName());
-			for (C element : elements) {
-				this.disposeElement(element);
-			}
-		}
-
-		@Override
-		protected void moveContextElement(int index, C element) {
-			// NOP - not a list
-		}
-	}
-
-
-	/**
-	 * Adapter used to synchronize a context list container with its corresponding
-	 * resource container.
-	 * @param <C> the type of context elements
-	 * @param <R> the type of resource elements
-	 */
-	protected abstract class ContextListContainer<C extends JpaContextModel, R>
-		extends AbstractContextCollectionContainer<C, R>
-	{
-		protected ContextListContainer() {
-			super();
-		}
-
-		@Override
-		public ListIterable<C> getContextElements() {
-			return IterableTools.cloneLive(this.contextElements);
-		}
-
-		@Override
-		protected abstract ListIterable<R> getResourceElements();
-
-		/**
-		 * Return the index of the specified context element.
-		 */
-		public int indexOfContextElement(C element) {
-			return this.contextElements.indexOf(element);
-		}
-
-		public C getContextElement(int index) {
-			return this.contextElements.elementAt(index);
-		}
-
-		@Override
-		protected C addContextElement_(int index, C element) {
-			AbstractJpaModel.this.addItemToList(index, element, this.contextElements, this.getContextElementsPropertyName());
-			return element;
-		}
-
-		@Override
-		public Iterable<C> addAll(int index, Iterable<C> elements) {
-			AbstractJpaModel.this.addItemsToList(index, elements, this.contextElements, this.getContextElementsPropertyName());
-			return elements;
-		}
-
-		/**
-		 * Move the context element at the specified target index to the 
-		 * specified source index.
-		 */
-		public void moveContextElement(int targetIndex, int sourceIndex) {
-			AbstractJpaModel.this.moveItemInList(targetIndex, sourceIndex, this.contextElements, this.getContextElementsPropertyName());
-		}
-
-		@Override
-		public void moveContextElement(int index, C element) {
-			AbstractJpaModel.this.moveItemInList(index, element, this.contextElements, this.getContextElementsPropertyName());
-		}
-
-		/**
-		 * clear the list of context elements
-		 */
-		public void clearContextList() {
-			for (C element : this.contextElements) {
-				this.disposeElement(element);
-			}
-			AbstractJpaModel.this.clearList(this.contextElements, getContextElementsPropertyName());
-		}
-
-		/**
-		 * Remove the context element at the specified index from the container.
-		 */
-		public C removeContextElement(int index) {
-			C element = AbstractJpaModel.this.removeItemFromList(index, this.contextElements, this.getContextElementsPropertyName());
-			this.disposeElement(element);
-			return element;
-		}
-
-		@Override
-		public void removeContextElement(C element) {
-			AbstractJpaModel.this.removeItemFromList(element, this.contextElements, this.getContextElementsPropertyName());
-			this.disposeElement(element);
-		}
-
-		@Override
-		public void removeAll(Iterable<C> elements) {
-			AbstractJpaModel.this.removeItemsFromList(elements, this.contextElements, this.getContextElementsPropertyName());
-			for (C element : elements) {
-				this.disposeElement(element);
-			}
-		}
-	}
-
-
-	/**
-	 * Adapter used to synchronize a context list container with its corresponding
-	 * resource container.
-	 * @param <C> the type of context elements
-	 * @param <R> the type of resource elements
-	 */
-	protected abstract class ListContainer<C, R>
-		extends CollectionContainer<C, R>
-	{
-		protected ListContainer() {
-			super();
-		}
-
-		@Override
-		public ListIterable<C> getContextElements() {
-			return IterableTools.cloneLive(this.contextElements);
-		}
-
-		@Override
-		protected abstract ListIterable<R> getResourceElements();
-
-		/**
-		 * Return the index of the specified context element.
-		 */
-		public int indexOfContextElement(C element) {
-			return this.contextElements.indexOf(element);
-		}
-
-		public C getContextElement(int index) {
-			return this.contextElements.get(index);
-		}
-
-		@Override
-		protected C addContextElement_(int index, C element) {
-			AbstractJpaModel.this.addItemToList(index, element, this.contextElements, this.getContextElementsPropertyName());
-			return element;
-		}
-
-		@Override
-		protected Iterable<C> addAll(int index, Iterable<C> newContextElements) {
-			AbstractJpaModel.this.addItemsToList(index, newContextElements, this.contextElements, this.getContextElementsPropertyName());
-			return newContextElements;
-		}
-
-		/**
-		 * Move the context element at the specified target index to the 
-		 * specified source index.
-		 */
-		public void moveContextElement(int targetIndex, int sourceIndex) {
-			AbstractJpaModel.this.moveItemInList(targetIndex, sourceIndex, this.contextElements, this.getContextElementsPropertyName());
-		}
-
-		@Override
-		public void moveContextElement(int index, C element) {
-			AbstractJpaModel.this.moveItemInList(index, element, this.contextElements, this.getContextElementsPropertyName());
-		}
-
-		@Override
-		public void removeContextElement(C element) {
-			AbstractJpaModel.this.removeItemFromList(element, this.contextElements, this.getContextElementsPropertyName());
-			this.disposeElement(element);
-		}
-
-		/**
-		 * Remove the context element at the specified index from the container.
-		 */
-		public C removeContextElement(int index) {
-			C element = AbstractJpaModel.this.removeItemFromList(index, this.contextElements, this.getContextElementsPropertyName());
-			this.disposeElement(element);
-			return element;
-		}
-
-		@Override
-		public void removeAll(Iterable<C> elements) {
-			AbstractJpaModel.this.removeItemsFromList(elements, this.contextElements, this.getContextElementsPropertyName());
-			for (C element : elements) {
-				this.disposeElement(element);
-			}
-		}
-
-		@Override
-		protected void disposeElement(C element) {
-			//override if you need to dispose an element when it is removed
-		}
-
-		public void synchronizeWithResourceModel() {
-			ListIterable<R> resourceElements = getResourceElements();
-			
-			int index = 0;
-			for (R resourceElement : resourceElements) {
-				if (this.getContextElementsSize() > index) {
-					C contextElement = this.getContextElement(index);
-					if (! ObjectTools.equals(this.getResourceElement(contextElement), resourceElement)) {
-						this.addContextElement(index, resourceElement);
-					}
-				}
-				else {
-					this.addContextElement(index, resourceElement);			
-				}
-				index++;
-			}
-			
-			for ( ; index < this.getContextElementsSize(); ) {
-				this.removeContextElement(index);
-			}
-		}
-	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/AbstractJpaContextModel.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/AbstractJpaContextModel.java
index c1ff6a7533..b97d746a78 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/AbstractJpaContextModel.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/AbstractJpaContextModel.java
@@ -3,18 +3,28 @@
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
- * 
+ *
  * Contributors:
  *     Oracle - initial API and implementation
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.context;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
+import java.util.ListIterator;
+import java.util.Vector;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.jpt.common.core.JptResourceType;
 import org.eclipse.jpt.common.core.internal.utility.ValidationMessageTools;
 import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.common.core.utility.ValidationMessage;
+import org.eclipse.jpt.common.utility.internal.ObjectTools;
+import org.eclipse.jpt.common.utility.internal.collection.CollectionTools;
+import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools;
+import org.eclipse.jpt.common.utility.iterable.ListIterable;
 import org.eclipse.jpt.jpa.core.JpaModel;
 import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.MappingFile;
@@ -78,7 +88,7 @@ public abstract class AbstractJpaContextModel<P extends JpaContextModel>
 	public JptResourceType getResourceType() {
 		return this.parent.getResourceType();
 	}
-	
+
 	/**
 	 * Overridden in:<ul>
 	 * <li>{@link org.eclipse.jpt.jpa.core.internal.context.persistence.AbstractPersistenceUnit#getPersistenceUnit() AbstractPersistenceUnit}
@@ -107,7 +117,7 @@ public abstract class AbstractJpaContextModel<P extends JpaContextModel>
 	// ********** validation **********
 
 	/**
-	 * All subclass implementations should be 
+	 * All subclass implementations should be
 	 * preceded by a "super" call to this method.
 	 */
 	public void validate(List<IMessage> messages, IReporter reporter) {
@@ -118,7 +128,8 @@ public abstract class AbstractJpaContextModel<P extends JpaContextModel>
 
 	/**
 	 * Return the specified text range if it is not <code>null</code>; if it is
-	 * <code>null</code>, return the node's validation text range.
+	 * <code>null</code>, return the model's validation text range.
+	 * Typically, the specified text range is for one of the model's children.
 	 */
 	protected TextRange getValidationTextRange(TextRange textRange) {
 		return (textRange != null) ? textRange : this.getValidationTextRange();
@@ -218,7 +229,7 @@ public abstract class AbstractJpaContextModel<P extends JpaContextModel>
 		}
 		return null;
 	}
-	
+
 	/**
 	 * This method is called if the database is connected, allowing us to
 	 * get candidates from the various database tables etc.
@@ -267,5 +278,564 @@ public abstract class AbstractJpaContextModel<P extends JpaContextModel>
 		MappingFile.Root mfr = this.getMappingFileRoot();
 		return (mfr != null) ? mfr.getCatalog() : this.getPersistenceUnit().getDefaultCatalog();
 	}
-	
+
+
+	// ********** containers **********
+
+	/**
+	 * Adapter used to synchronize a collection of context models with the
+	 * corresponding collection of resource models.
+	 * @param <C> the type of context elements
+	 * @param <R> the type of resource elements
+	 */
+	public static abstract class Container<C, R>
+		implements ListIterable<C>
+	{
+		/**
+		 * "Context" elements.
+		 */
+		protected final Vector<C> elements = new Vector<C>();
+
+		/**
+		 * Aspect name used for event notification when the
+		 * container's contents change.
+		 */
+		protected final String aspectName;
+
+		protected final Adapter<C, R> adapter;
+
+
+		protected Container(String aspectName, Adapter<C, R> adapter) {
+			super();
+			this.aspectName = aspectName;
+			this.adapter = adapter;
+		}
+
+		/**
+		 * Subclasses call this as necessary.
+		 */
+		protected void initialize() {
+			for (R resourceElement : this.adapter.getResourceElements()) {
+				this.elements.add(this.adapter.buildContextElement(resourceElement));
+			}
+		}
+
+		public C get(int index) {
+			return this.elements.get(index);
+		}
+
+		public ListIterator<C> iterator() {
+			return IteratorTools.clone(this.elements);
+		}
+
+		/**
+		 * Return the size of the context elements collection
+		 */
+		public int size() {
+			return this.elements.size();
+		}
+
+		/**
+		 * Add a context element for the specified resource element at the
+		 * specified index.
+		 */
+		public C addContextElement(int index, R resourceElement) {
+			return this.add(index, this.adapter.buildContextElement(resourceElement));
+		}
+
+		/**
+		 * Add the specified context element to the container at the specified
+		 * index.
+		 */
+		protected abstract C add(int index, C element);
+
+		/**
+		 * Add context elements for the specified resource elements at the
+		 * specified index.
+		 */
+		public Iterable<C> addContextElements(int index, Iterable<R> resourceElements) {
+			ArrayList<C> contextElements = new ArrayList<C>();
+			for (R resourceElement : resourceElements) {
+				contextElements.add(this.adapter.buildContextElement(resourceElement));
+			}
+			return this.addAll(index, contextElements);
+		}
+
+		/**
+		 * Add the specified context elements to the collection.
+		 */
+		protected abstract Iterable<C> addAll(int index, Iterable<C> contextElements);
+
+		/**
+		 * Remove the specified context element from the container.
+		 */
+		public abstract void remove(C element);
+
+		/**
+		 * Remove the specified context elements from the container.
+		 */
+		public abstract void removeAll(Iterable<C> contextElements);
+
+		protected abstract void move(int index, C element);
+
+		@Override
+		public String toString() {
+			return this.elements.toString();
+		}
+
+		/**
+		 * Adapter used by the container to convert resource and context
+		 * elements.
+		 */
+		public interface Adapter<C, R> {
+			/**
+			 * Return the current list of resource elements.
+			 * The context elements are synchronized with this list.
+			 */
+			Iterable<R> getResourceElements();
+
+			/**
+			 * Return the specified context element's resource element.
+			 * @see #buildContextElement(Object)
+			 */
+			R extractResourceElement(C contextElement);
+
+			/**
+			 * Build a context element for the specified resource element.
+			 * @see #extractResourceElement(Object)
+			 */
+			C buildContextElement(R resourceElement);
+		}
+	}
+
+	public abstract class AbstractContainerAdapter<C, R>
+		implements Container.Adapter<C, R>
+	{
+		@Override
+		public String toString() {
+			return ObjectTools.toString(this);
+		}
+	}
+
+
+	/**
+	 * Adapter used to synchronize a collection of context models with the
+	 * corresponding collection of resource models.
+	 * @param <C> the type of context elements
+	 * @param <R> the type of resource elements
+	 */
+	public abstract class ContextContainer<C extends JpaContextModel, R>
+		extends Container<C, R>
+	{
+		protected ContextContainer(String aspectName, Container.Adapter<C, R> adapter) {
+			super(aspectName, adapter);
+		}
+
+		/**
+		 * Synchronize the context container with its
+		 * corresponding resource container: moving, removing, and adding elements
+		 * as necessary.
+		 * <p>
+		 * We can do this because:<ul>
+		 * <li>the XML translators will <em>move</em> the EMF elements when
+		 * appropriate (as opposed to simply rebuilding them in place).
+		 * <li>the Java resource model will re-use existing annotations when
+		 * appropriate (as opposed to simply rebuilding them in place).
+		 * </ul>
+		 */
+		public void synchronizeWithResourceModel() {
+			this.sync(true);  // true = sync
+		}
+
+		/**
+		 * @see #synchronizeWithResourceModel()
+		 */
+		public void update() {
+			this.sync(false);  // false = update
+		}
+
+		/**
+		 * The specified <code>sync</code> flag controls whether any surviving
+		 * context nodes are either <em>synchronized</em> (<code>true</code>) or
+		 * <em>updated</em> (<code>false</code>).
+		 */
+		protected void sync(boolean sync) {
+			@SuppressWarnings("unchecked")
+			HashSet<C> contextElements = (HashSet<C>) CollectionTools.set(this.elements.toArray());
+			ArrayList<C> contextElementsToSync = new ArrayList<C>(contextElements.size());
+			int resourceIndex = 0;
+
+			for (R resourceElement : this.adapter.getResourceElements()) {
+				boolean match = false;
+				for (Iterator<C> stream = contextElements.iterator(); stream.hasNext(); ) {
+					C contextElement = stream.next();
+					if (ObjectTools.equals(this.adapter.extractResourceElement(contextElement), resourceElement)) {
+						// we don't know the source index because the element has been moved by previously moved elements
+						this.move(resourceIndex, contextElement);
+						stream.remove();
+						// TODO perform update here someday...
+						contextElementsToSync.add(contextElement);
+						match = true;
+						break;
+					}
+				}
+				if ( ! match) {
+					// added elements are sync'ed during construction or will be
+					// updated during the next "update" (which is triggered by
+					// their addition to the model)
+					this.addContextElement(resourceIndex, resourceElement);
+				}
+				resourceIndex++;
+			}
+			// remove any leftover context elements
+			for (C contextElement : contextElements) {
+				this.remove(contextElement);
+			}
+			// TODO bjv
+			// take care of the structural changes before sync'ing the remaining elements;
+			// we might be able to do this inline once we get rid of the "list change" events
+			// and go with only add, remove, etc. list events
+			// (these syncs will trigger "list change" events with list aspect adapters, which
+			// trigger refreshes of UI adapters (e.g. TableModelAdapter) which will prematurely
+			// discover any structural changes... :( )
+			// see ItemAspectListValueModelAdapter.itemAspectChanged(EventObject)
+			for (C contextElement : contextElementsToSync) {
+				if (sync) {
+					contextElement.synchronizeWithResourceModel();
+				} else {
+					contextElement.update();
+				}
+			}
+		}
+	}
+
+
+	/**
+	 * Adapter used to synchronize a <em>collection</em> of context models with the
+	 * corresponding <em>collection</em> of resource models.
+	 * @param <C> the type of context elements
+	 * @param <R> the type of resource elements
+	 */
+	public abstract class ContextCollectionContainer<C extends JpaContextModel, R>
+		extends ContextContainer<C, R>
+	{
+		protected ContextCollectionContainer(String aspectName, Container.Adapter<C, R> adapter) {
+			super(aspectName, adapter);
+		}
+
+		@Override
+		protected C add(int index, C element) {
+			// ignore the index - not a list
+			AbstractJpaContextModel.this.addItemToCollection(element, this.elements, this.aspectName);
+			return element;
+		}
+
+		@Override
+		protected Iterable<C> addAll(int index, Iterable<C> contextElements) {
+			// ignore the index - not a list
+			AbstractJpaContextModel.this.addItemsToCollection(contextElements, this.elements, this.aspectName);
+			return contextElements;
+		}
+
+		@Override
+		public void remove(C element) {
+			AbstractJpaContextModel.this.removeItemFromCollection(element, this.elements, this.aspectName);
+		}
+
+		@Override
+		public void removeAll(Iterable<C> contextElements) {
+			AbstractJpaContextModel.this.removeItemsFromCollection(contextElements, this.elements, this.aspectName);
+		}
+
+		@Override
+		protected void move(int index, C element) {
+			// NOP - not a list
+		}
+	}
+
+	// open up accessibility to container classes
+	@Override
+	protected <E> boolean addItemToCollection(E item, Collection<E> collection, String collectionName) {
+		return super.addItemToCollection(item, collection, collectionName);
+	}
+	@Override
+	protected <E> boolean addItemsToCollection(Iterable<? extends E> items, Collection<E> collection, String collectionName) {
+		return super.addItemsToCollection(items, collection, collectionName);
+	}
+	@Override
+	protected boolean removeItemFromCollection(Object item, Collection<?> collection, String collectionName) {
+		return super.removeItemFromCollection(item, collection, collectionName);
+	}
+	@Override
+	protected boolean removeItemsFromCollection(Iterable<?> items, Collection<?> collection, String collectionName) {
+		return super.removeItemsFromCollection(items, collection, collectionName);
+	}
+
+
+	/**
+	 * Use this container for a collection of <em>specified</em> elements.
+	 * The container is initialized from the resource model upon construction.
+	 * @see AbstractJpaContextModel.SpecifiedContextListContainer
+	 * @see #buildSpecifiedContextCollectionContainer(String, AbstractJpaContextModel.Container.Adapter)
+	 */
+	public class SpecifiedContextCollectionContainer<C extends JpaContextModel, R>
+		extends ContextCollectionContainer<C, R>
+	{
+		public SpecifiedContextCollectionContainer(String aspectName, Container.Adapter<C, R> adapter) {
+			super(aspectName, adapter);
+			this.initialize();
+		}
+	}
+
+	protected <C extends JpaContextModel, R> SpecifiedContextCollectionContainer<C, R> buildSpecifiedContextCollectionContainer(String aspectName, Container.Adapter<C, R> adapter) {
+		return new SpecifiedContextCollectionContainer<C, R>(aspectName, adapter);
+	}
+
+
+	/**
+	 * Use this container for a collection of <em>virtual</em> elements
+	 * (e.g. default elements).
+	 * The container is <em>not</em> initialized from the resource model upon
+	 * construction (i.e. the container will effectively be initialized with the
+	 * first <em>update</em>).
+	 * @see AbstractJpaContextModel.VirtualContextListContainer
+	 * @see #buildVirtualContextCollectionContainer(String, AbstractJpaContextModel.Container.Adapter)
+	 */
+	public class VirtualContextCollectionContainer<C extends JpaContextModel, R>
+		extends ContextCollectionContainer<C, R>
+	{
+		public VirtualContextCollectionContainer(String aspectName, Container.Adapter<C, R> adapter) {
+			super(aspectName, adapter);
+			// NO initialization
+		}
+	}
+
+	protected <C extends JpaContextModel, R> VirtualContextCollectionContainer<C, R> buildVirtualContextCollectionContainer(String aspectName, Container.Adapter<C, R> adapter) {
+		return new VirtualContextCollectionContainer<C, R>(aspectName, adapter);
+	}
+
+
+	/**
+	 * Adapter used to synchronize a <em>list</em> of context models with the
+	 * corresponding <em>list</em> of resource models.
+	 * @param <C> the type of context elements
+	 * @param <R> the type of resource elements
+	 */
+	public abstract class ContextListContainer<C extends JpaContextModel, R>
+		extends ContextContainer<C, R>
+	{
+		protected ContextListContainer(String aspectName, Container.Adapter<C, R> adapter) {
+			super(aspectName, adapter);
+		}
+
+		/**
+		 * Return the index of the specified context element.
+		 */
+		public int indexOf(C element) {
+			return this.elements.indexOf(element);
+		}
+
+		@Override
+		protected C add(int index, C element) {
+			AbstractJpaContextModel.this.addItemToList(index, element, this.elements, this.aspectName);
+			return element;
+		}
+
+		@Override
+		public Iterable<C> addAll(int index, Iterable<C> contextElements) {
+			AbstractJpaContextModel.this.addItemsToList(index, contextElements, this.elements, this.aspectName);
+			return contextElements;
+		}
+
+		/**
+		 * Move the context element at the specified source index to the
+		 * specified target index.
+		 */
+		public void move(int targetIndex, int sourceIndex) {
+			AbstractJpaContextModel.this.moveItemInList(targetIndex, sourceIndex, this.elements, this.aspectName);
+		}
+
+		@Override
+		public void move(int index, C element) {
+			AbstractJpaContextModel.this.moveItemInList(index, element, this.elements, this.aspectName);
+		}
+
+		/**
+		 * Clear the container.
+		 */
+		public void clear() {
+			AbstractJpaContextModel.this.clearList(this.elements, this.aspectName);
+		}
+
+		/**
+		 * Remove the context element at the specified index from the container.
+		 */
+		public C remove(int index) {
+			return AbstractJpaContextModel.this.removeItemFromList(index, this.elements, this.aspectName);
+		}
+
+		@Override
+		public void remove(C element) {
+			AbstractJpaContextModel.this.removeItemFromList(element, this.elements, this.aspectName);
+		}
+
+		@Override
+		public void removeAll(Iterable<C> contextElements) {
+			AbstractJpaContextModel.this.removeItemsFromList(contextElements, this.elements, this.aspectName);
+		}
+	}
+
+	// open up accessibility to container classes
+	@Override
+	protected <E> void addItemToList(int index, E item, List<E> list, String listName) {
+		super.addItemToList(index, item, list, listName);
+	}
+	@Override
+	protected <E> boolean addItemsToList(int index, Iterable<? extends E> items, List<E> list, String listName) {
+		return super.addItemsToList(index, items, list, listName);
+	}
+	@Override
+	protected <E> void moveItemInList(int targetIndex, int sourceIndex, List<E> list, String listName) {
+		super.moveItemInList(targetIndex, sourceIndex, list, listName);
+	}
+	@Override
+	protected <E> void moveItemInList(int targetIndex, E item, List<E> list, String listName) {
+		super.moveItemInList(targetIndex, item, list, listName);
+	}
+	@Override
+	protected boolean clearList(List<?> list, String listName) {
+		return super.clearList(list, listName);
+	}
+	@Override
+	protected <E> E removeItemFromList(int index, List<E> list, String listName) {
+		return super.removeItemFromList(index, list, listName);
+	}
+	@Override
+	protected boolean removeItemFromList(Object item, List<?> list, String listName) {
+		return super.removeItemFromList(item, list, listName);
+	}
+	@Override
+	protected boolean removeItemsFromList(Iterable<?> items, List<?> list, String listName) {
+		return super.removeItemsFromList(items, list, listName);
+	}
+
+
+	/**
+	 * @see AbstractJpaContextModel.SpecifiedContextCollectionContainer
+	 * @see #buildSpecifiedContextListContainer(String, AbstractJpaContextModel.Container.Adapter)
+	 */
+	public class SpecifiedContextListContainer<C extends JpaContextModel, R>
+		extends ContextListContainer<C, R>
+	{
+		public SpecifiedContextListContainer(String aspectName, Container.Adapter<C, R> adapter) {
+			super(aspectName, adapter);
+			this.initialize();
+		}
+	}
+
+	protected <C extends JpaContextModel, R> SpecifiedContextListContainer<C, R> buildSpecifiedContextListContainer(String aspectName, Container.Adapter<C, R> adapter) {
+		return new SpecifiedContextListContainer<C, R>(aspectName, adapter);
+	}
+
+
+	/**
+	 * @see AbstractJpaContextModel.VirtualContextCollectionContainer
+	 * @see #buildVirtualContextListContainer(String, AbstractJpaContextModel.Container.Adapter)
+	 */
+	public class VirtualContextListContainer<C extends JpaContextModel, R>
+		extends ContextListContainer<C, R>
+	{
+		public VirtualContextListContainer(String aspectName, Container.Adapter<C, R> adapter) {
+			super(aspectName, adapter);
+			// NO initialization
+		}
+	}
+
+	protected <C extends JpaContextModel, R> VirtualContextListContainer<C, R> buildVirtualContextListContainer(String aspectName, Container.Adapter<C, R> adapter) {
+		return new VirtualContextListContainer<C, R>(aspectName, adapter);
+	}
+
+
+	/**
+	 * Adapter used to synchronize a <em>list</em> of context values with the
+	 * corresponding list of resource values. The assumption is the values are
+	 * equal in each model (e.g. {@link String}s).
+	 * @param <E> the type of context elements
+	 */
+	public abstract class ValueListContainer<E>
+		extends Container<E, E>
+	{
+		protected ValueListContainer(String aspectName, Container.Adapter<E, E> adapter) {
+			super(aspectName, adapter);
+		}
+
+		/**
+		 * Return the index of the specified context element.
+		 */
+		public int indexOf(E element) {
+			return this.elements.indexOf(element);
+		}
+
+		@Override
+		protected E add(int index, E element) {
+			AbstractJpaContextModel.this.addItemToList(index, element, this.elements, this.aspectName);
+			return element;
+		}
+
+		@Override
+		protected Iterable<E> addAll(int index, Iterable<E> contextElements) {
+			AbstractJpaContextModel.this.addItemsToList(index, contextElements, this.elements, this.aspectName);
+			return contextElements;
+		}
+
+		/**
+		 * Move the context element at the specified source index to the
+		 * specified target index.
+		 */
+		public void move(int targetIndex, int sourceIndex) {
+			AbstractJpaContextModel.this.moveItemInList(targetIndex, sourceIndex, this.elements, this.aspectName);
+		}
+
+		@Override
+		public void move(int index, E element) {
+			AbstractJpaContextModel.this.moveItemInList(index, element, this.elements, this.aspectName);
+		}
+
+		@Override
+		public void remove(E element) {
+			AbstractJpaContextModel.this.removeItemFromList(element, this.elements, this.aspectName);
+		}
+
+		/**
+		 * Remove the context element at the specified index from the container.
+		 */
+		public E remove(int index) {
+			return AbstractJpaContextModel.this.removeItemFromList(index, this.elements, this.aspectName);
+		}
+
+		@Override
+		public void removeAll(Iterable<E> contextElements) {
+			AbstractJpaContextModel.this.removeItemsFromList(contextElements, this.elements, this.aspectName);
+		}
+
+		public void synchronizeWithResourceModel() {
+			int resourceIndex = 0;
+			// TODO we don't look for any moves, just simple adds and removes
+			for (E resourceElement : this.adapter.getResourceElements()) {
+				if (this.size() > resourceIndex) {
+					E contextElement = this.get(resourceIndex);
+					if (ObjectTools.notEquals(this.adapter.extractResourceElement(contextElement), resourceElement)) {
+						this.addContextElement(resourceIndex, resourceElement);
+					}
+				} else {
+					this.addContextElement(resourceIndex, resourceElement);
+				}
+				resourceIndex++;
+			}
+
+			while (resourceIndex < this.size()) {
+				this.remove(resourceIndex++);
+			}
+		}
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaEntity.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaEntity.java
index 8bbcdd8cfb..54f929a647 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaEntity.java
@@ -412,11 +412,11 @@ public abstract class AbstractJavaEntity
 	// ********** specified secondary tables **********
 
 	public ListIterable<JavaSpecifiedSecondaryTable> getSpecifiedSecondaryTables() {
-		return this.specifiedSecondaryTableContainer.getContextElements();
+		return this.specifiedSecondaryTableContainer;
 	}
 
 	public int getSpecifiedSecondaryTablesSize() {
-		return this.specifiedSecondaryTableContainer.getContextElementsSize();
+		return this.specifiedSecondaryTableContainer.size();
 	}
 
 	public JavaSpecifiedSecondaryTable addSpecifiedSecondaryTable() {
@@ -433,17 +433,17 @@ public abstract class AbstractJavaEntity
 	}
 
 	public void removeSpecifiedSecondaryTable(SpecifiedSecondaryTable secondaryTable) {
-		this.removeSpecifiedSecondaryTable(this.specifiedSecondaryTableContainer.indexOfContextElement((JavaSpecifiedSecondaryTable) secondaryTable));
+		this.removeSpecifiedSecondaryTable(this.specifiedSecondaryTableContainer.indexOf((JavaSpecifiedSecondaryTable) secondaryTable));
 	}
 
 	public void removeSpecifiedSecondaryTable(int index) {
 		this.getJavaResourceType().removeAnnotation(index, SecondaryTableAnnotation.ANNOTATION_NAME);
-		this.specifiedSecondaryTableContainer.removeContextElement(index);
+		this.specifiedSecondaryTableContainer.remove(index);
 	}
 
 	public void moveSpecifiedSecondaryTable(int targetIndex, int sourceIndex) {
 		this.getResourceAnnotatedElement().moveAnnotation(targetIndex, sourceIndex, SecondaryTableAnnotation.ANNOTATION_NAME);
-		this.specifiedSecondaryTableContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedSecondaryTableContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected JavaSpecifiedSecondaryTable buildSecondaryTable(SecondaryTableAnnotation secondaryTableAnnotation) {
@@ -467,31 +467,22 @@ public abstract class AbstractJavaEntity
 	}
 
 	protected ContextListContainer<JavaSpecifiedSecondaryTable, SecondaryTableAnnotation> buildSpecifiedSecondaryTableContainer() {
-		SpecifiedSecondaryTableContainer container = new SpecifiedSecondaryTableContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_SECONDARY_TABLES_LIST, new SpecifiedSecondaryTableContainerAdapter());
 	}
 
 	/**
-	 * specified secondary table container
+	 * specified secondary table container adapter
 	 */
-	public class SpecifiedSecondaryTableContainer
-		extends ContextListContainer<JavaSpecifiedSecondaryTable, SecondaryTableAnnotation>
+	public class SpecifiedSecondaryTableContainerAdapter
+		extends AbstractContainerAdapter<JavaSpecifiedSecondaryTable, SecondaryTableAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_SECONDARY_TABLES_LIST;
-		}
-		@Override
-		protected JavaSpecifiedSecondaryTable buildContextElement(SecondaryTableAnnotation resourceElement) {
+		public JavaSpecifiedSecondaryTable buildContextElement(SecondaryTableAnnotation resourceElement) {
 			return AbstractJavaEntity.this.buildSecondaryTable(resourceElement);
 		}
-		@Override
-		protected ListIterable<SecondaryTableAnnotation> getResourceElements() {
+		public ListIterable<SecondaryTableAnnotation> getResourceElements() {
 			return AbstractJavaEntity.this.getSecondaryTableAnnotations();
 		}
-		@Override
-		protected SecondaryTableAnnotation getResourceElement(JavaSpecifiedSecondaryTable contextElement) {
+		public SecondaryTableAnnotation extractResourceElement(JavaSpecifiedSecondaryTable contextElement) {
 			return contextElement.getTableAnnotation();
 		}
 	}
@@ -515,7 +506,7 @@ public abstract class AbstractJavaEntity
 	// ********** specified primary key join columns **********
 
 	public ListIterable<JavaSpecifiedPrimaryKeyJoinColumn> getSpecifiedPrimaryKeyJoinColumns() {
-		return this.specifiedPrimaryKeyJoinColumnContainer.getContextElements();
+		return this.specifiedPrimaryKeyJoinColumnContainer;
 	}
 
 	public SpecifiedPrimaryKeyJoinColumn getSpecifiedPrimaryKeyJoinColumn(int index) {
@@ -523,7 +514,7 @@ public abstract class AbstractJavaEntity
 	}
 
 	public int getSpecifiedPrimaryKeyJoinColumnsSize() {
-		return this.specifiedPrimaryKeyJoinColumnContainer.getContextElementsSize();
+		return this.specifiedPrimaryKeyJoinColumnContainer.size();
 	}
 
 	protected boolean hasSpecifiedPrimaryKeyJoinColumns() {
@@ -544,7 +535,7 @@ public abstract class AbstractJavaEntity
 	}
 
 	public void removeSpecifiedPrimaryKeyJoinColumn(SpecifiedPrimaryKeyJoinColumn joinColumn) {
-		this.removeSpecifiedPrimaryKeyJoinColumn(this.specifiedPrimaryKeyJoinColumnContainer.indexOfContextElement((JavaSpecifiedPrimaryKeyJoinColumn) joinColumn));
+		this.removeSpecifiedPrimaryKeyJoinColumn(this.specifiedPrimaryKeyJoinColumnContainer.indexOf((JavaSpecifiedPrimaryKeyJoinColumn) joinColumn));
 	}
 
 	public void convertDefaultPrimaryKeyJoinColumnsToSpecified() {
@@ -564,17 +555,17 @@ public abstract class AbstractJavaEntity
 		for (int index = this.getSpecifiedPrimaryKeyJoinColumnsSize(); --index >= 0; ) {
 			this.getJavaResourceType().removeAnnotation(index, PrimaryKeyJoinColumnAnnotation.ANNOTATION_NAME);
 		}
-		this.specifiedPrimaryKeyJoinColumnContainer.clearContextList();
+		this.specifiedPrimaryKeyJoinColumnContainer.clear();
 	}
 
 	public void removeSpecifiedPrimaryKeyJoinColumn(int index) {
 		this.getJavaResourceType().removeAnnotation(index, PrimaryKeyJoinColumnAnnotation.ANNOTATION_NAME);
-		this.specifiedPrimaryKeyJoinColumnContainer.removeContextElement(index);
+		this.specifiedPrimaryKeyJoinColumnContainer.remove(index);
 	}
 
 	public void moveSpecifiedPrimaryKeyJoinColumn(int targetIndex, int sourceIndex) {
 		this.getJavaResourceType().moveAnnotation(targetIndex, sourceIndex, PrimaryKeyJoinColumnAnnotation.ANNOTATION_NAME);
-		this.specifiedPrimaryKeyJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedPrimaryKeyJoinColumnContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected void syncSpecifiedPrimaryKeyJoinColumns() {
@@ -602,31 +593,22 @@ public abstract class AbstractJavaEntity
 	}
 
 	protected ContextListContainer<JavaSpecifiedPrimaryKeyJoinColumn, PrimaryKeyJoinColumnAnnotation> buildSpecifiedPrimaryKeyJoinColumnContainer() {
-		SpecifiedPrimaryKeyJoinColumnContainer container = new SpecifiedPrimaryKeyJoinColumnContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST, new SpecifiedPrimaryKeyJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified primary key join column container
+	 * specified primary key join column container adapter
 	 */
-	public class SpecifiedPrimaryKeyJoinColumnContainer
-		extends ContextListContainer<JavaSpecifiedPrimaryKeyJoinColumn, PrimaryKeyJoinColumnAnnotation>
+	public class SpecifiedPrimaryKeyJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<JavaSpecifiedPrimaryKeyJoinColumn, PrimaryKeyJoinColumnAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected JavaSpecifiedPrimaryKeyJoinColumn buildContextElement(PrimaryKeyJoinColumnAnnotation resourceElement) {
+		public JavaSpecifiedPrimaryKeyJoinColumn buildContextElement(PrimaryKeyJoinColumnAnnotation resourceElement) {
 			return AbstractJavaEntity.this.buildSpecifiedPrimaryKeyJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<PrimaryKeyJoinColumnAnnotation> getResourceElements() {
+		public ListIterable<PrimaryKeyJoinColumnAnnotation> getResourceElements() {
 			return AbstractJavaEntity.this.getPrimaryKeyJoinColumnAnnotations();
 		}
-		@Override
-		protected PrimaryKeyJoinColumnAnnotation getResourceElement(JavaSpecifiedPrimaryKeyJoinColumn contextElement) {
+		public PrimaryKeyJoinColumnAnnotation extractResourceElement(JavaSpecifiedPrimaryKeyJoinColumn contextElement) {
 			return contextElement.getColumnAnnotation();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaJoinColumnRelationshipStrategy.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaJoinColumnRelationshipStrategy.java
index c3925eba62..6aecc3871a 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaJoinColumnRelationshipStrategy.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaJoinColumnRelationshipStrategy.java
@@ -10,19 +10,18 @@
 package org.eclipse.jpt.jpa.core.internal.context.java;
 
 import java.util.List;
-
 import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.common.utility.internal.iterable.EmptyIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterable;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
-import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
 import org.eclipse.jpt.jpa.core.context.JoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
+import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
-import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaJoinColumnRelationship;
+import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.resource.java.JoinColumnAnnotation;
 import org.eclipse.jpt.jpa.db.Table;
@@ -76,11 +75,11 @@ public abstract class AbstractJavaJoinColumnRelationshipStrategy<P extends JavaJ
 	// ********** specified join columns **********
 
 	public ListIterable<JavaSpecifiedJoinColumn> getSpecifiedJoinColumns() {
-		return this.specifiedJoinColumnContainer.getContextElements();
+		return this.specifiedJoinColumnContainer;
 	}
 
 	public int getSpecifiedJoinColumnsSize() {
-		return this.specifiedJoinColumnContainer.getContextElementsSize();
+		return this.specifiedJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedJoinColumns() {
@@ -88,7 +87,7 @@ public abstract class AbstractJavaJoinColumnRelationshipStrategy<P extends JavaJ
 	}
 
 	public JavaSpecifiedJoinColumn getSpecifiedJoinColumn(int index) {
-		return this.specifiedJoinColumnContainer.getContextElement(index);
+		return this.specifiedJoinColumnContainer.get(index);
 	}
 
 	public JavaSpecifiedJoinColumn addSpecifiedJoinColumn() {
@@ -101,17 +100,17 @@ public abstract class AbstractJavaJoinColumnRelationshipStrategy<P extends JavaJ
 	}
 
 	public void removeSpecifiedJoinColumn(SpecifiedJoinColumn joinColumn) {
-		this.removeSpecifiedJoinColumn(this.specifiedJoinColumnContainer.indexOfContextElement((JavaSpecifiedJoinColumn) joinColumn));
+		this.removeSpecifiedJoinColumn(this.specifiedJoinColumnContainer.indexOf((JavaSpecifiedJoinColumn) joinColumn));
 	}
 
 	public void removeSpecifiedJoinColumn(int index) {
 		this.removeJoinColumnAnnotation(index);
-		this.specifiedJoinColumnContainer.removeContextElement(index);
+		this.specifiedJoinColumnContainer.remove(index);
 	}
 
 	public void moveSpecifiedJoinColumn(int targetIndex, int sourceIndex) {
 		this.moveJoinColumnAnnotation(targetIndex, sourceIndex);
-		this.specifiedJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedJoinColumnContainer.move(targetIndex, sourceIndex);
 	}
 
 	//default join column will get set in the update
@@ -132,7 +131,7 @@ public abstract class AbstractJavaJoinColumnRelationshipStrategy<P extends JavaJ
 		for (int index = getSpecifiedJoinColumnsSize(); --index >= 0; ) {
 			this.removeJoinColumnAnnotation(index);
 		}
-		this.specifiedJoinColumnContainer.clearContextList();
+		this.specifiedJoinColumnContainer.clear();
 	}
 
 	protected void syncSpecifiedJoinColumns() {
@@ -140,31 +139,22 @@ public abstract class AbstractJavaJoinColumnRelationshipStrategy<P extends JavaJ
 	}
 
 	protected ContextListContainer<JavaSpecifiedJoinColumn, JoinColumnAnnotation> buildSpecifiedJoinColumnContainer() {
-		SpecifiedJoinColumnContainer container = new SpecifiedJoinColumnContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_JOIN_COLUMNS_LIST, new SpecifiedJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified join column container
+	 * specified join column container adapter
 	 */
-	protected class SpecifiedJoinColumnContainer
-		extends ContextListContainer<JavaSpecifiedJoinColumn, JoinColumnAnnotation>
+	public class SpecifiedJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<JavaSpecifiedJoinColumn, JoinColumnAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected JavaSpecifiedJoinColumn buildContextElement(JoinColumnAnnotation resourceElement) {
+		public JavaSpecifiedJoinColumn buildContextElement(JoinColumnAnnotation resourceElement) {
 			return AbstractJavaJoinColumnRelationshipStrategy.this.buildJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<JoinColumnAnnotation> getResourceElements() {
+		public ListIterable<JoinColumnAnnotation> getResourceElements() {
 			return AbstractJavaJoinColumnRelationshipStrategy.this.getJoinColumnAnnotations();
 		}
-		@Override
-		protected JoinColumnAnnotation getResourceElement(JavaSpecifiedJoinColumn contextElement) {
+		public JoinColumnAnnotation extractResourceElement(JavaSpecifiedJoinColumn contextElement) {
 			return (JoinColumnAnnotation) contextElement.getColumnAnnotation();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java
index 794cf3fe88..23c40e3a6c 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java
@@ -701,11 +701,11 @@ public abstract class AbstractJavaMultiRelationshipMapping<A extends Relationshi
 	// ********** specified map key join columns **********
 
 	public ListIterable<JavaSpecifiedJoinColumn> getSpecifiedMapKeyJoinColumns() {
-		return this.specifiedMapKeyJoinColumnContainer.getContextElements();
+		return this.specifiedMapKeyJoinColumnContainer;
 	}
 
 	public int getSpecifiedMapKeyJoinColumnsSize() {
-		return this.specifiedMapKeyJoinColumnContainer.getContextElementsSize();
+		return this.specifiedMapKeyJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedMapKeyJoinColumns() {
@@ -713,7 +713,7 @@ public abstract class AbstractJavaMultiRelationshipMapping<A extends Relationshi
 	}
 
 	public JavaSpecifiedJoinColumn getSpecifiedMapKeyJoinColumn(int index) {
-		return this.specifiedMapKeyJoinColumnContainer.getContextElement(index);
+		return this.specifiedMapKeyJoinColumnContainer.get(index);
 	}
 
 	public JavaSpecifiedJoinColumn addSpecifiedMapKeyJoinColumn() {
@@ -726,17 +726,17 @@ public abstract class AbstractJavaMultiRelationshipMapping<A extends Relationshi
 	}
 
 	public void removeSpecifiedMapKeyJoinColumn(SpecifiedJoinColumn joinColumn) {
-		this.removeSpecifiedMapKeyJoinColumn(this.specifiedMapKeyJoinColumnContainer.indexOfContextElement((JavaSpecifiedJoinColumn) joinColumn));
+		this.removeSpecifiedMapKeyJoinColumn(this.specifiedMapKeyJoinColumnContainer.indexOf((JavaSpecifiedJoinColumn) joinColumn));
 	}
 
 	public void removeSpecifiedMapKeyJoinColumn(int index) {
 		this.removeMapKeyJoinColumnAnnotation(index);
-		this.specifiedMapKeyJoinColumnContainer.removeContextElement(index);
+		this.specifiedMapKeyJoinColumnContainer.remove(index);
 	}
 
 	public void moveSpecifiedMapKeyJoinColumn(int targetIndex, int sourceIndex) {
 		this.moveMapKeyJoinColumnAnnotation(targetIndex, sourceIndex);
-		this.specifiedMapKeyJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedMapKeyJoinColumnContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected void syncSpecifiedMapKeyJoinColumns() {
@@ -744,31 +744,22 @@ public abstract class AbstractJavaMultiRelationshipMapping<A extends Relationshi
 	}
 
 	protected ContextListContainer<JavaSpecifiedJoinColumn, MapKeyJoinColumnAnnotation2_0> buildSpecifiedMapKeyJoinColumnContainer() {
-		SpecifiedMapKeyJoinColumnContainer container = new SpecifiedMapKeyJoinColumnContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_MAP_KEY_JOIN_COLUMNS_LIST, new SpecifiedMapKeyJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified map key join column container
+	 * specified map key join column container adapter
 	 */
-	public class SpecifiedMapKeyJoinColumnContainer
-		extends ContextListContainer<JavaSpecifiedJoinColumn, MapKeyJoinColumnAnnotation2_0>
+	public class SpecifiedMapKeyJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<JavaSpecifiedJoinColumn, MapKeyJoinColumnAnnotation2_0>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_MAP_KEY_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected JavaSpecifiedJoinColumn buildContextElement(MapKeyJoinColumnAnnotation2_0 resourceElement) {
+		public JavaSpecifiedJoinColumn buildContextElement(MapKeyJoinColumnAnnotation2_0 resourceElement) {
 			return AbstractJavaMultiRelationshipMapping.this.buildMapKeyJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<MapKeyJoinColumnAnnotation2_0> getResourceElements() {
+		public ListIterable<MapKeyJoinColumnAnnotation2_0> getResourceElements() {
 			return AbstractJavaMultiRelationshipMapping.this.getMapKeyJoinColumnAnnotations();
 		}
-		@Override
-		protected MapKeyJoinColumnAnnotation2_0 getResourceElement(JavaSpecifiedJoinColumn contextElement) {
+		public MapKeyJoinColumnAnnotation2_0 extractResourceElement(JavaSpecifiedJoinColumn contextElement) {
 			return (MapKeyJoinColumnAnnotation2_0) contextElement.getColumnAnnotation();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaQuery.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaQuery.java
index ca2ae68b22..64838b5591 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaQuery.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaQuery.java
@@ -89,11 +89,11 @@ public abstract class AbstractJavaQuery<P extends JavaQueryContainer, A extends
 	// ********** hints **********
 
 	public ListIterable<JavaQueryHint> getHints() {
-		return this.hintContainer.getContextElements();
+		return this.hintContainer;
 	}
 
 	public int getHintsSize() {
-		return this.hintContainer.getContextElementsSize();
+		return this.hintContainer.size();
 	}
 
 	public JavaQueryHint addHint() {
@@ -106,17 +106,17 @@ public abstract class AbstractJavaQuery<P extends JavaQueryContainer, A extends
 	}
 
 	public void removeHint(QueryHint hint) {
-		this.removeHint(this.hintContainer.indexOfContextElement((JavaQueryHint) hint));
+		this.removeHint(this.hintContainer.indexOf((JavaQueryHint) hint));
 	}
 
 	public void removeHint(int index) {
 		this.queryAnnotation.removeHint(index);
-		this.hintContainer.removeContextElement(index);
+		this.hintContainer.remove(index);
 	}
 
 	public void moveHint(int targetIndex, int sourceIndex) {
 		this.queryAnnotation.moveHint(targetIndex, sourceIndex);
-		this.hintContainer.moveContextElement(targetIndex, sourceIndex);
+		this.hintContainer.move(targetIndex, sourceIndex);
 	}
 
 	public JavaQueryHint getHint(int index) {
@@ -136,31 +136,22 @@ public abstract class AbstractJavaQuery<P extends JavaQueryContainer, A extends
 	}
 
 	protected ContextListContainer<JavaQueryHint, QueryHintAnnotation> buildHintContainer() {
-		HintContainer container = new HintContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(HINTS_LIST, new HintContainerAdapter());
 	}
 
 	/**
-	 * query hint container
+	 * hint container adapter
 	 */
-	protected class HintContainer
-		extends ContextListContainer<JavaQueryHint, QueryHintAnnotation>
+	public class HintContainerAdapter
+		extends AbstractContainerAdapter<JavaQueryHint, QueryHintAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return HINTS_LIST;
-		}
-		@Override
-		protected JavaQueryHint buildContextElement(QueryHintAnnotation resourceElement) {
+		public JavaQueryHint buildContextElement(QueryHintAnnotation resourceElement) {
 			return AbstractJavaQuery.this.buildHint(resourceElement);
 		}
-		@Override
-		protected ListIterable<QueryHintAnnotation> getResourceElements() {
+		public ListIterable<QueryHintAnnotation> getResourceElements() {
 			return AbstractJavaQuery.this.getHintAnnotations();
 		}
-		@Override
-		protected QueryHintAnnotation getResourceElement(JavaQueryHint contextElement) {
+		public QueryHintAnnotation extractResourceElement(JavaQueryHint contextElement) {
 			return contextElement.getQueryHintAnnotation();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaTable.java
index eaabe4295d..26faab7840 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaTable.java
@@ -17,9 +17,9 @@ import org.eclipse.jpt.common.utility.internal.iterable.EmptyIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.TransformationIterable;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
 import org.eclipse.jpt.jpa.core.context.JpaContextModel;
+import org.eclipse.jpt.jpa.core.context.SpecifiedUniqueConstraint;
 import org.eclipse.jpt.jpa.core.context.Table;
 import org.eclipse.jpt.jpa.core.context.UniqueConstraint;
-import org.eclipse.jpt.jpa.core.context.SpecifiedUniqueConstraint;
 import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedTable;
 import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedUniqueConstraint;
 import org.eclipse.jpt.jpa.core.internal.context.JpaValidator;
@@ -254,15 +254,15 @@ public abstract class AbstractJavaTable<P extends JpaContextModel, PA extends Ta
 
 	// ********** unique constraints **********
 	public ListIterable<JavaSpecifiedUniqueConstraint> getUniqueConstraints() {
-		return this.uniqueConstraintContainer.getContextElements();
+		return this.uniqueConstraintContainer;
 	}
 
 	public int getUniqueConstraintsSize() {
-		return this.uniqueConstraintContainer.getContextElementsSize();
+		return this.uniqueConstraintContainer.size();
 	}
 
 	public JavaSpecifiedUniqueConstraint getUniqueConstraint(int index) {
-		return this.uniqueConstraintContainer.getContextElement(index);
+		return this.uniqueConstraintContainer.get(index);
 	}
 
 	public JavaSpecifiedUniqueConstraint addUniqueConstraint() {
@@ -276,16 +276,16 @@ public abstract class AbstractJavaTable<P extends JpaContextModel, PA extends Ta
 
 	public void removeUniqueConstraint(int index) {
 		this.getTableAnnotation().removeUniqueConstraint(index);
-		this.uniqueConstraintContainer.removeContextElement(index);
+		this.uniqueConstraintContainer.remove(index);
 	}
 
 	public void removeUniqueConstraint(SpecifiedUniqueConstraint uniqueConstraint) {
-		this.removeUniqueConstraint(this.uniqueConstraintContainer.indexOfContextElement((JavaSpecifiedUniqueConstraint) uniqueConstraint));
+		this.removeUniqueConstraint(this.uniqueConstraintContainer.indexOf((JavaSpecifiedUniqueConstraint) uniqueConstraint));
 	}
 
 	public void moveUniqueConstraint(int targetIndex, int sourceIndex) {
 		this.getTableAnnotation().moveUniqueConstraint(targetIndex, sourceIndex);
-		this.uniqueConstraintContainer.moveContextElement(targetIndex, sourceIndex);
+		this.uniqueConstraintContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected void syncUniqueConstraints() {
@@ -301,31 +301,22 @@ public abstract class AbstractJavaTable<P extends JpaContextModel, PA extends Ta
 	}
 
 	protected ContextListContainer<JavaSpecifiedUniqueConstraint, UniqueConstraintAnnotation> buildUniqueConstraintContainer() {
-		UniqueConstraintContainer container = new UniqueConstraintContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(UNIQUE_CONSTRAINTS_LIST, new UniqueConstraintContainerAdapter());
 	}
 
 	/**
-	 * unique constraint container
+	 * unique constraint container adapter
 	 */
-	protected class UniqueConstraintContainer
-		extends ContextListContainer<JavaSpecifiedUniqueConstraint, UniqueConstraintAnnotation>
+	public class UniqueConstraintContainerAdapter
+		extends AbstractContainerAdapter<JavaSpecifiedUniqueConstraint, UniqueConstraintAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return UNIQUE_CONSTRAINTS_LIST;
-		}
-		@Override
-		protected JavaSpecifiedUniqueConstraint buildContextElement(UniqueConstraintAnnotation resourceElement) {
+		public JavaSpecifiedUniqueConstraint buildContextElement(UniqueConstraintAnnotation resourceElement) {
 			return AbstractJavaTable.this.buildUniqueConstraint(resourceElement);
 		}
-		@Override
-		protected ListIterable<UniqueConstraintAnnotation> getResourceElements() {
+		public ListIterable<UniqueConstraintAnnotation> getResourceElements() {
 			return AbstractJavaTable.this.getUniqueConstraintAnnotations();
 		}
-		@Override
-		protected UniqueConstraintAnnotation getResourceElement(JavaSpecifiedUniqueConstraint contextElement) {
+		public UniqueConstraintAnnotation extractResourceElement(JavaSpecifiedUniqueConstraint contextElement) {
 			return contextElement.getUniqueConstraintAnnotation();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaVirtualReferenceTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaVirtualReferenceTable.java
index 2ea8f43485..4dcbaf430d 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaVirtualReferenceTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaVirtualReferenceTable.java
@@ -14,10 +14,10 @@ import org.eclipse.jpt.common.utility.internal.iterable.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.SuperListIterableWrapper;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
-import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
-import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
+import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.ReferenceTable;
+import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.Table;
 import org.eclipse.jpt.jpa.core.context.VirtualJoinColumn;
 import org.eclipse.jpt.jpa.core.context.VirtualReferenceTable;
@@ -65,11 +65,11 @@ public abstract class AbstractJavaVirtualReferenceTable<P extends JpaContextMode
 	// ********** specified join columns **********
 
 	public ListIterable<VirtualJoinColumn> getSpecifiedJoinColumns() {
-		return this.specifiedJoinColumnContainer.getContextElements();
+		return this.specifiedJoinColumnContainer;
 	}
 
 	public int getSpecifiedJoinColumnsSize() {
-		return this.specifiedJoinColumnContainer.getContextElementsSize();
+		return this.specifiedJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedJoinColumns() {
@@ -77,7 +77,7 @@ public abstract class AbstractJavaVirtualReferenceTable<P extends JpaContextMode
 	}
 
 	public VirtualJoinColumn getSpecifiedJoinColumn(int index) {
-		return this.specifiedJoinColumnContainer.getContextElement(index);
+		return this.specifiedJoinColumnContainer.get(index);
 	}
 
 	protected void updateSpecifiedJoinColumns() {
@@ -89,7 +89,7 @@ public abstract class AbstractJavaVirtualReferenceTable<P extends JpaContextMode
 	}
 
 	protected void moveSpecifiedJoinColumn(int index, VirtualJoinColumn joinColumn) {
-		this.specifiedJoinColumnContainer.moveContextElement(index, joinColumn);
+		this.specifiedJoinColumnContainer.move(index, joinColumn);
 	}
 
 	protected VirtualJoinColumn addSpecifiedJoinColumn(int index, SpecifiedJoinColumn joinColumn) {
@@ -97,33 +97,26 @@ public abstract class AbstractJavaVirtualReferenceTable<P extends JpaContextMode
 	}
 
 	protected void removeSpecifiedJoinColumn(VirtualJoinColumn joinColumn) {
-		this.specifiedJoinColumnContainer.removeContextElement(joinColumn);
+		this.specifiedJoinColumnContainer.remove(joinColumn);
 	}
 
 	protected ContextListContainer<VirtualJoinColumn, JoinColumn> buildSpecifiedJoinColumnContainer() {
-		return new SpecifiedJoinColumnContainer();
+		return this.buildVirtualContextListContainer(SPECIFIED_JOIN_COLUMNS_LIST, new SpecifiedJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified join column container
+	 * specified join column container adapter
 	 */
-	protected class SpecifiedJoinColumnContainer
-		extends ContextListContainer<VirtualJoinColumn, JoinColumn>
+	public class SpecifiedJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<VirtualJoinColumn, JoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected VirtualJoinColumn buildContextElement(JoinColumn resourceElement) {
+		public VirtualJoinColumn buildContextElement(JoinColumn resourceElement) {
 			return AbstractJavaVirtualReferenceTable.this.buildJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<JoinColumn> getResourceElements() {
+		public ListIterable<JoinColumn> getResourceElements() {
 			return AbstractJavaVirtualReferenceTable.this.getOverriddenJoinColumns();
 		}
-		@Override
-		protected JoinColumn getResourceElement(VirtualJoinColumn contextElement) {
+		public JoinColumn extractResourceElement(VirtualJoinColumn contextElement) {
 			return contextElement.getOverriddenColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaVirtualTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaVirtualTable.java
index 1e482e130a..705adaab50 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaVirtualTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/AbstractJavaVirtualTable.java
@@ -185,15 +185,15 @@ public abstract class AbstractJavaVirtualTable<P extends JpaContextModel, PA ext
 	// ********** unique constraints **********
 
 	public ListIterable<VirtualUniqueConstraint> getUniqueConstraints() {
-		return this.uniqueConstraintContainer.getContextElements();
+		return this.uniqueConstraintContainer;
 	}
 
 	public int getUniqueConstraintsSize() {
-		return this.uniqueConstraintContainer.getContextElementsSize();
+		return this.uniqueConstraintContainer.size();
 	}
 
 	public VirtualUniqueConstraint getUniqueConstraint(int index) {
-		return this.uniqueConstraintContainer.getContextElement(index);
+		return this.uniqueConstraintContainer.get(index);
 	}
 
 	protected void updateUniqueConstraints() {
@@ -205,7 +205,7 @@ public abstract class AbstractJavaVirtualTable<P extends JpaContextModel, PA ext
 	}
 
 	protected void moveUniqueConstraint(int index, VirtualUniqueConstraint constraint) {
-		this.uniqueConstraintContainer.moveContextElement(index, constraint);
+		this.uniqueConstraintContainer.move(index, constraint);
 	}
 
 	protected VirtualUniqueConstraint addUniqueConstraint(int index, UniqueConstraint uniqueConstraint) {
@@ -217,33 +217,26 @@ public abstract class AbstractJavaVirtualTable<P extends JpaContextModel, PA ext
 	}
 
 	protected void removeUniqueConstraint(VirtualUniqueConstraint constraint) {
-		this.uniqueConstraintContainer.removeContextElement(constraint);
+		this.uniqueConstraintContainer.remove(constraint);
 	}
 
 	protected ContextListContainer<VirtualUniqueConstraint, UniqueConstraint> buildUniqueConstraintContainer() {
-		return new UniqueConstraintContainer();
+		return this.buildVirtualContextListContainer(UNIQUE_CONSTRAINTS_LIST, new UniqueConstraintContainerAdapter());
 	}
 
 	/**
-	 * unique constraint container
+	 * unique constraint container adapter
 	 */
-	protected class UniqueConstraintContainer
-		extends ContextListContainer<VirtualUniqueConstraint, UniqueConstraint>
+	public class UniqueConstraintContainerAdapter
+		extends AbstractContainerAdapter<VirtualUniqueConstraint, UniqueConstraint>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return UNIQUE_CONSTRAINTS_LIST;
-		}
-		@Override
-		protected VirtualUniqueConstraint buildContextElement(UniqueConstraint resourceElement) {
+		public VirtualUniqueConstraint buildContextElement(UniqueConstraint resourceElement) {
 			return AbstractJavaVirtualTable.this.buildUniqueConstraint(resourceElement);
 		}
-		@Override
-		protected ListIterable<UniqueConstraint> getResourceElements() {
+		public ListIterable<UniqueConstraint> getResourceElements() {
 			return AbstractJavaVirtualTable.this.getOverriddenUniqueConstraints();
 		}
-		@Override
-		protected UniqueConstraint getResourceElement(VirtualUniqueConstraint contextElement) {
+		public UniqueConstraint extractResourceElement(VirtualUniqueConstraint contextElement) {
 			return contextElement.getOverriddenUniqueConstraint();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/GenericJavaPrimaryKeyJoinColumnRelationshipStrategy.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/GenericJavaPrimaryKeyJoinColumnRelationshipStrategy.java
index e63946be15..9324f5ea83 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/GenericJavaPrimaryKeyJoinColumnRelationshipStrategy.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/GenericJavaPrimaryKeyJoinColumnRelationshipStrategy.java
@@ -15,23 +15,23 @@ import org.eclipse.jpt.common.core.resource.java.NestableAnnotation;
 import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.common.utility.internal.iterable.SubListIterableWrapper;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
-import org.eclipse.jpt.jpa.core.context.Entity;
-import org.eclipse.jpt.jpa.core.context.JpaContextModel;
-import org.eclipse.jpt.jpa.core.context.SpecifiedPersistentAttribute;
-import org.eclipse.jpt.jpa.core.context.SpecifiedPrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.BaseJoinColumn;
+import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
+import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.NamedColumn;
 import org.eclipse.jpt.jpa.core.context.RelationshipStrategy;
+import org.eclipse.jpt.jpa.core.context.SpecifiedPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.SpecifiedPrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
-import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedPrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaPrimaryKeyJoinColumnRelationship;
-import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedPrimaryKeyJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.java.JavaRelationshipMapping;
+import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedPrimaryKeyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedPrimaryKeyJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.internal.context.JpaValidator;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.OneToOnePrimaryKeyJoinColumnValidator;
-import org.eclipse.jpt.jpa.core.jpa2.context.SpecifiedMappingRelationshipStrategy2_0;
 import org.eclipse.jpt.jpa.core.jpa2.context.OverrideRelationship2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.SpecifiedMappingRelationshipStrategy2_0;
 import org.eclipse.jpt.jpa.core.resource.java.PrimaryKeyJoinColumnAnnotation;
 import org.eclipse.jpt.jpa.core.validation.JptJpaCoreValidationArgumentMessages;
 import org.eclipse.jpt.jpa.db.Table;
@@ -71,11 +71,11 @@ public class GenericJavaPrimaryKeyJoinColumnRelationshipStrategy
 	// ********** primary key join columns **********
 
 	public ListIterable<JavaSpecifiedPrimaryKeyJoinColumn> getPrimaryKeyJoinColumns() {
-		return this.primaryKeyJoinColumnContainer.getContextElements();
+		return this.primaryKeyJoinColumnContainer;
 	}
 
 	public int getPrimaryKeyJoinColumnsSize() {
-		return this.primaryKeyJoinColumnContainer.getContextElementsSize();
+		return this.primaryKeyJoinColumnContainer.size();
 	}
 
 	public boolean hasPrimaryKeyJoinColumns() {
@@ -83,7 +83,7 @@ public class GenericJavaPrimaryKeyJoinColumnRelationshipStrategy
 	}
 
 	public JavaSpecifiedPrimaryKeyJoinColumn getPrimaryKeyJoinColumn(int index) {
-		return this.primaryKeyJoinColumnContainer.getContextElement(index);
+		return this.primaryKeyJoinColumnContainer.get(index);
 	}
 
 	public JavaSpecifiedPrimaryKeyJoinColumn addPrimaryKeyJoinColumn() {
@@ -96,17 +96,17 @@ public class GenericJavaPrimaryKeyJoinColumnRelationshipStrategy
 	}
 
 	public void removePrimaryKeyJoinColumn(SpecifiedPrimaryKeyJoinColumn joinColumn) {
-		this.removePrimaryKeyJoinColumn(this.primaryKeyJoinColumnContainer.indexOfContextElement((JavaSpecifiedPrimaryKeyJoinColumn) joinColumn));
+		this.removePrimaryKeyJoinColumn(this.primaryKeyJoinColumnContainer.indexOf((JavaSpecifiedPrimaryKeyJoinColumn) joinColumn));
 	}
 
 	public void removePrimaryKeyJoinColumn(int index) {
 		this.removePrimaryKeyJoinColumnAnnotation(index);
-		this.primaryKeyJoinColumnContainer.removeContextElement(index);
+		this.primaryKeyJoinColumnContainer.remove(index);
 	}
 
 	public void movePrimaryKeyJoinColumn(int targetIndex, int sourceIndex) {
 		this.movePrimaryKeyJoinColumnAnnotation(targetIndex, sourceIndex);
-		this.primaryKeyJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.primaryKeyJoinColumnContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected void syncPrimaryKeyJoinColumns() {
@@ -114,31 +114,22 @@ public class GenericJavaPrimaryKeyJoinColumnRelationshipStrategy
 	}
 
 	protected ContextListContainer<JavaSpecifiedPrimaryKeyJoinColumn, PrimaryKeyJoinColumnAnnotation> buildPrimaryKeyJoinColumnContainer() {
-		PrimaryKeyJoinColumnContainer container = new PrimaryKeyJoinColumnContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(PRIMARY_KEY_JOIN_COLUMNS_LIST, new PrimaryKeyJoinColumnContainerAdapter());
 	}
 
 	/**
-	 *  primary key join column container
+	 * primary key join column container adapter
 	 */
-	protected class PrimaryKeyJoinColumnContainer
-		extends ContextListContainer<JavaSpecifiedPrimaryKeyJoinColumn, PrimaryKeyJoinColumnAnnotation>
+	public class PrimaryKeyJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<JavaSpecifiedPrimaryKeyJoinColumn, PrimaryKeyJoinColumnAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return PRIMARY_KEY_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected JavaSpecifiedPrimaryKeyJoinColumn buildContextElement(PrimaryKeyJoinColumnAnnotation resourceElement) {
+		public JavaSpecifiedPrimaryKeyJoinColumn buildContextElement(PrimaryKeyJoinColumnAnnotation resourceElement) {
 			return GenericJavaPrimaryKeyJoinColumnRelationshipStrategy.this.buildPrimaryKeyJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<PrimaryKeyJoinColumnAnnotation> getResourceElements() {
+		public ListIterable<PrimaryKeyJoinColumnAnnotation> getResourceElements() {
 			return GenericJavaPrimaryKeyJoinColumnRelationshipStrategy.this.getPrimaryKeyJoinColumnAnnotations();
 		}
-		@Override
-		protected PrimaryKeyJoinColumnAnnotation getResourceElement(JavaSpecifiedPrimaryKeyJoinColumn contextElement) {
+		public PrimaryKeyJoinColumnAnnotation extractResourceElement(JavaSpecifiedPrimaryKeyJoinColumn contextElement) {
 			return contextElement.getColumnAnnotation();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/GenericJavaVirtualJoinTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/GenericJavaVirtualJoinTable.java
index 07104343a9..f91d2ff1db 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/GenericJavaVirtualJoinTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/java/GenericJavaVirtualJoinTable.java
@@ -79,11 +79,11 @@ public class GenericJavaVirtualJoinTable
 	// ********** inverse specified join columns **********
 
 	public ListIterable<VirtualJoinColumn> getSpecifiedInverseJoinColumns() {
-		return this.specifiedInverseJoinColumnContainer.getContextElements();
+		return this.specifiedInverseJoinColumnContainer;
 	}
 
 	public int getSpecifiedInverseJoinColumnsSize() {
-		return this.specifiedInverseJoinColumnContainer.getContextElementsSize();
+		return this.specifiedInverseJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedInverseJoinColumns() {
@@ -91,7 +91,7 @@ public class GenericJavaVirtualJoinTable
 	}
 
 	public VirtualJoinColumn getSpecifiedInverseJoinColumn(int index) {
-		return this.specifiedInverseJoinColumnContainer.getContextElement(index);
+		return this.specifiedInverseJoinColumnContainer.get(index);
 	}
 
 	protected void updateSpecifiedInverseJoinColumns() {
@@ -103,7 +103,7 @@ public class GenericJavaVirtualJoinTable
 	}
 
 	protected void moveSpecifiedInverseJoinColumn(int index, VirtualJoinColumn joinColumn) {
-		this.specifiedInverseJoinColumnContainer.moveContextElement(index, joinColumn);
+		this.specifiedInverseJoinColumnContainer.move(index, joinColumn);
 	}
 
 	protected VirtualJoinColumn addSpecifiedInverseJoinColumn(int index, JoinColumn joinColumn) {
@@ -111,33 +111,26 @@ public class GenericJavaVirtualJoinTable
 	}
 
 	protected void removeSpecifiedInverseJoinColumn(VirtualJoinColumn joinColumn) {
-		this.specifiedInverseJoinColumnContainer.removeContextElement(joinColumn);
+		this.specifiedInverseJoinColumnContainer.remove(joinColumn);
 	}
 
 	protected ContextListContainer<VirtualJoinColumn, JoinColumn> buildSpecifiedInverseJoinColumnContainer() {
-		return new SpecifiedInverseJoinColumnContainer();
+		return this.buildVirtualContextListContainer(SPECIFIED_INVERSE_JOIN_COLUMNS_LIST, new SpecifiedInverseJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified join column container
+	 * specified inverse join column container adapter
 	 */
-	public class SpecifiedInverseJoinColumnContainer
-		extends ContextListContainer<VirtualJoinColumn, JoinColumn>
+	public class SpecifiedInverseJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<VirtualJoinColumn, JoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_INVERSE_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected VirtualJoinColumn buildContextElement(JoinColumn resourceElement) {
+		public VirtualJoinColumn buildContextElement(JoinColumn resourceElement) {
 			return GenericJavaVirtualJoinTable.this.buildInverseJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<JoinColumn> getResourceElements() {
+		public ListIterable<JoinColumn> getResourceElements() {
 			return GenericJavaVirtualJoinTable.this.getOverriddenInverseJoinColumns();
 		}
-		@Override
-		protected JoinColumn getResourceElement(VirtualJoinColumn contextElement) {
+		public JoinColumn extractResourceElement(VirtualJoinColumn contextElement) {
 			return contextElement.getOverriddenColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractEntityMappings.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractEntityMappings.java
index 038cad1d94..3b2942113c 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractEntityMappings.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractEntityMappings.java
@@ -947,11 +947,11 @@ public abstract class AbstractEntityMappings
 	// ********** sequence generators **********
 
 	public ListIterable<OrmSequenceGenerator> getSequenceGenerators() {
-		return this.sequenceGeneratorContainer.getContextElements();
+		return this.sequenceGeneratorContainer;
 	}
 
 	public int getSequenceGeneratorsSize() {
-		return this.sequenceGeneratorContainer.getContextElementsSize();
+		return this.sequenceGeneratorContainer.size();
 	}
 
 	public OrmSequenceGenerator addSequenceGenerator() {
@@ -974,16 +974,16 @@ public abstract class AbstractEntityMappings
 	}
 
 	public void removeSequenceGenerator(OrmSequenceGenerator sequenceGenerator) {
-		this.removeSequenceGenerator(this.sequenceGeneratorContainer.indexOfContextElement(sequenceGenerator));
+		this.removeSequenceGenerator(this.sequenceGeneratorContainer.indexOf(sequenceGenerator));
 	}
 
 	public void removeSequenceGenerator(int index) {
-		this.sequenceGeneratorContainer.removeContextElement(index);
+		this.sequenceGeneratorContainer.remove(index);
 		this.xmlEntityMappings.getSequenceGenerators().remove(index);
 	}
 
 	public void moveSequenceGenerator(int targetIndex, int sourceIndex) {
-		this.sequenceGeneratorContainer.moveContextElement(targetIndex, sourceIndex);
+		this.sequenceGeneratorContainer.move(targetIndex, sourceIndex);
 		this.xmlEntityMappings.getSequenceGenerators().move(targetIndex, sourceIndex);
 	}
 
@@ -997,31 +997,22 @@ public abstract class AbstractEntityMappings
 	}
 
 	protected ContextListContainer<OrmSequenceGenerator, XmlSequenceGenerator> buildSequenceGeneratorContainer() {
-		SequenceGeneratorContainer container = new SequenceGeneratorContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SEQUENCE_GENERATORS_LIST, new SequenceGeneratorContainerAdapter());
 	}
 
 	/**
-	 * sequence generator container
+	 * sequence generator container adapter
 	 */
-	protected class SequenceGeneratorContainer
-		extends ContextListContainer<OrmSequenceGenerator, XmlSequenceGenerator>
+	public class SequenceGeneratorContainerAdapter
+		extends AbstractContainerAdapter<OrmSequenceGenerator, XmlSequenceGenerator>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SEQUENCE_GENERATORS_LIST;
-		}
-		@Override
-		protected OrmSequenceGenerator buildContextElement(XmlSequenceGenerator resourceElement) {
+		public OrmSequenceGenerator buildContextElement(XmlSequenceGenerator resourceElement) {
 			return AbstractEntityMappings.this.buildSequenceGenerator(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlSequenceGenerator> getResourceElements() {
+		public ListIterable<XmlSequenceGenerator> getResourceElements() {
 			return AbstractEntityMappings.this.getXmlSequenceGenerators();
 		}
-		@Override
-		protected XmlSequenceGenerator getResourceElement(OrmSequenceGenerator contextElement) {
+		public XmlSequenceGenerator extractResourceElement(OrmSequenceGenerator contextElement) {
 			return contextElement.getXmlGenerator();
 		}
 	}
@@ -1030,11 +1021,11 @@ public abstract class AbstractEntityMappings
 	// ********** table generators **********
 
 	public ListIterable<OrmTableGenerator> getTableGenerators() {
-		return this.tableGeneratorContainer.getContextElements();
+		return this.tableGeneratorContainer;
 	}
 
 	public int getTableGeneratorsSize() {
-		return this.tableGeneratorContainer.getContextElementsSize();
+		return this.tableGeneratorContainer.size();
 	}
 
 	public OrmTableGenerator addTableGenerator() {
@@ -1057,16 +1048,16 @@ public abstract class AbstractEntityMappings
 	}
 
 	public void removeTableGenerator(OrmTableGenerator tableGenerator) {
-		this.removeTableGenerator(this.tableGeneratorContainer.indexOfContextElement(tableGenerator));
+		this.removeTableGenerator(this.tableGeneratorContainer.indexOf(tableGenerator));
 	}
 
 	public void removeTableGenerator(int index) {
-		this.tableGeneratorContainer.removeContextElement(index);
+		this.tableGeneratorContainer.remove(index);
 		this.xmlEntityMappings.getTableGenerators().remove(index);
 	}
 
 	public void moveTableGenerator(int targetIndex, int sourceIndex) {
-		this.tableGeneratorContainer.moveContextElement(targetIndex, sourceIndex);
+		this.tableGeneratorContainer.move(targetIndex, sourceIndex);
 		this.xmlEntityMappings.getTableGenerators().move(targetIndex, sourceIndex);
 	}
 
@@ -1080,31 +1071,22 @@ public abstract class AbstractEntityMappings
 	}
 
 	protected ContextListContainer<OrmTableGenerator, XmlTableGenerator> buildTableGeneratorContainer() {
-		TableGeneratorContainer container = new TableGeneratorContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(TABLE_GENERATORS_LIST, new TableGeneratorContainerAdapter());
 	}
 
 	/**
-	 * table generator container
+	 * table generator container adapter
 	 */
-	protected class TableGeneratorContainer
-		extends ContextListContainer<OrmTableGenerator, XmlTableGenerator>
+	public class TableGeneratorContainerAdapter
+		extends AbstractContainerAdapter<OrmTableGenerator, XmlTableGenerator>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return TABLE_GENERATORS_LIST;
-		}
-		@Override
-		protected OrmTableGenerator buildContextElement(XmlTableGenerator resourceElement) {
+		public OrmTableGenerator buildContextElement(XmlTableGenerator resourceElement) {
 			return AbstractEntityMappings.this.buildTableGenerator(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlTableGenerator> getResourceElements() {
+		public ListIterable<XmlTableGenerator> getResourceElements() {
 			return AbstractEntityMappings.this.getXmlTableGenerators();
 		}
-		@Override
-		protected XmlTableGenerator getResourceElement(OrmTableGenerator contextElement) {
+		public XmlTableGenerator extractResourceElement(OrmTableGenerator contextElement) {
 			return contextElement.getXmlGenerator();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmEntity.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmEntity.java
index 7baf5e42f7..78b146a829 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmEntity.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmEntity.java
@@ -500,7 +500,7 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	// ********** specified secondary tables **********
 
 	public ListIterable<OrmSpecifiedSecondaryTable> getSpecifiedSecondaryTables() {
-		return this.specifiedSecondaryTableContainer.getContextElements();
+		return this.specifiedSecondaryTableContainer;
 	}
 
 	protected ListIterable<SecondaryTable> getReadOnlySpecifiedSecondaryTables() {
@@ -508,7 +508,7 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	}
 
 	public int getSpecifiedSecondaryTablesSize() {
-		return this.specifiedSecondaryTableContainer.getContextElementsSize();
+		return this.specifiedSecondaryTableContainer.size();
 	}
 
 	public OrmSpecifiedSecondaryTable addSpecifiedSecondaryTable() {
@@ -547,16 +547,16 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	}
 
 	public void removeSpecifiedSecondaryTable(SpecifiedSecondaryTable secondaryTable) {
-		this.removeSpecifiedSecondaryTable(this.specifiedSecondaryTableContainer.indexOfContextElement((OrmSpecifiedSecondaryTable) secondaryTable));
+		this.removeSpecifiedSecondaryTable(this.specifiedSecondaryTableContainer.indexOf((OrmSpecifiedSecondaryTable) secondaryTable));
 	}
 
 	public void removeSpecifiedSecondaryTable(int index) {
-		this.specifiedSecondaryTableContainer.removeContextElement(index);
+		this.specifiedSecondaryTableContainer.remove(index);
 		this.xmlTypeMapping.getSecondaryTables().remove(index);
 	}
 
 	public void moveSpecifiedSecondaryTable(int targetIndex, int sourceIndex) {
-		this.specifiedSecondaryTableContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedSecondaryTableContainer.move(targetIndex, sourceIndex);
 		this.xmlTypeMapping.getSecondaryTables().move(targetIndex, sourceIndex);
 	}
 
@@ -565,7 +565,7 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	}
 
 	protected void clearSpecifiedSecondaryTables() {
-		this.specifiedSecondaryTableContainer.clearContextList();
+		this.specifiedSecondaryTableContainer.clear();
 		this.xmlTypeMapping.getSecondaryTables().clear();
 	}
 
@@ -579,31 +579,22 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	}
 
 	protected ContextListContainer<OrmSpecifiedSecondaryTable, XmlSecondaryTable> buildSpecifiedSecondaryTableContainer() {
-		SpecifiedSecondaryTableContainer container = new SpecifiedSecondaryTableContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_SECONDARY_TABLES_LIST, new SpecifiedSecondaryTableContainerAdapter());
 	}
 
 	/**
-	 * specified secondary table container
+	 * specified secondary table container adapter
 	 */
-	public class SpecifiedSecondaryTableContainer
-		extends ContextListContainer<OrmSpecifiedSecondaryTable, XmlSecondaryTable>
+	public class SpecifiedSecondaryTableContainerAdapter
+		extends AbstractContainerAdapter<OrmSpecifiedSecondaryTable, XmlSecondaryTable>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_SECONDARY_TABLES_LIST;
-		}
-		@Override
-		protected OrmSpecifiedSecondaryTable buildContextElement(XmlSecondaryTable resourceElement) {
+		public OrmSpecifiedSecondaryTable buildContextElement(XmlSecondaryTable resourceElement) {
 			return AbstractOrmEntity.this.buildSpecifiedSecondaryTable(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlSecondaryTable> getResourceElements() {
+		public ListIterable<XmlSecondaryTable> getResourceElements() {
 			return AbstractOrmEntity.this.getXmlSecondaryTables();
 		}
-		@Override
-		protected XmlSecondaryTable getResourceElement(OrmSpecifiedSecondaryTable contextElement) {
+		public XmlSecondaryTable extractResourceElement(OrmSpecifiedSecondaryTable contextElement) {
 			return contextElement.getXmlTable();
 		}
 	}
@@ -612,7 +603,7 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	// ********** virtual secondary tables **********
 
 	public ListIterable<OrmVirtualSecondaryTable> getVirtualSecondaryTables() {
-		return this.virtualSecondaryTableContainer.getContextElements();
+		return this.virtualSecondaryTableContainer;
 	}
 
 	protected ListIterable<SecondaryTable> getReadOnlyVirtualSecondaryTables() {
@@ -620,11 +611,11 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	}
 
 	public int getVirtualSecondaryTablesSize() {
-		return this.virtualSecondaryTableContainer.getContextElementsSize();
+		return this.virtualSecondaryTableContainer.size();
 	}
 
 	protected void clearVirtualSecondaryTables() {
-		this.virtualSecondaryTableContainer.clearContextList();
+		this.virtualSecondaryTableContainer.clear();
 	}
 
 	/**
@@ -649,7 +640,7 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	}
 
 	protected void moveVirtualSecondaryTable(int index, OrmVirtualSecondaryTable secondaryTable) {
-		this.virtualSecondaryTableContainer.moveContextElement(index, secondaryTable);
+		this.virtualSecondaryTableContainer.move(index, secondaryTable);
 	}
 
 	protected OrmVirtualSecondaryTable addVirtualSecondaryTable(int index, JavaSpecifiedSecondaryTable javaSecondaryTable) {
@@ -661,33 +652,26 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	}
 
 	protected void removeVirtualSecondaryTable(OrmVirtualSecondaryTable secondaryTable) {
-		this.virtualSecondaryTableContainer.removeContextElement(secondaryTable);
+		this.virtualSecondaryTableContainer.remove(secondaryTable);
 	}
 
 	protected ContextListContainer<OrmVirtualSecondaryTable, JavaSpecifiedSecondaryTable> buildVirtualSecondaryTableContainer() {
-		return new VirtualSecondaryTableContainer();
+		return this.buildVirtualContextListContainer(VIRTUAL_SECONDARY_TABLES_LIST, new VirtualSecondaryTableContainerAdapter());
 	}
 
 	/**
-	 * virtual secondary table container
+	 * virtual secondary table container adapter
 	 */
-	public class VirtualSecondaryTableContainer
-		extends ContextListContainer<OrmVirtualSecondaryTable, JavaSpecifiedSecondaryTable>
+	public class VirtualSecondaryTableContainerAdapter
+		extends AbstractContainerAdapter<OrmVirtualSecondaryTable, JavaSpecifiedSecondaryTable>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return VIRTUAL_SECONDARY_TABLES_LIST;
-		}
-		@Override
-		protected OrmVirtualSecondaryTable buildContextElement(JavaSpecifiedSecondaryTable resourceElement) {
+		public OrmVirtualSecondaryTable buildContextElement(JavaSpecifiedSecondaryTable resourceElement) {
 			return AbstractOrmEntity.this.buildVirtualSecondaryTable(resourceElement);
 		}
-		@Override
-		protected ListIterable<JavaSpecifiedSecondaryTable> getResourceElements() {
+		public ListIterable<JavaSpecifiedSecondaryTable> getResourceElements() {
 			return AbstractOrmEntity.this.getJavaSecondaryTablesForVirtuals();
 		}
-		@Override
-		protected JavaSpecifiedSecondaryTable getResourceElement(OrmVirtualSecondaryTable contextElement) {
+		public JavaSpecifiedSecondaryTable extractResourceElement(OrmVirtualSecondaryTable contextElement) {
 			return contextElement.getOverriddenTable();
 		}
 	}
@@ -773,7 +757,7 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	// ********** specified primary key join columns **********
 
 	public ListIterable<OrmSpecifiedPrimaryKeyJoinColumn> getSpecifiedPrimaryKeyJoinColumns() {
-		return this.specifiedPrimaryKeyJoinColumnContainer.getContextElements();
+		return this.specifiedPrimaryKeyJoinColumnContainer;
 	}
 
 	public SpecifiedPrimaryKeyJoinColumn getSpecifiedPrimaryKeyJoinColumn(int index) {
@@ -785,7 +769,7 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	}
 
 	public int getSpecifiedPrimaryKeyJoinColumnsSize() {
-		return this.specifiedPrimaryKeyJoinColumnContainer.getContextElementsSize();
+		return this.specifiedPrimaryKeyJoinColumnContainer.size();
 	}
 
 	public OrmSpecifiedPrimaryKeyJoinColumn addSpecifiedPrimaryKeyJoinColumn() {
@@ -806,11 +790,11 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	}
 
 	public void removeSpecifiedPrimaryKeyJoinColumn(SpecifiedPrimaryKeyJoinColumn primaryKeyJoinColumn) {
-		this.removeSpecifiedPrimaryKeyJoinColumn(this.specifiedPrimaryKeyJoinColumnContainer.indexOfContextElement((OrmSpecifiedPrimaryKeyJoinColumn) primaryKeyJoinColumn));
+		this.removeSpecifiedPrimaryKeyJoinColumn(this.specifiedPrimaryKeyJoinColumnContainer.indexOf((OrmSpecifiedPrimaryKeyJoinColumn) primaryKeyJoinColumn));
 	}
 
 	public void removeSpecifiedPrimaryKeyJoinColumn(int index) {
-		this.specifiedPrimaryKeyJoinColumnContainer.removeContextElement(index);
+		this.specifiedPrimaryKeyJoinColumnContainer.remove(index);
 		this.xmlTypeMapping.getPrimaryKeyJoinColumns().remove(index);
 	}
 
@@ -826,12 +810,12 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	}
 
 	public void clearSpecifiedPrimaryKeyJoinColumns() {
-		this.specifiedPrimaryKeyJoinColumnContainer.clearContextList();
+		this.specifiedPrimaryKeyJoinColumnContainer.clear();
 		this.xmlTypeMapping.getPrimaryKeyJoinColumns().clear();
 	}
 
 	public void moveSpecifiedPrimaryKeyJoinColumn(int targetIndex, int sourceIndex) {
-		this.specifiedPrimaryKeyJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedPrimaryKeyJoinColumnContainer.move(targetIndex, sourceIndex);
 		this.xmlTypeMapping.getPrimaryKeyJoinColumns().move(targetIndex, sourceIndex);
 	}
 
@@ -849,31 +833,22 @@ public abstract class AbstractOrmEntity<X extends XmlEntity>
 	}
 
 	protected ContextListContainer<OrmSpecifiedPrimaryKeyJoinColumn, XmlPrimaryKeyJoinColumn> buildSpecifiedPrimaryKeyJoinColumnContainer() {
-		SpecifiedPrimaryKeyJoinColumnContainer container = new SpecifiedPrimaryKeyJoinColumnContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST, new SpecifiedPrimaryKeyJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified primary key join column container
+	 * specified primary key join column container adapter
 	 */
-	public class SpecifiedPrimaryKeyJoinColumnContainer
-		extends ContextListContainer<OrmSpecifiedPrimaryKeyJoinColumn, XmlPrimaryKeyJoinColumn>
+	public class SpecifiedPrimaryKeyJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<OrmSpecifiedPrimaryKeyJoinColumn, XmlPrimaryKeyJoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected OrmSpecifiedPrimaryKeyJoinColumn buildContextElement(XmlPrimaryKeyJoinColumn resourceElement) {
+		public OrmSpecifiedPrimaryKeyJoinColumn buildContextElement(XmlPrimaryKeyJoinColumn resourceElement) {
 			return AbstractOrmEntity.this.buildPrimaryKeyJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlPrimaryKeyJoinColumn> getResourceElements() {
+		public ListIterable<XmlPrimaryKeyJoinColumn> getResourceElements() {
 			return AbstractOrmEntity.this.getXmlPrimaryKeyJoinColumns();
 		}
-		@Override
-		protected XmlPrimaryKeyJoinColumn getResourceElement(OrmSpecifiedPrimaryKeyJoinColumn contextElement) {
+		public XmlPrimaryKeyJoinColumn extractResourceElement(OrmSpecifiedPrimaryKeyJoinColumn contextElement) {
 			return contextElement.getXmlColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmJoinColumnRelationshipStrategy.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmJoinColumnRelationshipStrategy.java
index d09c330286..61d0485e11 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmJoinColumnRelationshipStrategy.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmJoinColumnRelationshipStrategy.java
@@ -15,13 +15,13 @@ import org.eclipse.jpt.common.utility.internal.iterable.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.IterableTools;
 import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterable;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
-import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
 import org.eclipse.jpt.jpa.core.context.JoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
+import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
-import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmJoinColumnRelationship;
+import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.jpa.core.resource.orm.XmlJoinColumn;
@@ -84,11 +84,11 @@ public abstract class AbstractOrmJoinColumnRelationshipStrategy<P extends OrmJoi
 	// ********** specified join columns **********
 
 	public ListIterable<OrmSpecifiedJoinColumn> getSpecifiedJoinColumns() {
-		return this.specifiedJoinColumnContainer.getContextElements();
+		return this.specifiedJoinColumnContainer;
 	}
 
 	public int getSpecifiedJoinColumnsSize() {
-		return this.specifiedJoinColumnContainer.getContextElementsSize();
+		return this.specifiedJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedJoinColumns() {
@@ -96,7 +96,7 @@ public abstract class AbstractOrmJoinColumnRelationshipStrategy<P extends OrmJoi
 	}
 
 	public OrmSpecifiedJoinColumn getSpecifiedJoinColumn(int index) {
-		return this.specifiedJoinColumnContainer.getContextElement(index);
+		return this.specifiedJoinColumnContainer.get(index);
 	}
 
 	public OrmSpecifiedJoinColumn addSpecifiedJoinColumn() {
@@ -115,11 +115,11 @@ public abstract class AbstractOrmJoinColumnRelationshipStrategy<P extends OrmJoi
 	}
 
 	public void removeSpecifiedJoinColumn(SpecifiedJoinColumn joinColumn) {
-		this.removeSpecifiedJoinColumn(this.specifiedJoinColumnContainer.indexOfContextElement((OrmSpecifiedJoinColumn) joinColumn));
+		this.removeSpecifiedJoinColumn(this.specifiedJoinColumnContainer.indexOf((OrmSpecifiedJoinColumn) joinColumn));
 	}
 
 	public void removeSpecifiedJoinColumn(int index) {
-		this.specifiedJoinColumnContainer.removeContextElement(index);
+		this.specifiedJoinColumnContainer.remove(index);
 		this.getXmlJoinColumnContainer().getJoinColumns().remove(index);
 	}
 
@@ -136,12 +136,12 @@ public abstract class AbstractOrmJoinColumnRelationshipStrategy<P extends OrmJoi
 	}
 
 	public void clearSpecifiedJoinColumns() {
-		this.specifiedJoinColumnContainer.clearContextList();
+		this.specifiedJoinColumnContainer.clear();
 		this.getXmlJoinColumnContainer().getJoinColumns().clear();
 	}
 
 	public void moveSpecifiedJoinColumn(int targetIndex, int sourceIndex) {
-		this.specifiedJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedJoinColumnContainer.move(targetIndex, sourceIndex);
 		this.getXmlJoinColumnContainer().getJoinColumns().move(targetIndex, sourceIndex);
 	}
 
@@ -155,31 +155,22 @@ public abstract class AbstractOrmJoinColumnRelationshipStrategy<P extends OrmJoi
 	}
 
 	protected ContextListContainer<OrmSpecifiedJoinColumn, XmlJoinColumn> buildSpecifiedJoinColumnContainer() {
-		SpecifiedJoinColumnContainer container = new SpecifiedJoinColumnContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_JOIN_COLUMNS_LIST, new SpecifiedJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified join column container
+	 * specified join column container adapter
 	 */
-	protected class SpecifiedJoinColumnContainer
-		extends ContextListContainer<OrmSpecifiedJoinColumn, XmlJoinColumn>
+	public class SpecifiedJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<OrmSpecifiedJoinColumn, XmlJoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected OrmSpecifiedJoinColumn buildContextElement(XmlJoinColumn resourceElement) {
+		public OrmSpecifiedJoinColumn buildContextElement(XmlJoinColumn resourceElement) {
 			return AbstractOrmJoinColumnRelationshipStrategy.this.buildJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlJoinColumn> getResourceElements() {
+		public ListIterable<XmlJoinColumn> getResourceElements() {
 			return AbstractOrmJoinColumnRelationshipStrategy.this.getXmlJoinColumns();
 		}
-		@Override
-		protected XmlJoinColumn getResourceElement(OrmSpecifiedJoinColumn contextElement) {
+		public XmlJoinColumn extractResourceElement(OrmSpecifiedJoinColumn contextElement) {
 			return contextElement.getXmlColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java
index a411df4817..45b7dc168c 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java
@@ -718,11 +718,11 @@ public abstract class AbstractOrmMultiRelationshipMapping<X extends AbstractXmlM
 	// ********** specified map key join columns **********
 
 	public ListIterable<OrmSpecifiedJoinColumn> getSpecifiedMapKeyJoinColumns() {
-		return this.specifiedMapKeyJoinColumnContainer.getContextElements();
+		return this.specifiedMapKeyJoinColumnContainer;
 	}
 
 	public int getSpecifiedMapKeyJoinColumnsSize() {
-		return this.specifiedMapKeyJoinColumnContainer.getContextElementsSize();
+		return this.specifiedMapKeyJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedMapKeyJoinColumns() {
@@ -730,7 +730,7 @@ public abstract class AbstractOrmMultiRelationshipMapping<X extends AbstractXmlM
 	}
 
 	public OrmSpecifiedJoinColumn getSpecifiedMapKeyJoinColumn(int index) {
-		return this.specifiedMapKeyJoinColumnContainer.getContextElement(index);
+		return this.specifiedMapKeyJoinColumnContainer.get(index);
 	}
 
 	public OrmSpecifiedJoinColumn addSpecifiedMapKeyJoinColumn() {
@@ -749,16 +749,16 @@ public abstract class AbstractOrmMultiRelationshipMapping<X extends AbstractXmlM
 	}
 
 	public void removeSpecifiedMapKeyJoinColumn(SpecifiedJoinColumn joinColumn) {
-		this.removeSpecifiedMapKeyJoinColumn(this.specifiedMapKeyJoinColumnContainer.indexOfContextElement((OrmSpecifiedJoinColumn) joinColumn));
+		this.removeSpecifiedMapKeyJoinColumn(this.specifiedMapKeyJoinColumnContainer.indexOf((OrmSpecifiedJoinColumn) joinColumn));
 	}
 
 	public void removeSpecifiedMapKeyJoinColumn(int index) {
-		this.specifiedMapKeyJoinColumnContainer.removeContextElement(index);
+		this.specifiedMapKeyJoinColumnContainer.remove(index);
 		this.getXmlAttributeMapping().getMapKeyJoinColumns().remove(index);
 	}
 
 	public void moveSpecifiedMapKeyJoinColumn(int targetIndex, int sourceIndex) {
-		this.specifiedMapKeyJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedMapKeyJoinColumnContainer.move(targetIndex, sourceIndex);
 		this.getXmlAttributeMapping().getMapKeyJoinColumns().move(targetIndex, sourceIndex);
 	}
 
@@ -772,31 +772,22 @@ public abstract class AbstractOrmMultiRelationshipMapping<X extends AbstractXmlM
 	}
 
 	protected ContextListContainer<OrmSpecifiedJoinColumn, XmlJoinColumn> buildSpecifiedMapKeyJoinColumnContainer() {
-		SpecifiedMapKeyJoinColumnContainer container = new SpecifiedMapKeyJoinColumnContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_MAP_KEY_JOIN_COLUMNS_LIST, new SpecifiedMapKeyJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified join column container
+	 * specified map key join column container adapter
 	 */
-	public class SpecifiedMapKeyJoinColumnContainer
-		extends ContextListContainer<OrmSpecifiedJoinColumn, XmlJoinColumn>
+	public class SpecifiedMapKeyJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<OrmSpecifiedJoinColumn, XmlJoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_MAP_KEY_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected OrmSpecifiedJoinColumn buildContextElement(XmlJoinColumn resourceElement) {
+		public OrmSpecifiedJoinColumn buildContextElement(XmlJoinColumn resourceElement) {
 			return AbstractOrmMultiRelationshipMapping.this.buildMapKeyJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlJoinColumn> getResourceElements() {
+		public ListIterable<XmlJoinColumn> getResourceElements() {
 			return AbstractOrmMultiRelationshipMapping.this.getXmlMapKeyJoinColumns();
 		}
-		@Override
-		protected XmlJoinColumn getResourceElement(OrmSpecifiedJoinColumn contextElement) {
+		public XmlJoinColumn extractResourceElement(OrmSpecifiedJoinColumn contextElement) {
 			return contextElement.getXmlColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmQuery.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmQuery.java
index 2553cb7b7f..4968d38217 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmQuery.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmQuery.java
@@ -91,11 +91,11 @@ public abstract class AbstractOrmQuery<X extends XmlQuery>
 	// ********** hints **********
 
 	public ListIterable<OrmQueryHint> getHints() {
-		return this.hintContainer.getContextElements();
+		return this.hintContainer;
 	}
 
 	public int getHintsSize() {
-		return this.hintContainer.getContextElementsSize();
+		return this.hintContainer.size();
 	}
 
 	public OrmQueryHint addHint() {
@@ -114,16 +114,16 @@ public abstract class AbstractOrmQuery<X extends XmlQuery>
 	}
 
 	public void removeHint(QueryHint hint) {
-		this.removeHint(this.hintContainer.indexOfContextElement((OrmQueryHint) hint));
+		this.removeHint(this.hintContainer.indexOf((OrmQueryHint) hint));
 	}
 
 	public void removeHint(int index) {
-		this.hintContainer.removeContextElement(index);
+		this.hintContainer.remove(index);
 		this.xmlQuery.getHints().remove(index);
 	}
 
 	public void moveHint(int targetIndex, int sourceIndex) {
-		this.hintContainer.moveContextElement(targetIndex, sourceIndex);
+		this.hintContainer.move(targetIndex, sourceIndex);
 		this.xmlQuery.getHints().move(targetIndex, sourceIndex);
 	}
 
@@ -145,31 +145,22 @@ public abstract class AbstractOrmQuery<X extends XmlQuery>
 	}
 
 	protected ContextListContainer<OrmQueryHint, XmlQueryHint> buildHintContainer() {
-		HintContainer container = new HintContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(HINTS_LIST, new HintContainerAdapter());
 	}
 
 	/**
-	 * query hint container
+	 * hint container adapter
 	 */
-	protected class HintContainer
-		extends ContextListContainer<OrmQueryHint, XmlQueryHint>
+	public class HintContainerAdapter
+		extends AbstractContainerAdapter<OrmQueryHint, XmlQueryHint>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return HINTS_LIST;
-		}
-		@Override
-		protected OrmQueryHint buildContextElement(XmlQueryHint resourceElement) {
+		public OrmQueryHint buildContextElement(XmlQueryHint resourceElement) {
 			return AbstractOrmQuery.this.buildHint(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlQueryHint> getResourceElements() {
+		public ListIterable<XmlQueryHint> getResourceElements() {
 			return AbstractOrmQuery.this.getXmlHints();
 		}
-		@Override
-		protected XmlQueryHint getResourceElement(OrmQueryHint contextElement) {
+		public XmlQueryHint extractResourceElement(OrmQueryHint contextElement) {
 			return contextElement.getXmlQueryHint();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmTable.java
index e9632cd8ec..5520049c4d 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmTable.java
@@ -20,8 +20,8 @@ import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.SpecifiedUniqueConstraint;
 import org.eclipse.jpt.jpa.core.context.Table;
 import org.eclipse.jpt.jpa.core.context.UniqueConstraint;
-import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedUniqueConstraint;
 import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedTable;
+import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedUniqueConstraint;
 import org.eclipse.jpt.jpa.core.internal.context.JpaValidator;
 import org.eclipse.jpt.jpa.core.resource.orm.AbstractXmlTable;
 import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory;
@@ -271,15 +271,15 @@ public abstract class AbstractOrmTable<P extends JpaContextModel, PA extends Tab
 	// ********** unique constraints **********
 
 	public ListIterable<OrmSpecifiedUniqueConstraint> getUniqueConstraints() {
-		return this.uniqueConstraintContainer.getContextElements();
+		return this.uniqueConstraintContainer;
 	}
 
 	public int getUniqueConstraintsSize() {
-		return this.uniqueConstraintContainer.getContextElementsSize();
+		return this.uniqueConstraintContainer.size();
 	}
 
 	public OrmSpecifiedUniqueConstraint getUniqueConstraint(int index) {
-		return this.uniqueConstraintContainer.getContextElement(index);
+		return this.uniqueConstraintContainer.get(index);
 	}
 
 	public OrmSpecifiedUniqueConstraint addUniqueConstraint() {
@@ -299,17 +299,17 @@ public abstract class AbstractOrmTable<P extends JpaContextModel, PA extends Tab
 	}
 
 	public void removeUniqueConstraint(SpecifiedUniqueConstraint uniqueConstraint) {
-		this.removeUniqueConstraint(this.uniqueConstraintContainer.indexOfContextElement((OrmSpecifiedUniqueConstraint) uniqueConstraint));
+		this.removeUniqueConstraint(this.uniqueConstraintContainer.indexOf((OrmSpecifiedUniqueConstraint) uniqueConstraint));
 	}
 
 	public void removeUniqueConstraint(int index) {
-		this.uniqueConstraintContainer.removeContextElement(index);
+		this.uniqueConstraintContainer.remove(index);
 		this.getXmlTable().getUniqueConstraints().remove(index);
 		this.removeXmlTableIfUnset();
 	}
 
 	public void moveUniqueConstraint(int targetIndex, int sourceIndex) {
-		this.uniqueConstraintContainer.moveContextElement(targetIndex, sourceIndex);
+		this.uniqueConstraintContainer.move(targetIndex, sourceIndex);
 		this.getXmlTable().getUniqueConstraints().move(targetIndex, sourceIndex);
 	}
 
@@ -329,31 +329,22 @@ public abstract class AbstractOrmTable<P extends JpaContextModel, PA extends Tab
 	}
 
 	protected ContextListContainer<OrmSpecifiedUniqueConstraint, XmlUniqueConstraint> buildUniqueConstraintContainer() {
-		UniqueConstraintContainer container = new UniqueConstraintContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(UNIQUE_CONSTRAINTS_LIST, new UniqueConstraintContainerAdapter());
 	}
 
 	/**
-	 * unique constraint container
+	 * unique constraint container adapter
 	 */
-	protected class UniqueConstraintContainer
-		extends ContextListContainer<OrmSpecifiedUniqueConstraint, XmlUniqueConstraint>
+	public class UniqueConstraintContainerAdapter
+		extends AbstractContainerAdapter<OrmSpecifiedUniqueConstraint, XmlUniqueConstraint>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return UNIQUE_CONSTRAINTS_LIST;
-		}
-		@Override
-		protected OrmSpecifiedUniqueConstraint buildContextElement(XmlUniqueConstraint resourceElement) {
+		public OrmSpecifiedUniqueConstraint buildContextElement(XmlUniqueConstraint resourceElement) {
 			return AbstractOrmTable.this.buildUniqueConstraint(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlUniqueConstraint> getResourceElements() {
+		public ListIterable<XmlUniqueConstraint> getResourceElements() {
 			return AbstractOrmTable.this.getXmlUniqueConstraints();
 		}
-		@Override
-		protected XmlUniqueConstraint getResourceElement(OrmSpecifiedUniqueConstraint contextElement) {
+		public XmlUniqueConstraint extractResourceElement(OrmSpecifiedUniqueConstraint contextElement) {
 			return contextElement.getXmlUniqueConstraint();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmVirtualReferenceTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmVirtualReferenceTable.java
index c70d0679c5..43415175d0 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmVirtualReferenceTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmVirtualReferenceTable.java
@@ -10,13 +10,12 @@
 package org.eclipse.jpt.jpa.core.internal.context.orm;
 
 import java.util.List;
-
 import org.eclipse.jpt.common.utility.internal.iterable.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.SuperListIterableWrapper;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
-import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
+import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.ReferenceTable;
 import org.eclipse.jpt.jpa.core.context.Table;
 import org.eclipse.jpt.jpa.core.context.VirtualJoinColumn;
@@ -65,11 +64,11 @@ public abstract class AbstractOrmVirtualReferenceTable<P extends JpaContextModel
 	// ********** specified join columns **********
 
 	public ListIterable<VirtualJoinColumn> getSpecifiedJoinColumns() {
-		return this.specifiedJoinColumnContainer.getContextElements();
+		return this.specifiedJoinColumnContainer;
 	}
 
 	public int getSpecifiedJoinColumnsSize() {
-		return this.specifiedJoinColumnContainer.getContextElementsSize();
+		return this.specifiedJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedJoinColumns() {
@@ -77,7 +76,7 @@ public abstract class AbstractOrmVirtualReferenceTable<P extends JpaContextModel
 	}
 
 	public VirtualJoinColumn getSpecifiedJoinColumn(int index) {
-		return this.specifiedJoinColumnContainer.getContextElement(index);
+		return this.specifiedJoinColumnContainer.get(index);
 	}
 
 	protected void updateSpecifiedJoinColumns() {
@@ -89,7 +88,7 @@ public abstract class AbstractOrmVirtualReferenceTable<P extends JpaContextModel
 	}
 
 	protected void moveSpecifiedJoinColumn(int index, VirtualJoinColumn joinColumn) {
-		this.specifiedJoinColumnContainer.moveContextElement(index, joinColumn);
+		this.specifiedJoinColumnContainer.move(index, joinColumn);
 	}
 
 	protected VirtualJoinColumn addSpecifiedJoinColumn(int index, JoinColumn joinColumn) {
@@ -97,33 +96,26 @@ public abstract class AbstractOrmVirtualReferenceTable<P extends JpaContextModel
 	}
 
 	protected void removeSpecifiedJoinColumn(VirtualJoinColumn joinColumn) {
-		this.specifiedJoinColumnContainer.removeContextElement(joinColumn);
+		this.specifiedJoinColumnContainer.remove(joinColumn);
 	}
 
 	protected ContextListContainer<VirtualJoinColumn, JoinColumn> buildSpecifiedJoinColumnContainer() {
-		return new SpecifiedJoinColumnContainer();
+		return this.buildVirtualContextListContainer(SPECIFIED_JOIN_COLUMNS_LIST, new SpecifiedJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified join column container
+	 * specified join column container adapter
 	 */
-	protected class SpecifiedJoinColumnContainer
-		extends ContextListContainer<VirtualJoinColumn, JoinColumn>
+	public class SpecifiedJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<VirtualJoinColumn, JoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected VirtualJoinColumn buildContextElement(JoinColumn resourceElement) {
+		public VirtualJoinColumn buildContextElement(JoinColumn resourceElement) {
 			return AbstractOrmVirtualReferenceTable.this.buildJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<JoinColumn> getResourceElements() {
+		public ListIterable<JoinColumn> getResourceElements() {
 			return AbstractOrmVirtualReferenceTable.this.getOverriddenJoinColumns();
 		}
-		@Override
-		protected JoinColumn getResourceElement(VirtualJoinColumn contextElement) {
+		public JoinColumn extractResourceElement(VirtualJoinColumn contextElement) {
 			return contextElement.getOverriddenColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmVirtualTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmVirtualTable.java
index df488c7241..70c58917d8 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmVirtualTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/AbstractOrmVirtualTable.java
@@ -185,15 +185,15 @@ public abstract class AbstractOrmVirtualTable<P extends JpaContextModel, PA exte
 	// ********** unique constraints **********
 
 	public ListIterable<VirtualUniqueConstraint> getUniqueConstraints() {
-		return this.uniqueConstraintContainer.getContextElements();
+		return this.uniqueConstraintContainer;
 	}
 
 	public int getUniqueConstraintsSize() {
-		return this.uniqueConstraintContainer.getContextElementsSize();
+		return this.uniqueConstraintContainer.size();
 	}
 
 	public VirtualUniqueConstraint getUniqueConstraint(int index) {
-		return this.uniqueConstraintContainer.getContextElement(index);
+		return this.uniqueConstraintContainer.get(index);
 	}
 
 	protected void updateUniqueConstraints() {
@@ -205,7 +205,7 @@ public abstract class AbstractOrmVirtualTable<P extends JpaContextModel, PA exte
 	}
 
 	protected void moveUniqueConstraint(int index, VirtualUniqueConstraint constraint) {
-		this.uniqueConstraintContainer.moveContextElement(index, constraint);
+		this.uniqueConstraintContainer.move(index, constraint);
 	}
 
 	protected VirtualUniqueConstraint addUniqueConstraint(int index, UniqueConstraint uniqueConstraint) {
@@ -217,33 +217,26 @@ public abstract class AbstractOrmVirtualTable<P extends JpaContextModel, PA exte
 	}
 
 	protected void removeUniqueConstraint(VirtualUniqueConstraint constraint) {
-		this.uniqueConstraintContainer.removeContextElement(constraint);
+		this.uniqueConstraintContainer.remove(constraint);
 	}
 
 	protected ContextListContainer<VirtualUniqueConstraint, UniqueConstraint> buildUniqueConstraintContainer() {
-		return new UniqueConstraintContainer();
+		return this.buildVirtualContextListContainer(UNIQUE_CONSTRAINTS_LIST, new UniqueConstraintContainerAdapter());
 	}
 
 	/**
-	 * unique constraint container
+	 * unique constraint container adapter
 	 */
-	protected class UniqueConstraintContainer
-		extends ContextListContainer<VirtualUniqueConstraint, UniqueConstraint>
+	public class UniqueConstraintContainerAdapter
+		extends AbstractContainerAdapter<VirtualUniqueConstraint, UniqueConstraint>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return UNIQUE_CONSTRAINTS_LIST;
-		}
-		@Override
-		protected VirtualUniqueConstraint buildContextElement(UniqueConstraint resourceElement) {
+		public VirtualUniqueConstraint buildContextElement(UniqueConstraint resourceElement) {
 			return AbstractOrmVirtualTable.this.buildUniqueConstraint(resourceElement);
 		}
-		@Override
-		protected ListIterable<UniqueConstraint> getResourceElements() {
+		public ListIterable<UniqueConstraint> getResourceElements() {
 			return AbstractOrmVirtualTable.this.getOverriddenUniqueConstraints();
 		}
-		@Override
-		protected UniqueConstraint getResourceElement(VirtualUniqueConstraint contextElement) {
+		public UniqueConstraint extractResourceElement(VirtualUniqueConstraint contextElement) {
 			return contextElement.getOverriddenUniqueConstraint();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmPrimaryKeyJoinColumnRelationshipStrategy.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmPrimaryKeyJoinColumnRelationshipStrategy.java
index 0174495366..b320226d8a 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmPrimaryKeyJoinColumnRelationshipStrategy.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmPrimaryKeyJoinColumnRelationshipStrategy.java
@@ -13,23 +13,23 @@ import java.util.List;
 import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.common.utility.internal.iterable.IterableTools;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
-import org.eclipse.jpt.jpa.core.context.Entity;
-import org.eclipse.jpt.jpa.core.context.JpaContextModel;
-import org.eclipse.jpt.jpa.core.context.SpecifiedPersistentAttribute;
-import org.eclipse.jpt.jpa.core.context.SpecifiedPrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.BaseJoinColumn;
+import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
+import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.NamedColumn;
-import org.eclipse.jpt.jpa.core.context.RelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
+import org.eclipse.jpt.jpa.core.context.RelationshipStrategy;
+import org.eclipse.jpt.jpa.core.context.SpecifiedPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.SpecifiedPrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
-import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedPrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmPrimaryKeyJoinColumnRelationship;
+import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedPrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedPrimaryKeyJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.internal.context.JpaValidator;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.OneToOnePrimaryKeyJoinColumnValidator;
-import org.eclipse.jpt.jpa.core.jpa2.context.SpecifiedMappingRelationshipStrategy2_0;
 import org.eclipse.jpt.jpa.core.jpa2.context.OverrideRelationship2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.SpecifiedMappingRelationshipStrategy2_0;
 import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.jpa.core.resource.orm.XmlPrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.resource.orm.XmlPrimaryKeyJoinColumnContainer;
@@ -71,11 +71,11 @@ public class GenericOrmPrimaryKeyJoinColumnRelationshipStrategy
 	// ********** primary key join columns **********
 
 	public ListIterable<OrmSpecifiedPrimaryKeyJoinColumn> getPrimaryKeyJoinColumns() {
-		return this.primaryKeyJoinColumnContainer.getContextElements();
+		return this.primaryKeyJoinColumnContainer;
 	}
 
 	public int getPrimaryKeyJoinColumnsSize() {
-		return this.primaryKeyJoinColumnContainer.getContextElementsSize();
+		return this.primaryKeyJoinColumnContainer.size();
 	}
 
 	public boolean hasPrimaryKeyJoinColumns() {
@@ -83,7 +83,7 @@ public class GenericOrmPrimaryKeyJoinColumnRelationshipStrategy
 	}
 
 	public OrmSpecifiedPrimaryKeyJoinColumn getPrimaryKeyJoinColumn(int index) {
-		return this.primaryKeyJoinColumnContainer.getContextElement(index);
+		return this.primaryKeyJoinColumnContainer.get(index);
 	}
 
 	public OrmSpecifiedPrimaryKeyJoinColumn addPrimaryKeyJoinColumn() {
@@ -102,16 +102,16 @@ public class GenericOrmPrimaryKeyJoinColumnRelationshipStrategy
 	}
 
 	public void removePrimaryKeyJoinColumn(SpecifiedPrimaryKeyJoinColumn joinColumn) {
-		this.removePrimaryKeyJoinColumn(this.primaryKeyJoinColumnContainer.indexOfContextElement((OrmSpecifiedPrimaryKeyJoinColumn) joinColumn));
+		this.removePrimaryKeyJoinColumn(this.primaryKeyJoinColumnContainer.indexOf((OrmSpecifiedPrimaryKeyJoinColumn) joinColumn));
 	}
 
 	public void removePrimaryKeyJoinColumn(int index) {
-		this.primaryKeyJoinColumnContainer.removeContextElement(index);
+		this.primaryKeyJoinColumnContainer.remove(index);
 		this.getXmlPrimaryKeyJoinColumnContainer().getPrimaryKeyJoinColumns().remove(index);
 	}
 
 	public void movePrimaryKeyJoinColumn(int targetIndex, int sourceIndex) {
-		this.primaryKeyJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.primaryKeyJoinColumnContainer.move(targetIndex, sourceIndex);
 		this.getXmlPrimaryKeyJoinColumnContainer().getPrimaryKeyJoinColumns().move(targetIndex, sourceIndex);
 	}
 
@@ -125,26 +125,23 @@ public class GenericOrmPrimaryKeyJoinColumnRelationshipStrategy
 		return IterableTools.cloneLive(this.getXmlPrimaryKeyJoinColumnContainer().getPrimaryKeyJoinColumns());
 	}
 
+	protected ContextListContainer<OrmSpecifiedPrimaryKeyJoinColumn, XmlPrimaryKeyJoinColumn> buildPrimaryKeyJoinColumnContainer() {
+		return this.buildSpecifiedContextListContainer(PRIMARY_KEY_JOIN_COLUMNS_LIST, new PrimaryKeyJoinColumnContainerAdapter());
+	}
+
 	/**
-	 *  primary key join column container
+	 * primary key join column container adapter
 	 */
-	protected class PrimaryKeyJoinColumnContainer
-		extends ContextListContainer<OrmSpecifiedPrimaryKeyJoinColumn, XmlPrimaryKeyJoinColumn>
+	public class PrimaryKeyJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<OrmSpecifiedPrimaryKeyJoinColumn, XmlPrimaryKeyJoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return PRIMARY_KEY_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected OrmSpecifiedPrimaryKeyJoinColumn buildContextElement(XmlPrimaryKeyJoinColumn resourceElement) {
+		public OrmSpecifiedPrimaryKeyJoinColumn buildContextElement(XmlPrimaryKeyJoinColumn resourceElement) {
 			return GenericOrmPrimaryKeyJoinColumnRelationshipStrategy.this.buildPrimaryKeyJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlPrimaryKeyJoinColumn> getResourceElements() {
+		public ListIterable<XmlPrimaryKeyJoinColumn> getResourceElements() {
 			return GenericOrmPrimaryKeyJoinColumnRelationshipStrategy.this.getXmlPrimaryKeyJoinColumns();
 		}
-		@Override
-		protected XmlPrimaryKeyJoinColumn getResourceElement(OrmSpecifiedPrimaryKeyJoinColumn contextElement) {
+		public XmlPrimaryKeyJoinColumn extractResourceElement(OrmSpecifiedPrimaryKeyJoinColumn contextElement) {
 			return contextElement.getXmlColumn();
 		}
 	}
@@ -157,12 +154,6 @@ public class GenericOrmPrimaryKeyJoinColumnRelationshipStrategy
 		return this.getContextModelFactory().buildOrmPrimaryKeyJoinColumn(this.primaryKeyJoinColumnParentAdapter, xmlJoinColumn);
 	}
 
-	protected ContextListContainer<OrmSpecifiedPrimaryKeyJoinColumn, XmlPrimaryKeyJoinColumn> buildPrimaryKeyJoinColumnContainer() {
-		PrimaryKeyJoinColumnContainer container = new PrimaryKeyJoinColumnContainer();
-		container.initialize();
-		return container;
-	}
-
 
 	// ********** misc **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmVirtualJoinTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmVirtualJoinTable.java
index f8ce900a9a..721e0c865c 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmVirtualJoinTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmVirtualJoinTable.java
@@ -18,12 +18,12 @@ import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterabl
 import org.eclipse.jpt.common.utility.internal.iterable.SuperListIterableWrapper;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
 import org.eclipse.jpt.jpa.core.context.Entity;
-import org.eclipse.jpt.jpa.core.context.JpaContextModel;
-import org.eclipse.jpt.jpa.core.context.SpecifiedPersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
 import org.eclipse.jpt.jpa.core.context.JoinTable;
+import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.NamedColumn;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
+import org.eclipse.jpt.jpa.core.context.SpecifiedPersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.VirtualJoinColumn;
 import org.eclipse.jpt.jpa.core.context.VirtualJoinTable;
@@ -79,11 +79,11 @@ public class GenericOrmVirtualJoinTable
 	// ********** specified inverse join columns **********
 
 	public ListIterable<VirtualJoinColumn> getSpecifiedInverseJoinColumns() {
-		return this.specifiedInverseJoinColumnContainer.getContextElements();
+		return this.specifiedInverseJoinColumnContainer;
 	}
 
 	public int getSpecifiedInverseJoinColumnsSize() {
-		return this.specifiedInverseJoinColumnContainer.getContextElementsSize();
+		return this.specifiedInverseJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedInverseJoinColumns() {
@@ -91,7 +91,7 @@ public class GenericOrmVirtualJoinTable
 	}
 
 	public VirtualJoinColumn getSpecifiedInverseJoinColumn(int index) {
-		return this.specifiedInverseJoinColumnContainer.getContextElement(index);
+		return this.specifiedInverseJoinColumnContainer.get(index);
 	}
 
 	protected void updateSpecifiedInverseJoinColumns() {
@@ -103,7 +103,7 @@ public class GenericOrmVirtualJoinTable
 	}
 
 	protected void moveSpecifiedInverseJoinColumn(int index, VirtualJoinColumn joinColumn) {
-		this.specifiedInverseJoinColumnContainer.moveContextElement(index, joinColumn);
+		this.specifiedInverseJoinColumnContainer.move(index, joinColumn);
 	}
 
 	protected VirtualJoinColumn addSpecifiedInverseJoinColumn(int index, JoinColumn joinColumn) {
@@ -111,33 +111,26 @@ public class GenericOrmVirtualJoinTable
 	}
 
 	protected void removeSpecifiedInverseJoinColumn(VirtualJoinColumn joinColumn) {
-		this.specifiedInverseJoinColumnContainer.removeContextElement(joinColumn);
+		this.specifiedInverseJoinColumnContainer.remove(joinColumn);
 	}
 
 	protected ContextListContainer<VirtualJoinColumn, JoinColumn> buildSpecifiedInverseJoinColumnContainer() {
-		return new SpecifiedInverseJoinColumnContainer();
+		return this.buildVirtualContextListContainer(SPECIFIED_INVERSE_JOIN_COLUMNS_LIST, new SpecifiedInverseJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified inverse join column container
+	 * specified inverse join column container adapter
 	 */
-	protected class SpecifiedInverseJoinColumnContainer
-		extends ContextListContainer<VirtualJoinColumn, JoinColumn>
+	public class SpecifiedInverseJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<VirtualJoinColumn, JoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_INVERSE_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected VirtualJoinColumn buildContextElement(JoinColumn resourceElement) {
+		public VirtualJoinColumn buildContextElement(JoinColumn resourceElement) {
 			return GenericOrmVirtualJoinTable.this.buildInverseJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<JoinColumn> getResourceElements() {
+		public ListIterable<JoinColumn> getResourceElements() {
 			return GenericOrmVirtualJoinTable.this.getOverriddenInverseJoinColumns();
 		}
-		@Override
-		protected JoinColumn getResourceElement(VirtualJoinColumn contextElement) {
+		public JoinColumn extractResourceElement(VirtualJoinColumn contextElement) {
 			return contextElement.getOverriddenColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmVirtualOverrideJoinColumnRelationshipStrategy.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmVirtualOverrideJoinColumnRelationshipStrategy.java
index 4ed0cfb2bb..149fb811ea 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmVirtualOverrideJoinColumnRelationshipStrategy.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmVirtualOverrideJoinColumnRelationshipStrategy.java
@@ -16,8 +16,8 @@ import org.eclipse.jpt.common.utility.internal.iterable.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.SuperListIterableWrapper;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
-import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.BaseColumn;
+import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
 import org.eclipse.jpt.jpa.core.context.JoinColumnRelationship;
 import org.eclipse.jpt.jpa.core.context.JoinColumnRelationshipStrategy;
@@ -76,11 +76,11 @@ public class GenericOrmVirtualOverrideJoinColumnRelationshipStrategy
 	// ********** specified join columns **********
 
 	public ListIterable<VirtualJoinColumn> getSpecifiedJoinColumns() {
-		return this.specifiedJoinColumnContainer.getContextElements();
+		return this.specifiedJoinColumnContainer;
 	}
 
 	public int getSpecifiedJoinColumnsSize() {
-		return this.specifiedJoinColumnContainer.getContextElementsSize();
+		return this.specifiedJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedJoinColumns() {
@@ -88,7 +88,7 @@ public class GenericOrmVirtualOverrideJoinColumnRelationshipStrategy
 	}
 
 	public VirtualJoinColumn getSpecifiedJoinColumn(int index) {
-		return this.specifiedJoinColumnContainer.getContextElement(index);
+		return this.specifiedJoinColumnContainer.get(index);
 	}
 
 	protected void updateSpecifiedJoinColumns() {
@@ -103,29 +103,22 @@ public class GenericOrmVirtualOverrideJoinColumnRelationshipStrategy
 	}
 
 	protected ContextListContainer<VirtualJoinColumn, JoinColumn> buildSpecifiedJoinColumnContainer() {
-		return new SpecifiedJoinColumnContainer();
+		return this.buildVirtualContextListContainer(SPECIFIED_JOIN_COLUMNS_LIST, new SpecifiedJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified join column container
+	 * specified join column container adapter
 	 */
-	protected class SpecifiedJoinColumnContainer
-		extends ContextListContainer<VirtualJoinColumn, JoinColumn>
+	public class SpecifiedJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<VirtualJoinColumn, JoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected VirtualJoinColumn buildContextElement(JoinColumn resourceElement) {
+		public VirtualJoinColumn buildContextElement(JoinColumn resourceElement) {
 			return GenericOrmVirtualOverrideJoinColumnRelationshipStrategy.this.buildJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<JoinColumn> getResourceElements() {
+		public ListIterable<JoinColumn> getResourceElements() {
 			return GenericOrmVirtualOverrideJoinColumnRelationshipStrategy.this.getOverriddenSpecifiedJoinColumns();
 		}
-		@Override
-		protected JoinColumn getResourceElement(VirtualJoinColumn contextElement) {
+		public JoinColumn extractResourceElement(VirtualJoinColumn contextElement) {
 			return contextElement.getOverriddenColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmVirtualSecondaryTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmVirtualSecondaryTable.java
index a368e22da9..31dc419894 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmVirtualSecondaryTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/orm/GenericOrmVirtualSecondaryTable.java
@@ -14,8 +14,8 @@ import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.common.utility.internal.iterable.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterable;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
-import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.BaseJoinColumn;
+import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.NamedColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedPrimaryKeyJoinColumn;
@@ -74,11 +74,11 @@ public class GenericOrmVirtualSecondaryTable
 	// ********** specified primary key join columns **********
 
 	public ListIterable<OrmVirtualPrimaryKeyJoinColumn> getSpecifiedPrimaryKeyJoinColumns() {
-		return this.specifiedPrimaryKeyJoinColumnContainer.getContextElements();
+		return this.specifiedPrimaryKeyJoinColumnContainer;
 	}
 
 	public int getSpecifiedPrimaryKeyJoinColumnsSize() {
-		return this.specifiedPrimaryKeyJoinColumnContainer.getContextElementsSize();
+		return this.specifiedPrimaryKeyJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedPrimaryKeyJoinColumns() {
@@ -86,7 +86,7 @@ public class GenericOrmVirtualSecondaryTable
 	}
 
 	public OrmVirtualPrimaryKeyJoinColumn getSpecifiedPrimaryKeyJoinColumn(int index) {
-		return this.specifiedPrimaryKeyJoinColumnContainer.getContextElement(index);
+		return this.specifiedPrimaryKeyJoinColumnContainer.get(index);
 	}
 
 	protected void updateSpecifiedPrimaryKeyJoinColumns() {
@@ -98,7 +98,7 @@ public class GenericOrmVirtualSecondaryTable
 	}
 
 	protected void moveSpecifiedPrimaryKeyJoinColumn(int index, OrmVirtualPrimaryKeyJoinColumn pkJoinColumn) {
-		this.specifiedPrimaryKeyJoinColumnContainer.moveContextElement(index, pkJoinColumn);
+		this.specifiedPrimaryKeyJoinColumnContainer.move(index, pkJoinColumn);
 	}
 
 	protected OrmVirtualPrimaryKeyJoinColumn addSpecifiedPrimaryKeyJoinColumn(int index, JavaSpecifiedPrimaryKeyJoinColumn javaColumn) {
@@ -106,33 +106,26 @@ public class GenericOrmVirtualSecondaryTable
 	}
 
 	protected void removeSpecifiedPrimaryKeyJoinColumn(OrmVirtualPrimaryKeyJoinColumn pkJoinColumn) {
-		this.specifiedPrimaryKeyJoinColumnContainer.removeContextElement(pkJoinColumn);
+		this.specifiedPrimaryKeyJoinColumnContainer.remove(pkJoinColumn);
 	}
 
 	protected ContextListContainer<OrmVirtualPrimaryKeyJoinColumn, JavaSpecifiedPrimaryKeyJoinColumn> buildSpecifiedPrimaryKeyJoinColumnContainer() {
-		return new SpecifiedPrimaryKeyJoinColumnContainer();
+		return this.buildVirtualContextListContainer(SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST, new SpecifiedPrimaryKeyJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified primary key join column container
+	 * specified primary key join column container adapter
 	 */
-	protected class SpecifiedPrimaryKeyJoinColumnContainer
-		extends ContextListContainer<OrmVirtualPrimaryKeyJoinColumn, JavaSpecifiedPrimaryKeyJoinColumn>
+	public class SpecifiedPrimaryKeyJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<OrmVirtualPrimaryKeyJoinColumn, JavaSpecifiedPrimaryKeyJoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected OrmVirtualPrimaryKeyJoinColumn buildContextElement(JavaSpecifiedPrimaryKeyJoinColumn resourceElement) {
+		public OrmVirtualPrimaryKeyJoinColumn buildContextElement(JavaSpecifiedPrimaryKeyJoinColumn resourceElement) {
 			return GenericOrmVirtualSecondaryTable.this.buildPrimaryKeyJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<JavaSpecifiedPrimaryKeyJoinColumn> getResourceElements() {
+		public ListIterable<JavaSpecifiedPrimaryKeyJoinColumn> getResourceElements() {
 			return GenericOrmVirtualSecondaryTable.this.getOverriddenPrimaryKeyJoinColumns();
 		}
-		@Override
-		protected JavaSpecifiedPrimaryKeyJoinColumn getResourceElement(OrmVirtualPrimaryKeyJoinColumn contextElement) {
+		public JavaSpecifiedPrimaryKeyJoinColumn extractResourceElement(OrmVirtualPrimaryKeyJoinColumn contextElement) {
 			return contextElement.getOverriddenColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/persistence/AbstractPersistenceUnit.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/persistence/AbstractPersistenceUnit.java
index 04ed4778dc..c6eb38db46 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/persistence/AbstractPersistenceUnit.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/context/persistence/AbstractPersistenceUnit.java
@@ -571,11 +571,11 @@ public abstract class AbstractPersistenceUnit
 	// ********** specified mapping file refs **********
 
 	public ListIterable<MappingFileRef> getSpecifiedMappingFileRefs() {
-		return this.specifiedMappingFileRefContainer.getContextElements();
+		return this.specifiedMappingFileRefContainer;
 	}
 
 	public int getSpecifiedMappingFileRefsSize() {
-		return this.specifiedMappingFileRefContainer.getContextElementsSize();
+		return this.specifiedMappingFileRefContainer.size();
 	}
 
 	public MappingFileRef addSpecifiedMappingFileRef(String fileName) {
@@ -600,7 +600,7 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	public void removeSpecifiedMappingFileRef(MappingFileRef mappingFileRef) {
-		this.removeSpecifiedMappingFileRef(this.specifiedMappingFileRefContainer.indexOfContextElement(mappingFileRef));
+		this.removeSpecifiedMappingFileRef(this.specifiedMappingFileRefContainer.indexOf(mappingFileRef));
 	}
 
 	public void removeSpecifiedMappingFileRef(int index) {
@@ -609,7 +609,7 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	protected void removeSpecifiedMappingFileRef_(int index) {
-		this.specifiedMappingFileRefContainer.removeContextElement(index);
+		this.specifiedMappingFileRefContainer.remove(index);
 	}
 
 	protected void syncSpecifiedMappingFileRefs() {
@@ -622,36 +622,59 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	protected ContextListContainer<MappingFileRef, XmlMappingFileRef> buildSpecifiedMappingFileRefContainer() {
-		SpecifiedMappingFileRefContainer container = new SpecifiedMappingFileRefContainer();
-		container.initialize();
-		return container;
+		return new SpecifiedMappingFileRefContainer(SPECIFIED_MAPPING_FILE_REFS_LIST, new SpecifiedMappingFileRefContainerAdapter());
+		// return this.buildSpecifiedContextListContainer(SPECIFIED_MAPPING_FILE_REFS_LIST, new SpecifiedMappingFileRefContainerAdapter());
 	}
 
 	/**
-	 * specified mapping file ref container
+	 * specified mapping file ref container adapter
 	 */
-	protected class SpecifiedMappingFileRefContainer
-		extends ContextListContainer<MappingFileRef, XmlMappingFileRef>
+	public class SpecifiedMappingFileRefContainerAdapter
+		extends AbstractContainerAdapter<MappingFileRef, XmlMappingFileRef>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_MAPPING_FILE_REFS_LIST;
-		}
-		@Override
-		protected MappingFileRef buildContextElement(XmlMappingFileRef resourceElement) {
+		public MappingFileRef buildContextElement(XmlMappingFileRef resourceElement) {
 			return AbstractPersistenceUnit.this.buildSpecifiedMappingFileRef(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlMappingFileRef> getResourceElements() {
+		public ListIterable<XmlMappingFileRef> getResourceElements() {
 			return AbstractPersistenceUnit.this.getXmlMappingFileRefs();
 		}
-		@Override
-		protected XmlMappingFileRef getResourceElement(MappingFileRef contextElement) {
+		public XmlMappingFileRef extractResourceElement(MappingFileRef contextElement) {
 			return contextElement.getXmlMappingFileRef();
 		}
+	}
+
+	// TODO - remove once we remove need for dispose...
+	public class SpecifiedMappingFileRefContainer
+		extends SpecifiedContextListContainer<MappingFileRef, XmlMappingFileRef>
+	{
+		public SpecifiedMappingFileRefContainer(String aspectName, Container.Adapter<MappingFileRef, XmlMappingFileRef> adapter) {
+			super(aspectName, adapter);
+		}
+		@Override
+		public void clear() {
+			Object[] temp = this.elements.toArray();
+			super.clear();
+			for (Object element : temp) {
+				((MappingFileRef) element).dispose();
+			}
+		}
 		@Override
-		protected void disposeElement(MappingFileRef element) {
+		public MappingFileRef remove(int index) {
+			MappingFileRef element = super.remove(index);
 			element.dispose();
+			return element;
+		}
+		@Override
+		public void remove(MappingFileRef element) {
+			super.remove(element);
+			element.dispose();
+		}
+		@Override
+		public void removeAll(Iterable<MappingFileRef> contextElements) {
+			super.removeAll(contextElements);
+			for (MappingFileRef element : contextElements) {
+				element.dispose();
+			}
 		}
 	}
 
@@ -716,11 +739,11 @@ public abstract class AbstractPersistenceUnit
 	// ********** JAR file refs **********
 
 	public ListIterable<JarFileRef> getJarFileRefs() {
-		return this.jarFileRefContainer.getContextElements();
+		return this.jarFileRefContainer;
 	}
 
 	public int getJarFileRefsSize() {
-		return this.jarFileRefContainer.getContextElementsSize();
+		return this.jarFileRefContainer.size();
 	}
 
 	public JarFileRef addJarFileRef(String fileName) {
@@ -745,7 +768,7 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	public void removeJarFileRef(JarFileRef jarFileRef) {
-		this.removeJarFileRef(this.jarFileRefContainer.indexOfContextElement(jarFileRef));
+		this.removeJarFileRef(this.jarFileRefContainer.indexOf(jarFileRef));
 	}
 
 	public void removeJarFileRef(int index) {
@@ -754,7 +777,7 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	protected void removeJarFileRef_(int index) {
-		this.jarFileRefContainer.removeContextElement(index);
+		this.jarFileRefContainer.remove(index);
 	}
 
 	protected void syncJarFileRefs() {
@@ -767,31 +790,22 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	protected ContextListContainer<JarFileRef, XmlJarFileRef> buildJarFileRefContainer() {
-		JarFileRefContainer container = new JarFileRefContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(JAR_FILE_REFS_LIST, new JarFileRefContainerAdapter());
 	}
 
 	/**
-	 * JAR file ref container
+	 * JAR file ref container adapter
 	 */
-	protected class JarFileRefContainer
-		extends ContextListContainer<JarFileRef, XmlJarFileRef>
+	public class JarFileRefContainerAdapter
+		extends AbstractContainerAdapter<JarFileRef, XmlJarFileRef>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return JAR_FILE_REFS_LIST;
-		}
-		@Override
-		protected JarFileRef buildContextElement(XmlJarFileRef resourceElement) {
+		public JarFileRef buildContextElement(XmlJarFileRef resourceElement) {
 			return AbstractPersistenceUnit.this.buildJarFileRef(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlJarFileRef> getResourceElements() {
+		public ListIterable<XmlJarFileRef> getResourceElements() {
 			return AbstractPersistenceUnit.this.getXmlJarFileRefs();
 		}
-		@Override
-		protected XmlJarFileRef getResourceElement(JarFileRef contextElement) {
+		public XmlJarFileRef extractResourceElement(JarFileRef contextElement) {
 			return contextElement.getXmlJarFileRef();
 		}
 	}
@@ -814,11 +828,11 @@ public abstract class AbstractPersistenceUnit
 	// ********** specified class refs **********
 
 	public ListIterable<ClassRef> getSpecifiedClassRefs() {
-		return this.specifiedClassRefContainer.getContextElements();
+		return this.specifiedClassRefContainer;
 	}
 
 	public int getSpecifiedClassRefsSize() {
-		return this.specifiedClassRefContainer.getContextElementsSize();
+		return this.specifiedClassRefContainer.size();
 	}
 
 	public ClassRef addSpecifiedClassRef(String className) {
@@ -857,7 +871,7 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	public void removeSpecifiedClassRef(ClassRef classRef) {
-		this.removeSpecifiedClassRef(this.specifiedClassRefContainer.indexOfContextElement(classRef));
+		this.removeSpecifiedClassRef(this.specifiedClassRefContainer.indexOf(classRef));
 	}
 
 	public void removeSpecifiedClassRef(int index) {
@@ -866,7 +880,7 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	protected void removeSpecifiedClassRef_(int index) {
-		this.specifiedClassRefContainer.removeContextElement(index);
+		this.specifiedClassRefContainer.remove(index);
 	}
 
 	public void removeSpecifiedClassRefs(Iterable<ClassRef> classRefs) {
@@ -888,31 +902,22 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	protected ContextListContainer<ClassRef, XmlJavaClassRef> buildSpecifiedClassRefContainer() {
-		SpecifiedClassRefContainer container = new SpecifiedClassRefContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_CLASS_REFS_LIST, new SpecifiedClassRefContainerAdapter());
 	}
 
 	/**
-	 * specified class ref container
+	 * specified class ref container adapter
 	 */
-	protected class SpecifiedClassRefContainer
-		extends ContextListContainer<ClassRef, XmlJavaClassRef>
+	public class SpecifiedClassRefContainerAdapter
+		extends AbstractContainerAdapter<ClassRef, XmlJavaClassRef>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_CLASS_REFS_LIST;
-		}
-		@Override
-		protected ClassRef buildContextElement(XmlJavaClassRef resourceElement) {
+		public ClassRef buildContextElement(XmlJavaClassRef resourceElement) {
 			return AbstractPersistenceUnit.this.buildClassRef(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlJavaClassRef> getResourceElements() {
+		public ListIterable<XmlJavaClassRef> getResourceElements() {
 			return AbstractPersistenceUnit.this.getXmlClassRefs();
 		}
-		@Override
-		protected XmlJavaClassRef getResourceElement(ClassRef contextElement) {
+		public XmlJavaClassRef extractResourceElement(ClassRef contextElement) {
 			return contextElement.getXmlClassRef();
 		}
 	}
@@ -921,11 +926,11 @@ public abstract class AbstractPersistenceUnit
 	// ********** virtual class refs **********
 
 	public Iterable<ClassRef> getImpliedClassRefs() {
-		return this.impliedClassRefContainer.getContextElements();
+		return this.impliedClassRefContainer;
 	}
 
 	public int getImpliedClassRefsSize() {
-		return this.impliedClassRefContainer.getContextElementsSize();
+		return this.impliedClassRefContainer.size();
 	}
 
 	protected ClassRef buildClassRef(JavaResourceAbstractType jrat) {
@@ -961,11 +966,11 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	protected ContextCollectionContainer<ClassRef, JavaResourceAbstractType> buildImpliedClassRefContainer() {
-		return new ImpliedClassRefContainer();
+		return this.buildVirtualContextCollectionContainer(IMPLIED_CLASS_REFS_COLLECTION, new ImpliedClassRefContainerAdapter());
 	}
 
 	/**
-	 * Virtual class ref container adapter.
+	 * default class ref container adapter
 	 * <p>
 	 * <strong>NB:</strong> The context class ref is matched with a java resource type.
 	 * <p>
@@ -987,23 +992,16 @@ public abstract class AbstractPersistenceUnit
 	 * setting whether the persistence unit excludes unlisted classes); o the
 	 * collection must also be synchronized during <em>update</em>.
 	 */
-	protected class ImpliedClassRefContainer
-		extends ContextCollectionContainer<ClassRef, JavaResourceAbstractType>
+	public class ImpliedClassRefContainerAdapter
+		extends AbstractContainerAdapter<ClassRef, JavaResourceAbstractType>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return IMPLIED_CLASS_REFS_COLLECTION;
-		}
-		@Override
-		protected ClassRef buildContextElement(JavaResourceAbstractType resourceElement) {
+		public ClassRef buildContextElement(JavaResourceAbstractType resourceElement) {
 			return AbstractPersistenceUnit.this.buildClassRef(resourceElement);
 		}
-		@Override
-		protected Iterable<JavaResourceAbstractType> getResourceElements() {
+		public Iterable<JavaResourceAbstractType> getResourceElements() {
 			return AbstractPersistenceUnit.this.getImpliedClassResourceTypes();
 		}
-		@Override
-		protected JavaResourceAbstractType getResourceElement(ClassRef contextElement) {
+		public JavaResourceAbstractType extractResourceElement(ClassRef contextElement) {
 			return contextElement.getJavaResourceType();
 		}
 	}
@@ -1038,11 +1036,11 @@ public abstract class AbstractPersistenceUnit
 	// ********** properties **********
 
 	public ListIterable<Property> getProperties() {
-		return this.propertyContainer.getContextElements();
+		return this.propertyContainer;
 	}
 
 	public int getPropertiesSize() {
-		return this.propertyContainer.getContextElementsSize();
+		return this.propertyContainer.size();
 	}
 
 	public Property getProperty(String propertyName) {
@@ -1138,7 +1136,7 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	public void removeProperty(Property property) {
-		this.removeProperty(this.propertyContainer.indexOfContextElement(property));
+		this.removeProperty(this.propertyContainer.indexOf(property));
 	}
 
 	public void removeProperty(String propertyName) {
@@ -1168,7 +1166,7 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	protected void removeProperty(int index) {
-		Property removedProperty = this.propertyContainer.removeContextElement(index);
+		Property removedProperty = this.propertyContainer.remove(index);
 		this.xmlPersistenceUnit.getProperties().getProperties().remove(index);
 
 		if (this.xmlPersistenceUnit.getProperties().getProperties().isEmpty()) {
@@ -1254,56 +1252,82 @@ public abstract class AbstractPersistenceUnit
 	}
 
 	protected void removeProperty_(Property property) {
-		this.propertyContainer.removeContextElement(property);
+		this.propertyContainer.remove(property);
 		if (property.getName() != null) {
 			this.propertyRemoved(property.getName());
 		}
 	}
 
 	protected ContextListContainer<Property, XmlProperty> buildPropertyContainer() {
-		PropertyContainer container = new PropertyContainer();
-		container.initialize();
-		return container;
+		return new PropertyContainer(PROPERTIES_LIST, new PropertyContainerAdapter());
+		// return this.buildSpecifiedContextListContainer(PROPERTIES_LIST, new PropertyContainerAdapter());
 	}
 
 	/**
-	 * property container
+	 * property container adapter
 	 */
-	protected class PropertyContainer
-		extends ContextListContainer<Property, XmlProperty>
+	public class PropertyContainerAdapter
+		extends AbstractContainerAdapter<Property, XmlProperty>
 	{
+		public Property buildContextElement(XmlProperty resourceElement) {
+			return AbstractPersistenceUnit.this.buildProperty(resourceElement);
+		}
+		public ListIterable<XmlProperty> getResourceElements() {
+			return AbstractPersistenceUnit.this.getXmlProperties();
+		}
+		public XmlProperty extractResourceElement(Property contextElement) {
+			return contextElement.getXmlProperty();
+		}
+	}
+
+	public class PropertyContainer
+		extends SpecifiedContextListContainer<Property, XmlProperty>
+	{
+		public PropertyContainer(String aspectName, Container.Adapter<Property, XmlProperty> adapter) {
+			super(aspectName, adapter);
+		}
 		@Override
-		protected String getContextElementsPropertyName() {
-			return PROPERTIES_LIST;
+		protected Property add(int index, Property element) {
+			super.add(index, element);
+			if (element.getName() != null) {
+				propertyAdded(element.getName(), element.getValue());
+			}
+			return element;
 		}
 		@Override
-		protected Property buildContextElement(XmlProperty resourceElement) {
-			return AbstractPersistenceUnit.this.buildProperty(resourceElement);
+		public void clear() {
+			Object[] temp = this.elements.toArray();
+			super.clear();
+			for (Object element : temp) {
+				this.dispose((Property) element);
+			}
 		}
 		@Override
-		protected ListIterable<XmlProperty> getResourceElements() {
-			return AbstractPersistenceUnit.this.getXmlProperties();
+		public Property remove(int index) {
+			Property element = super.remove(index);
+			this.dispose(element);
+			return element;
 		}
 		@Override
-		protected XmlProperty getResourceElement(Property contextElement) {
-			return contextElement.getXmlProperty();
+		public void remove(Property element) {
+			super.remove(element);
+			this.dispose(element);
 		}
 		@Override
-		protected Property addContextElement_(int index, Property contextElement) {
-			super.addContextElement_(index, contextElement);
-			if (contextElement.getName() != null) {
-				propertyAdded(contextElement.getName(), contextElement.getValue());
+		public void removeAll(Iterable<Property> contextElements) {
+			super.removeAll(contextElements);
+			for (Property element : contextElements) {
+				this.dispose(element);
 			}
-			return contextElement;
 		}
-		@Override
-		protected void disposeElement(Property contextElement) {
-			if (contextElement.getName() != null) {
-				propertyRemoved(contextElement.getName());
+		protected void dispose(Property element) {
+			if (element.getName() != null) {
+				propertyRemoved(element.getName());
 			}
 		}
 	}
 
+
 	// ********** mapping file (orm.xml) persistence unit metadata & defaults **********
 
 	public boolean isXmlMappingMetadataComplete() {
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJarFile.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJarFile.java
index c50e2fad10..d2391c9605 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJarFile.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJarFile.java
@@ -95,11 +95,11 @@ public class GenericJarFile
 	}
 
 	public Iterable<JavaManagedType> getJavaManagedTypes() {
-		return this.javaManagedTypeContainer.getContextElements();
+		return this.javaManagedTypeContainer;
 	}
 
 	public int getJavaManagedTypesSize() {
-		return this.javaManagedTypeContainer.getContextElementsSize();
+		return this.javaManagedTypeContainer.size();
 	}
 
 	protected void syncJavaManagedTypes() {
@@ -111,7 +111,7 @@ public class GenericJarFile
 	}
 
 	protected void removeJavaManagedType(JavaManagedType javaManagedType) {
-		this.javaManagedTypeContainer.removeContextElement(javaManagedType);
+		this.javaManagedTypeContainer.remove(javaManagedType);
 	}
 
 	//only accept types, enums aren't valid for JPA
@@ -154,31 +154,22 @@ public class GenericJarFile
 	}
 
 	protected ContextCollectionContainer<JavaManagedType, JavaResourceType> buildJavaManagedTypeContainer() {
-		JavaManagedTypeContainer container = new JavaManagedTypeContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextCollectionContainer(JAVA_MANAGED_TYPES_COLLECTION, new JavaManagedTypeContainerAdapter());
 	}
 
 	/**
-	 * Java managed type container
+	 * Java managed type container adapter
 	 */
-	protected class JavaManagedTypeContainer
-		extends ContextCollectionContainer<JavaManagedType, JavaResourceType>
+	public class JavaManagedTypeContainerAdapter
+		extends AbstractContainerAdapter<JavaManagedType, JavaResourceType>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return JAVA_MANAGED_TYPES_COLLECTION;
-		}
-		@Override
-		protected JavaManagedType buildContextElement(JavaResourceType resourceElement) {
+		public JavaManagedType buildContextElement(JavaResourceType resourceElement) {
 			return GenericJarFile.this.buildJavaManagedType(resourceElement);
 		}
-		@Override
-		protected Iterable<JavaResourceType> getResourceElements() {
+		public Iterable<JavaResourceType> getResourceElements() {
 			return GenericJarFile.this.getJavaResourceTypes();
 		}
-		@Override
-		protected JavaResourceType getResourceElement(JavaManagedType contextElement) {
+		public JavaResourceType extractResourceElement(JavaManagedType contextElement) {
 			return contextElement.getJavaResourceType();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaJoinTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaJoinTable.java
index b05c9cda90..08a8f5f434 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaJoinTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaJoinTable.java
@@ -17,14 +17,14 @@ import org.eclipse.jpt.common.utility.internal.iterable.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterable;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
 import org.eclipse.jpt.jpa.core.context.Entity;
-import org.eclipse.jpt.jpa.core.context.JpaContextModel;
-import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
-import org.eclipse.jpt.jpa.core.context.SpecifiedPersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
 import org.eclipse.jpt.jpa.core.context.JoinTable;
+import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.NamedColumn;
-import org.eclipse.jpt.jpa.core.context.SpecifiedRelationship;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
+import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
+import org.eclipse.jpt.jpa.core.context.SpecifiedPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.SpecifiedRelationship;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedJoinTable;
@@ -113,11 +113,11 @@ public class GenericJavaJoinTable
 	// ********** specified inverse join columns **********
 
 	public ListIterable<JavaSpecifiedJoinColumn> getSpecifiedInverseJoinColumns() {
-		return this.specifiedInverseJoinColumnContainer.getContextElements();
+		return this.specifiedInverseJoinColumnContainer;
 	}
 
 	public int getSpecifiedInverseJoinColumnsSize() {
-		return this.specifiedInverseJoinColumnContainer.getContextElementsSize();
+		return this.specifiedInverseJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedInverseJoinColumns() {
@@ -125,7 +125,7 @@ public class GenericJavaJoinTable
 	}
 
 	public JavaSpecifiedJoinColumn getSpecifiedInverseJoinColumn(int index) {
-		return this.specifiedInverseJoinColumnContainer.getContextElement(index);
+		return this.specifiedInverseJoinColumnContainer.get(index);
 	}
 
 	public JavaSpecifiedJoinColumn addSpecifiedInverseJoinColumn() {
@@ -138,18 +138,18 @@ public class GenericJavaJoinTable
 	}
 
 	public void removeSpecifiedInverseJoinColumn(SpecifiedJoinColumn joinColumn) {
-		this.removeSpecifiedInverseJoinColumn(this.specifiedInverseJoinColumnContainer.indexOfContextElement((JavaSpecifiedJoinColumn) joinColumn));
+		this.removeSpecifiedInverseJoinColumn(this.specifiedInverseJoinColumnContainer.indexOf((JavaSpecifiedJoinColumn) joinColumn));
 	}
 
 	public void removeSpecifiedInverseJoinColumn(int index) {
 		this.getTableAnnotation().removeInverseJoinColumn(index);
 		this.removeTableAnnotationIfUnset();
-		this.specifiedInverseJoinColumnContainer.removeContextElement(index);
+		this.specifiedInverseJoinColumnContainer.remove(index);
 	}
 
 	public void moveSpecifiedInverseJoinColumn(int targetIndex, int sourceIndex) {
 		this.getTableAnnotation().moveInverseJoinColumn(targetIndex, sourceIndex);
-		this.specifiedInverseJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedInverseJoinColumnContainer.move(targetIndex, sourceIndex);
 	}
 
 	public void clearSpecifiedInverseJoinColumns() {
@@ -158,7 +158,7 @@ public class GenericJavaJoinTable
 			this.getTableAnnotation().removeInverseJoinColumn(index);
 		}
 		this.removeTableAnnotationIfUnset();
-		this.specifiedInverseJoinColumnContainer.clearContextList();
+		this.specifiedInverseJoinColumnContainer.clear();
 	}
 
 	protected void syncSpecifiedInverseJoinColumns() {
@@ -169,26 +169,23 @@ public class GenericJavaJoinTable
 		return this.getTableAnnotation().getInverseJoinColumns();
 	}
 
+	protected ContextListContainer<JavaSpecifiedJoinColumn, JoinColumnAnnotation> buildSpecifiedInverseJoinColumnContainer() {
+		return this.buildSpecifiedContextListContainer(SPECIFIED_INVERSE_JOIN_COLUMNS_LIST, new SpecifiedInverseJoinColumnContainerAdapter());
+	}
+
 	/**
-	 * inverse join column container
+	 * specified inverse join column container adapter
 	 */
-	public class SpecifiedInverseJoinColumnContainer
-		extends ContextListContainer<JavaSpecifiedJoinColumn, JoinColumnAnnotation>
+	public class SpecifiedInverseJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<JavaSpecifiedJoinColumn, JoinColumnAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_INVERSE_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected JavaSpecifiedJoinColumn buildContextElement(JoinColumnAnnotation resourceElement) {
+		public JavaSpecifiedJoinColumn buildContextElement(JoinColumnAnnotation resourceElement) {
 			return GenericJavaJoinTable.this.buildInverseJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<JoinColumnAnnotation> getResourceElements() {
+		public ListIterable<JoinColumnAnnotation> getResourceElements() {
 			return GenericJavaJoinTable.this.getInverseJoinColumnAnnotations();
 		}
-		@Override
-		protected JoinColumnAnnotation getResourceElement(JavaSpecifiedJoinColumn contextElement) {
+		public JoinColumnAnnotation extractResourceElement(JavaSpecifiedJoinColumn contextElement) {
 			return (JoinColumnAnnotation) contextElement.getColumnAnnotation();
 		}
 	}
@@ -197,11 +194,6 @@ public class GenericJavaJoinTable
 		return new InverseJoinColumnParentAdapter();
 	}
 
-	protected ContextListContainer<JavaSpecifiedJoinColumn, JoinColumnAnnotation> buildSpecifiedInverseJoinColumnContainer() {
-		SpecifiedInverseJoinColumnContainer container = new SpecifiedInverseJoinColumnContainer();
-		container.initialize();
-		return container;
-	}
 
 	// ********** default inverse join column **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaQueryContainer.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaQueryContainer.java
index 017c6a8a85..1fa00c3ff6 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaQueryContainer.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaQueryContainer.java
@@ -84,11 +84,11 @@ public class GenericJavaQueryContainer
 
 
 	public ListIterable<JavaNamedQuery> getNamedQueries() {
-		return this.namedQueryContainer.getContextElements();
+		return this.namedQueryContainer;
 	}
 
 	public int getNamedQueriesSize() {
-		return this.namedQueryContainer.getContextElementsSize();
+		return this.namedQueryContainer.size();
 	}
 
 	public JavaNamedQuery addNamedQuery() {
@@ -105,17 +105,17 @@ public class GenericJavaQueryContainer
 	}
 
 	public void removeNamedQuery(NamedQuery namedQuery) {
-		this.removeNamedQuery(this.namedQueryContainer.indexOfContextElement((JavaNamedQuery) namedQuery));
+		this.removeNamedQuery(this.namedQueryContainer.indexOf((JavaNamedQuery) namedQuery));
 	}
 
 	public void removeNamedQuery(int index) {
 		this.parent.getResourceAnnotatedElement().removeAnnotation(index, NamedQueryAnnotation.ANNOTATION_NAME);
-		this.namedQueryContainer.removeContextElement(index);
+		this.namedQueryContainer.remove(index);
 	}
 
 	public void moveNamedQuery(int targetIndex, int sourceIndex) {
 		this.parent.getResourceAnnotatedElement().moveAnnotation(targetIndex, sourceIndex, NamedQueryAnnotation.ANNOTATION_NAME);
-		this.namedQueryContainer.moveContextElement(targetIndex, sourceIndex);
+		this.namedQueryContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected JavaNamedQuery buildNamedQuery(NamedQueryAnnotation namedQueryAnnotation) {
@@ -135,31 +135,22 @@ public class GenericJavaQueryContainer
 	}
 
 	protected ContextListContainer<JavaNamedQuery, NamedQueryAnnotation> buildNamedQueryContainer() {
-		NamedQueryContainer container = new NamedQueryContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(NAMED_QUERIES_LIST, new NamedQueryContainerAdapter());
 	}
 
 	/**
-	 * named query container
+	 * named query container adapter
 	 */
-	protected class NamedQueryContainer
-		extends ContextListContainer<JavaNamedQuery, NamedQueryAnnotation>
+	public class NamedQueryContainerAdapter
+		extends AbstractContainerAdapter<JavaNamedQuery, NamedQueryAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return NAMED_QUERIES_LIST;
-		}
-		@Override
-		protected JavaNamedQuery buildContextElement(NamedQueryAnnotation resourceElement) {
+		public JavaNamedQuery buildContextElement(NamedQueryAnnotation resourceElement) {
 			return GenericJavaQueryContainer.this.buildNamedQuery(resourceElement);
 		}
-		@Override
-		protected ListIterable<NamedQueryAnnotation> getResourceElements() {
+		public ListIterable<NamedQueryAnnotation> getResourceElements() {
 			return GenericJavaQueryContainer.this.getNamedQueryAnnotations();
 		}
-		@Override
-		protected NamedQueryAnnotation getResourceElement(JavaNamedQuery contextElement) {
+		public NamedQueryAnnotation extractResourceElement(JavaNamedQuery contextElement) {
 			return contextElement.getQueryAnnotation();
 		}
 	}
@@ -168,11 +159,11 @@ public class GenericJavaQueryContainer
 	// ********** named native queries **********
 
 	public ListIterable<JavaNamedNativeQuery> getNamedNativeQueries() {
-		return this.namedNativeQueryContainer.getContextElements();
+		return this.namedNativeQueryContainer;
 	}
 
 	public int getNamedNativeQueriesSize() {
-		return this.namedNativeQueryContainer.getContextElementsSize();
+		return this.namedNativeQueryContainer.size();
 	}
 
 	public JavaNamedNativeQuery addNamedNativeQuery() {
@@ -189,17 +180,17 @@ public class GenericJavaQueryContainer
 	}
 
 	public void removeNamedNativeQuery(NamedNativeQuery namedNativeQuery) {
-		this.removeNamedNativeQuery(this.namedNativeQueryContainer.indexOfContextElement((JavaNamedNativeQuery) namedNativeQuery));
+		this.removeNamedNativeQuery(this.namedNativeQueryContainer.indexOf((JavaNamedNativeQuery) namedNativeQuery));
 	}
 
 	public void removeNamedNativeQuery(int index) {
 		this.parent.getResourceAnnotatedElement().removeAnnotation(index, NamedNativeQueryAnnotation.ANNOTATION_NAME);
-		this.namedNativeQueryContainer.removeContextElement(index);
+		this.namedNativeQueryContainer.remove(index);
 	}
 
 	public void moveNamedNativeQuery(int targetIndex, int sourceIndex) {
 		this.parent.getResourceAnnotatedElement().moveAnnotation(targetIndex, sourceIndex, NamedNativeQueryAnnotation.ANNOTATION_NAME);
-		this.namedNativeQueryContainer.moveContextElement(targetIndex, sourceIndex);
+		this.namedNativeQueryContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected JavaNamedNativeQuery buildNamedNativeQuery(NamedNativeQueryAnnotation namedNativeQueryAnnotation) {
@@ -219,31 +210,22 @@ public class GenericJavaQueryContainer
 	}
 
 	protected ContextListContainer<JavaNamedNativeQuery, NamedNativeQueryAnnotation> buildNamedNativeQueryContainer() {
-		NamedNativeQueryContainer container = new NamedNativeQueryContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(NAMED_NATIVE_QUERIES_LIST, new NamedNativeQueryContainerAdapter());
 	}
 
 	/**
-	 * named query container
+	 * named native query container adapter
 	 */
-	protected class NamedNativeQueryContainer
-		extends ContextListContainer<JavaNamedNativeQuery, NamedNativeQueryAnnotation>
+	public class NamedNativeQueryContainerAdapter
+		extends AbstractContainerAdapter<JavaNamedNativeQuery, NamedNativeQueryAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return NAMED_NATIVE_QUERIES_LIST;
-		}
-		@Override
-		protected JavaNamedNativeQuery buildContextElement(NamedNativeQueryAnnotation resourceElement) {
+		public JavaNamedNativeQuery buildContextElement(NamedNativeQueryAnnotation resourceElement) {
 			return GenericJavaQueryContainer.this.buildNamedNativeQuery(resourceElement);
 		}
-		@Override
-		protected ListIterable<NamedNativeQueryAnnotation> getResourceElements() {
+		public ListIterable<NamedNativeQueryAnnotation> getResourceElements() {
 			return GenericJavaQueryContainer.this.getNamedNativeQueryAnnotations();
 		}
-		@Override
-		protected NamedNativeQueryAnnotation getResourceElement(JavaNamedNativeQuery contextElement) {
+		public NamedNativeQueryAnnotation extractResourceElement(JavaNamedNativeQuery contextElement) {
 			return contextElement.getQueryAnnotation();
 		}
 	}
@@ -251,11 +233,11 @@ public class GenericJavaQueryContainer
 	// ********** named stored procedure queries **********
 
 	public ListIterable<JavaNamedStoredProcedureQuery2_1> getNamedStoredProcedureQueries() {
-		return this.namedStoredProcedureQueryContainer.getContextElements();
+		return this.namedStoredProcedureQueryContainer;
 	}
 
 	public int getNamedStoredProcedureQueriesSize() {
-		return this.namedStoredProcedureQueryContainer.getContextElementsSize();
+		return this.namedStoredProcedureQueryContainer.size();
 	}
 
 	public JavaNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery() {
@@ -272,17 +254,17 @@ public class GenericJavaQueryContainer
 	}
 
 	public void removeNamedStoredProcedureQuery(NamedStoredProcedureQuery2_1 namedStoredProcedureQuery) {
-		this.removeNamedStoredProcedureQuery(this.namedStoredProcedureQueryContainer.indexOfContextElement((JavaNamedStoredProcedureQuery2_1) namedStoredProcedureQuery));
+		this.removeNamedStoredProcedureQuery(this.namedStoredProcedureQueryContainer.indexOf((JavaNamedStoredProcedureQuery2_1) namedStoredProcedureQuery));
 	}
 
 	public void removeNamedStoredProcedureQuery(int index) {
 		this.parent.getResourceAnnotatedElement().removeAnnotation(index, NamedStoredProcedureQueryAnnotation2_1.ANNOTATION_NAME);
-		this.namedStoredProcedureQueryContainer.removeContextElement(index);
+		this.namedStoredProcedureQueryContainer.remove(index);
 	}
 
 	public void moveNamedStoredProcedureQuery(int targetIndex, int sourceIndex) {
 		this.parent.getResourceAnnotatedElement().moveAnnotation(targetIndex, sourceIndex, NamedStoredProcedureQueryAnnotation2_1.ANNOTATION_NAME);
-		this.namedStoredProcedureQueryContainer.moveContextElement(targetIndex, sourceIndex);
+		this.namedStoredProcedureQueryContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected JavaNamedStoredProcedureQuery2_1 buildNamedStoredProcedureQuery(NamedStoredProcedureQueryAnnotation2_1 namedStoredProcedureQueryAnnotation) {
@@ -302,31 +284,22 @@ public class GenericJavaQueryContainer
 	}
 
 	protected ContextListContainer<JavaNamedStoredProcedureQuery2_1, NamedStoredProcedureQueryAnnotation2_1> buildNamedStoredProcedureQueryContainer() {
-		NamedStoredProcedureQueryContainer container = new NamedStoredProcedureQueryContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(NAMED_STORED_PROCEDURE_QUERIES_LIST, new NamedStoredProcedureQueryContainerAdapter());
 	}
 
 	/**
-	 * named query container
+	 * named stored procedure query container adapter
 	 */
-	protected class NamedStoredProcedureQueryContainer
-		extends ContextListContainer<JavaNamedStoredProcedureQuery2_1, NamedStoredProcedureQueryAnnotation2_1>
+	public class NamedStoredProcedureQueryContainerAdapter
+		extends AbstractContainerAdapter<JavaNamedStoredProcedureQuery2_1, NamedStoredProcedureQueryAnnotation2_1>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return NAMED_STORED_PROCEDURE_QUERIES_LIST;
-		}
-		@Override
-		protected JavaNamedStoredProcedureQuery2_1 buildContextElement(NamedStoredProcedureQueryAnnotation2_1 resourceElement) {
+		public JavaNamedStoredProcedureQuery2_1 buildContextElement(NamedStoredProcedureQueryAnnotation2_1 resourceElement) {
 			return GenericJavaQueryContainer.this.buildNamedStoredProcedureQuery(resourceElement);
 		}
-		@Override
-		protected ListIterable<NamedStoredProcedureQueryAnnotation2_1> getResourceElements() {
+		public ListIterable<NamedStoredProcedureQueryAnnotation2_1> getResourceElements() {
 			return GenericJavaQueryContainer.this.getNamedStoredProcedureQueryAnnotations();
 		}
-		@Override
-		protected NamedStoredProcedureQueryAnnotation2_1 getResourceElement(JavaNamedStoredProcedureQuery2_1 contextElement) {
+		public NamedStoredProcedureQueryAnnotation2_1 extractResourceElement(JavaNamedStoredProcedureQuery2_1 contextElement) {
 			return contextElement.getQueryAnnotation();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaReferenceTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaReferenceTable.java
index b93e5dd94d..ef4d395bd6 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaReferenceTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaReferenceTable.java
@@ -13,10 +13,10 @@ import java.util.List;
 import org.eclipse.jpt.common.utility.internal.iterable.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterable;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
-import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
-import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
+import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.ReferenceTable;
+import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.Table;
 import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedReferenceTable;
@@ -82,11 +82,11 @@ public abstract class GenericJavaReferenceTable<P extends JpaContextModel, PA ex
 	// ********** specified join columns **********
 
 	public ListIterable<JavaSpecifiedJoinColumn> getSpecifiedJoinColumns() {
-		return this.specifiedJoinColumnContainer.getContextElements();
+		return this.specifiedJoinColumnContainer;
 	}
 
 	public int getSpecifiedJoinColumnsSize() {
-		return this.specifiedJoinColumnContainer.getContextElementsSize();
+		return this.specifiedJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedJoinColumns() {
@@ -94,7 +94,7 @@ public abstract class GenericJavaReferenceTable<P extends JpaContextModel, PA ex
 	}
 
 	public JavaSpecifiedJoinColumn getSpecifiedJoinColumn(int index) {
-		return this.specifiedJoinColumnContainer.getContextElement(index);
+		return this.specifiedJoinColumnContainer.get(index);
 	}
 
 	public JavaSpecifiedJoinColumn addSpecifiedJoinColumn() {
@@ -107,18 +107,18 @@ public abstract class GenericJavaReferenceTable<P extends JpaContextModel, PA ex
 	}
 
 	public void removeSpecifiedJoinColumn(SpecifiedJoinColumn joinColumn) {
-		this.removeSpecifiedJoinColumn(this.specifiedJoinColumnContainer.indexOfContextElement((JavaSpecifiedJoinColumn) joinColumn));
+		this.removeSpecifiedJoinColumn(this.specifiedJoinColumnContainer.indexOf((JavaSpecifiedJoinColumn) joinColumn));
 	}
 
 	public void removeSpecifiedJoinColumn(int index) {
 		this.getTableAnnotation().removeJoinColumn(index);
 		this.removeTableAnnotationIfUnset();
-		this.specifiedJoinColumnContainer.removeContextElement(index);
+		this.specifiedJoinColumnContainer.remove(index);
 	}
 
 	public void moveSpecifiedJoinColumn(int targetIndex, int sourceIndex) {
 		this.getTableAnnotation().moveJoinColumn(targetIndex, sourceIndex);
-		this.specifiedJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedJoinColumnContainer.move(targetIndex, sourceIndex);
 	}
 
 	public void clearSpecifiedJoinColumns() {
@@ -127,7 +127,7 @@ public abstract class GenericJavaReferenceTable<P extends JpaContextModel, PA ex
 			this.getTableAnnotation().removeJoinColumn(index);
 		}
 		this.removeTableAnnotationIfUnset();
-		this.specifiedJoinColumnContainer.clearContextList();
+		this.specifiedJoinColumnContainer.clear();
 	}
 
 	protected void syncSpecifiedJoinColumns() {
@@ -138,38 +138,29 @@ public abstract class GenericJavaReferenceTable<P extends JpaContextModel, PA ex
 		return this.getTableAnnotation().getJoinColumns();
 	}
 
+	protected ContextListContainer<JavaSpecifiedJoinColumn, JoinColumnAnnotation> buildSpecifiedJoinColumnContainer(){
+		return this.buildSpecifiedContextListContainer(SPECIFIED_JOIN_COLUMNS_LIST, new SpecifiedJoinColumnContainerAdapter());
+	}
 
 	/**
-	 * join column container
+	 * specified join column container adapter
 	 */
-	protected class SpecifiedJoinColumnContainer
-		extends ContextListContainer<JavaSpecifiedJoinColumn, JoinColumnAnnotation>
+	public class SpecifiedJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<JavaSpecifiedJoinColumn, JoinColumnAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected JavaSpecifiedJoinColumn buildContextElement(JoinColumnAnnotation resourceElement) {
+		public JavaSpecifiedJoinColumn buildContextElement(JoinColumnAnnotation resourceElement) {
 			return GenericJavaReferenceTable.this.buildJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<JoinColumnAnnotation> getResourceElements() {
+		public ListIterable<JoinColumnAnnotation> getResourceElements() {
 			return GenericJavaReferenceTable.this.getJoinColumnAnnotations();
 		}
-		@Override
-		protected JoinColumnAnnotation getResourceElement(JavaSpecifiedJoinColumn contextElement) {
+		public JoinColumnAnnotation extractResourceElement(JavaSpecifiedJoinColumn contextElement) {
 			return (JoinColumnAnnotation) contextElement.getColumnAnnotation();
 		}
 	}
 
 	protected abstract JoinColumn.ParentAdapter buildJoinColumnParentAdapter();
 
-	protected ContextListContainer<JavaSpecifiedJoinColumn, JoinColumnAnnotation> buildSpecifiedJoinColumnContainer(){
-		SpecifiedJoinColumnContainer container = new SpecifiedJoinColumnContainer();
-		container.initialize();
-		return container;
-	}
 
 	// ********** default join column **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaSecondaryTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaSecondaryTable.java
index 8ce7ad8f21..64183cafc1 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaSecondaryTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaSecondaryTable.java
@@ -112,7 +112,7 @@ public class GenericJavaSecondaryTable
 
 
 	public ListIterable<JavaSpecifiedPrimaryKeyJoinColumn> getSpecifiedPrimaryKeyJoinColumns() {
-		return this.specifiedPrimaryKeyJoinColumnContainer.getContextElements();
+		return this.specifiedPrimaryKeyJoinColumnContainer;
 	}
 
 	public JavaSpecifiedPrimaryKeyJoinColumn getSpecifiedPrimaryKeyJoinColumn(int index) {
@@ -120,7 +120,7 @@ public class GenericJavaSecondaryTable
 	}
 
 	public int getSpecifiedPrimaryKeyJoinColumnsSize() {
-		return this.specifiedPrimaryKeyJoinColumnContainer.getContextElementsSize();
+		return this.specifiedPrimaryKeyJoinColumnContainer.size();
 	}
 
 	protected boolean hasSpecifiedPrimaryKeyJoinColumns() {
@@ -137,13 +137,13 @@ public class GenericJavaSecondaryTable
 	}
 
 	public void removeSpecifiedPrimaryKeyJoinColumn(SpecifiedPrimaryKeyJoinColumn joinColumn) {
-		this.removeSpecifiedPrimaryKeyJoinColumn(this.specifiedPrimaryKeyJoinColumnContainer.indexOfContextElement((JavaSpecifiedPrimaryKeyJoinColumn) joinColumn));
+		this.removeSpecifiedPrimaryKeyJoinColumn(this.specifiedPrimaryKeyJoinColumnContainer.indexOf((JavaSpecifiedPrimaryKeyJoinColumn) joinColumn));
 	}
 
 	public void removeSpecifiedPrimaryKeyJoinColumn(int index) {
 		this.tableAnnotation.removePkJoinColumn(index);
 		this.removeTableAnnotationIfUnset();
-		this.specifiedPrimaryKeyJoinColumnContainer.removeContextElement(index);
+		this.specifiedPrimaryKeyJoinColumnContainer.remove(index);
 	}
 
 	//default PK join column will get set in the update
@@ -165,12 +165,12 @@ public class GenericJavaSecondaryTable
 			this.tableAnnotation.removePkJoinColumn(index);
 		}
 		this.removeTableAnnotationIfUnset();
-		this.specifiedPrimaryKeyJoinColumnContainer.clearContextList();
+		this.specifiedPrimaryKeyJoinColumnContainer.clear();
 	}
 
 	public void moveSpecifiedPrimaryKeyJoinColumn(int targetIndex, int sourceIndex) {
 		this.tableAnnotation.movePkJoinColumn(targetIndex, sourceIndex);
-		this.specifiedPrimaryKeyJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedPrimaryKeyJoinColumnContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected void syncSpecifiedPrimaryKeyJoinColumns() {
@@ -181,26 +181,23 @@ public class GenericJavaSecondaryTable
 		return this.tableAnnotation.getPkJoinColumns();
 	}
 
+	protected ContextListContainer<JavaSpecifiedPrimaryKeyJoinColumn, PrimaryKeyJoinColumnAnnotation> buildSpecifiedPrimaryKeyJoinColumnContainer() {
+		return this.buildSpecifiedContextListContainer(SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST, new SpecifiedPrimaryKeyJoinColumnContainerAdapter());
+	}
+
 	/**
-	 * specified primary key join column container
+	 * specified primary key join column container adapter
 	 */
-	public class SpecifiedPrimaryKeyJoinColumnContainer
-		extends ContextListContainer<JavaSpecifiedPrimaryKeyJoinColumn, PrimaryKeyJoinColumnAnnotation>
+	public class SpecifiedPrimaryKeyJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<JavaSpecifiedPrimaryKeyJoinColumn, PrimaryKeyJoinColumnAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected JavaSpecifiedPrimaryKeyJoinColumn buildContextElement(PrimaryKeyJoinColumnAnnotation resourceElement) {
+		public JavaSpecifiedPrimaryKeyJoinColumn buildContextElement(PrimaryKeyJoinColumnAnnotation resourceElement) {
 			return GenericJavaSecondaryTable.this.buildPrimaryKeyJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<PrimaryKeyJoinColumnAnnotation> getResourceElements() {
+		public ListIterable<PrimaryKeyJoinColumnAnnotation> getResourceElements() {
 			return GenericJavaSecondaryTable.this.getPrimaryKeyJoinColumnAnnotations();
 		}
-		@Override
-		protected PrimaryKeyJoinColumnAnnotation getResourceElement(JavaSpecifiedPrimaryKeyJoinColumn contextElement) {
+		public PrimaryKeyJoinColumnAnnotation extractResourceElement(JavaSpecifiedPrimaryKeyJoinColumn contextElement) {
 			return contextElement.getColumnAnnotation();
 		}
 	}
@@ -209,11 +206,6 @@ public class GenericJavaSecondaryTable
 		return new PrimaryKeyJoinColumnParentAdapter();
 	}
 
-	protected ContextListContainer<JavaSpecifiedPrimaryKeyJoinColumn, PrimaryKeyJoinColumnAnnotation> buildSpecifiedPrimaryKeyJoinColumnContainer() {
-		SpecifiedPrimaryKeyJoinColumnContainer container = new SpecifiedPrimaryKeyJoinColumnContainer();
-		container.initialize();
-		return container;
-	}
 
 	// ********** default primary key join column **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaTableGenerator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaTableGenerator.java
index 5a73fc1635..2100c540c6 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaTableGenerator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaTableGenerator.java
@@ -19,12 +19,11 @@ import org.eclipse.jpt.common.utility.internal.iterable.TransformationIterable;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
 import org.eclipse.jpt.common.utility.predicate.Predicate;
 import org.eclipse.jpt.jpa.core.context.DbGenerator;
-import org.eclipse.jpt.jpa.core.context.JpaContextModel;
-import org.eclipse.jpt.jpa.core.context.TableGenerator;
 import org.eclipse.jpt.jpa.core.context.SpecifiedUniqueConstraint;
+import org.eclipse.jpt.jpa.core.context.TableGenerator;
 import org.eclipse.jpt.jpa.core.context.java.JavaGeneratorContainer;
-import org.eclipse.jpt.jpa.core.context.java.JavaTableGenerator;
 import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedUniqueConstraint;
+import org.eclipse.jpt.jpa.core.context.java.JavaTableGenerator;
 import org.eclipse.jpt.jpa.core.context.orm.EntityMappings;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaDbGenerator;
 import org.eclipse.jpt.jpa.core.resource.java.TableGeneratorAnnotation;
@@ -336,15 +335,15 @@ public class GenericJavaTableGenerator
 
 	// ********** unique constraints **********
 	public ListIterable<JavaSpecifiedUniqueConstraint> getUniqueConstraints() {
-		return this.uniqueConstraintContainer.getContextElements();
+		return this.uniqueConstraintContainer;
 	}
 
 	public int getUniqueConstraintsSize() {
-		return this.uniqueConstraintContainer.getContextElementsSize();
+		return this.uniqueConstraintContainer.size();
 	}
 
 	public JavaSpecifiedUniqueConstraint getUniqueConstraint(int index) {
-		return this.uniqueConstraintContainer.getContextElement(index);
+		return this.uniqueConstraintContainer.get(index);
 	}
 
 	public JavaSpecifiedUniqueConstraint addUniqueConstraint() {
@@ -358,16 +357,16 @@ public class GenericJavaTableGenerator
 
 	public void removeUniqueConstraint(int index) {
 		this.getGeneratorAnnotation().removeUniqueConstraint(index);
-		this.uniqueConstraintContainer.removeContextElement(index);
+		this.uniqueConstraintContainer.remove(index);
 	}
 
 	public void removeUniqueConstraint(SpecifiedUniqueConstraint uniqueConstraint) {
-		this.removeUniqueConstraint(this.uniqueConstraintContainer.indexOfContextElement((JavaSpecifiedUniqueConstraint) uniqueConstraint));
+		this.removeUniqueConstraint(this.uniqueConstraintContainer.indexOf((JavaSpecifiedUniqueConstraint) uniqueConstraint));
 	}
 
 	public void moveUniqueConstraint(int targetIndex, int sourceIndex) {
 		this.getGeneratorAnnotation().moveUniqueConstraint(targetIndex, sourceIndex);
-		this.uniqueConstraintContainer.moveContextElement(targetIndex, sourceIndex);
+		this.uniqueConstraintContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected void syncUniqueConstraints() {
@@ -387,31 +386,22 @@ public class GenericJavaTableGenerator
 	}
 
 	protected ContextListContainer<JavaSpecifiedUniqueConstraint, UniqueConstraintAnnotation> buildUniqueConstraintContainer() {
-		UniqueConstraintContainer container = new UniqueConstraintContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(UNIQUE_CONSTRAINTS_LIST, new UniqueConstraintContainerAdapter());
 	}
 
 	/**
-	 * unique constraint container
+	 * unique constraint container adapter
 	 */
-	protected class UniqueConstraintContainer
-		extends ContextListContainer<JavaSpecifiedUniqueConstraint, UniqueConstraintAnnotation>
+	public class UniqueConstraintContainerAdapter
+		extends AbstractContainerAdapter<JavaSpecifiedUniqueConstraint, UniqueConstraintAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return UNIQUE_CONSTRAINTS_LIST;
-		}
-		@Override
-		protected JavaSpecifiedUniqueConstraint buildContextElement(UniqueConstraintAnnotation resourceElement) {
+		public JavaSpecifiedUniqueConstraint buildContextElement(UniqueConstraintAnnotation resourceElement) {
 			return GenericJavaTableGenerator.this.buildUniqueConstraint(resourceElement);
 		}
-		@Override
-		protected ListIterable<UniqueConstraintAnnotation> getResourceElements() {
+		public ListIterable<UniqueConstraintAnnotation> getResourceElements() {
 			return GenericJavaTableGenerator.this.getUniqueConstraintAnnotations();
 		}
-		@Override
-		protected UniqueConstraintAnnotation getResourceElement(JavaSpecifiedUniqueConstraint contextElement) {
+		public UniqueConstraintAnnotation extractResourceElement(JavaSpecifiedUniqueConstraint contextElement) {
 			return contextElement.getUniqueConstraintAnnotation();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.java
index 2a28f28fc0..ceab79d8ea 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.java
@@ -16,8 +16,8 @@ import org.eclipse.jpt.common.utility.internal.iterable.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.SuperListIterableWrapper;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
-import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.BaseColumn;
+import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
 import org.eclipse.jpt.jpa.core.context.JoinColumnRelationship;
 import org.eclipse.jpt.jpa.core.context.JoinColumnRelationshipStrategy;
@@ -77,11 +77,11 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 	// ********** specified join columns **********
 
 	public ListIterable<VirtualJoinColumn> getSpecifiedJoinColumns() {
-		return this.specifiedJoinColumnContainer.getContextElements();
+		return this.specifiedJoinColumnContainer;
 	}
 
 	public int getSpecifiedJoinColumnsSize() {
-		return this.specifiedJoinColumnContainer.getContextElementsSize();
+		return this.specifiedJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedJoinColumns() {
@@ -89,7 +89,7 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 	}
 
 	public VirtualJoinColumn getSpecifiedJoinColumn(int index) {
-		return this.specifiedJoinColumnContainer.getContextElement(index);
+		return this.specifiedJoinColumnContainer.get(index);
 	}
 
 	protected void updateSpecifiedJoinColumns() {
@@ -103,26 +103,23 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 				new SuperListIterableWrapper<JoinColumn>(overriddenStrategy.getSpecifiedJoinColumns());
 	}
 
+	protected ContextListContainer<VirtualJoinColumn, JoinColumn> buildSpecifiedJoinColumnContainer(){
+		return this.buildVirtualContextListContainer(SPECIFIED_JOIN_COLUMNS_LIST, new SpecifiedJoinColumnContainerAdapter());
+	}
+
 	/**
-	 * specified join column container
+	 * specified join column container adapter
 	 */
-	protected class SpecifiedJoinColumnContainer
-		extends ContextListContainer<VirtualJoinColumn, JoinColumn>
+	public class SpecifiedJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<VirtualJoinColumn, JoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected VirtualJoinColumn buildContextElement(JoinColumn resourceElement) {
+		public VirtualJoinColumn buildContextElement(JoinColumn resourceElement) {
 			return GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.buildJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<JoinColumn> getResourceElements() {
+		public ListIterable<JoinColumn> getResourceElements() {
 			return GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.getOverriddenSpecifiedJoinColumns();
 		}
-		@Override
-		protected JoinColumn getResourceElement(VirtualJoinColumn contextElement) {
+		public JoinColumn extractResourceElement(VirtualJoinColumn contextElement) {
 			return contextElement.getOverriddenColumn();
 		}
 	}
@@ -131,10 +128,6 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 		return new JoinColumnParentAdapter();
 	}
 
-	protected ContextListContainer<VirtualJoinColumn, JoinColumn> buildSpecifiedJoinColumnContainer(){
-		return new SpecifiedJoinColumnContainer();
-	}
-
 
 	// ********** default join column **********
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmJoinTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmJoinTable.java
index a3f149b49f..8798f86961 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmJoinTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmJoinTable.java
@@ -18,14 +18,14 @@ import org.eclipse.jpt.common.utility.internal.iterable.IterableTools;
 import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterable;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
 import org.eclipse.jpt.jpa.core.context.Entity;
-import org.eclipse.jpt.jpa.core.context.JpaContextModel;
-import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
-import org.eclipse.jpt.jpa.core.context.SpecifiedPersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
 import org.eclipse.jpt.jpa.core.context.JoinTable;
+import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.NamedColumn;
-import org.eclipse.jpt.jpa.core.context.SpecifiedRelationship;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
+import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
+import org.eclipse.jpt.jpa.core.context.SpecifiedPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.SpecifiedRelationship;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedJoinTable;
@@ -117,11 +117,11 @@ public class GenericOrmJoinTable
 	// ********** specified inverse join columns **********
 
 	public ListIterable<OrmSpecifiedJoinColumn> getSpecifiedInverseJoinColumns() {
-		return this.specifiedInverseJoinColumnContainer.getContextElements();
+		return this.specifiedInverseJoinColumnContainer;
 	}
 
 	public int getSpecifiedInverseJoinColumnsSize() {
-		return this.specifiedInverseJoinColumnContainer.getContextElementsSize();
+		return this.specifiedInverseJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedInverseJoinColumns() {
@@ -129,7 +129,7 @@ public class GenericOrmJoinTable
 	}
 
 	public OrmSpecifiedJoinColumn getSpecifiedInverseJoinColumn(int index) {
-		return this.specifiedInverseJoinColumnContainer.getContextElement(index);
+		return this.specifiedInverseJoinColumnContainer.get(index);
 	}
 
 	public OrmSpecifiedJoinColumn addSpecifiedInverseJoinColumn() {
@@ -145,22 +145,22 @@ public class GenericOrmJoinTable
 	}
 
 	public void removeSpecifiedInverseJoinColumn(SpecifiedJoinColumn joinColumn) {
-		this.removeSpecifiedInverseJoinColumn(this.specifiedInverseJoinColumnContainer.indexOfContextElement((OrmSpecifiedJoinColumn) joinColumn));
+		this.removeSpecifiedInverseJoinColumn(this.specifiedInverseJoinColumnContainer.indexOf((OrmSpecifiedJoinColumn) joinColumn));
 	}
 
 	public void removeSpecifiedInverseJoinColumn(int index) {
-		this.specifiedInverseJoinColumnContainer.removeContextElement(index);
+		this.specifiedInverseJoinColumnContainer.remove(index);
 		this.getXmlTable().getInverseJoinColumns().remove(index);
 		this.removeXmlTableIfUnset();
 	}
 
 	public void moveSpecifiedInverseJoinColumn(int targetIndex, int sourceIndex) {
-		this.specifiedInverseJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedInverseJoinColumnContainer.move(targetIndex, sourceIndex);
 		this.getXmlTable().getInverseJoinColumns().move(targetIndex, sourceIndex);
 	}
 
 	public void clearSpecifiedInverseJoinColumns() {
-		this.specifiedInverseJoinColumnContainer.clearContextList();
+		this.specifiedInverseJoinColumnContainer.clear();
 		this.getXmlTable().getInverseJoinColumns().clear();
 	}
 
@@ -177,31 +177,22 @@ public class GenericOrmJoinTable
 	}
 
 	protected ContextListContainer<OrmSpecifiedJoinColumn, XmlJoinColumn> buildSpecifiedInverseJoinColumnContainer() {
-		SpecifiedInverseJoinColumnContainer container = new SpecifiedInverseJoinColumnContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_INVERSE_JOIN_COLUMNS_LIST, new SpecifiedInverseJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified inverse join column container
+	 * specified inverse join column container adapter
 	 */
-	protected class SpecifiedInverseJoinColumnContainer
-		extends ContextListContainer<OrmSpecifiedJoinColumn, XmlJoinColumn>
+	public class SpecifiedInverseJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<OrmSpecifiedJoinColumn, XmlJoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_INVERSE_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected OrmSpecifiedJoinColumn buildContextElement(XmlJoinColumn resourceElement) {
+		public OrmSpecifiedJoinColumn buildContextElement(XmlJoinColumn resourceElement) {
 			return GenericOrmJoinTable.this.buildInverseJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlJoinColumn> getResourceElements() {
+		public ListIterable<XmlJoinColumn> getResourceElements() {
 			return GenericOrmJoinTable.this.getXmlInverseJoinColumns();
 		}
-		@Override
-		protected XmlJoinColumn getResourceElement(OrmSpecifiedJoinColumn contextElement) {
+		public XmlJoinColumn extractResourceElement(OrmSpecifiedJoinColumn contextElement) {
 			return contextElement.getXmlColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmQueryContainer.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmQueryContainer.java
index 405261fe01..e049b69759 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmQueryContainer.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmQueryContainer.java
@@ -89,11 +89,11 @@ public class GenericOrmQueryContainer
 	// ********** named queries **********
 
 	public ListIterable<OrmNamedQuery> getNamedQueries() {
-		return this.namedQueryContainer.getContextElements();
+		return this.namedQueryContainer;
 	}
 
 	public int getNamedQueriesSize() {
-		return this.namedQueryContainer.getContextElementsSize();
+		return this.namedQueryContainer.size();
 	}
 
 	public OrmNamedQuery addNamedQuery() {
@@ -112,16 +112,16 @@ public class GenericOrmQueryContainer
 	}
 
 	public void removeNamedQuery(NamedQuery namedQuery) {
-		this.removeNamedQuery(this.namedQueryContainer.indexOfContextElement((OrmNamedQuery) namedQuery));
+		this.removeNamedQuery(this.namedQueryContainer.indexOf((OrmNamedQuery) namedQuery));
 	}
 
 	public void removeNamedQuery(int index) {
-		this.namedQueryContainer.removeContextElement(index);
+		this.namedQueryContainer.remove(index);
 		this.xmlQueryContainer.getNamedQueries().remove(index);
 	}
 
 	public void moveNamedQuery(int targetIndex, int sourceIndex) {
-		this.namedQueryContainer.moveContextElement(targetIndex, sourceIndex);
+		this.namedQueryContainer.move(targetIndex, sourceIndex);
 		this.xmlQueryContainer.getNamedQueries().move(targetIndex, sourceIndex);
 	}
 
@@ -139,31 +139,22 @@ public class GenericOrmQueryContainer
 	}
 
 	protected ContextListContainer<OrmNamedQuery, XmlNamedQuery> buildNamedQueryContainer() {
-		NamedQueryContainer container = new NamedQueryContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(NAMED_QUERIES_LIST, new NamedQueryContainerAdapter());
 	}
 
 	/**
-	 * named query container
+	 * named query container adapter
 	 */
-	protected class NamedQueryContainer
-		extends ContextListContainer<OrmNamedQuery, XmlNamedQuery>
+	public class NamedQueryContainerAdapter
+		extends AbstractContainerAdapter<OrmNamedQuery, XmlNamedQuery>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return NAMED_QUERIES_LIST;
-		}
-		@Override
-		protected OrmNamedQuery buildContextElement(XmlNamedQuery resourceElement) {
+		public OrmNamedQuery buildContextElement(XmlNamedQuery resourceElement) {
 			return GenericOrmQueryContainer.this.buildNamedQuery(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlNamedQuery> getResourceElements() {
+		public ListIterable<XmlNamedQuery> getResourceElements() {
 			return GenericOrmQueryContainer.this.getXmlNamedQueries();
 		}
-		@Override
-		protected XmlNamedQuery getResourceElement(OrmNamedQuery contextElement) {
+		public XmlNamedQuery extractResourceElement(OrmNamedQuery contextElement) {
 			return contextElement.getXmlQuery();
 		}
 	}
@@ -171,11 +162,11 @@ public class GenericOrmQueryContainer
 	// ********** named native queries **********
 
 	public ListIterable<OrmNamedNativeQuery> getNamedNativeQueries() {
-		return this.namedNativeQueryContainer.getContextElements();
+		return this.namedNativeQueryContainer;
 	}
 
 	public int getNamedNativeQueriesSize() {
-		return this.namedNativeQueryContainer.getContextElementsSize();
+		return this.namedNativeQueryContainer.size();
 	}
 
 	public OrmNamedNativeQuery addNamedNativeQuery() {
@@ -194,16 +185,16 @@ public class GenericOrmQueryContainer
 	}
 
 	public void removeNamedNativeQuery(NamedNativeQuery namedNativeQuery) {
-		this.removeNamedNativeQuery(this.namedNativeQueryContainer.indexOfContextElement((OrmNamedNativeQuery) namedNativeQuery));
+		this.removeNamedNativeQuery(this.namedNativeQueryContainer.indexOf((OrmNamedNativeQuery) namedNativeQuery));
 	}
 
 	public void removeNamedNativeQuery(int index) {
-		this.namedNativeQueryContainer.removeContextElement(index);
+		this.namedNativeQueryContainer.remove(index);
 		this.xmlQueryContainer.getNamedNativeQueries().remove(index);
 	}
 
 	public void moveNamedNativeQuery(int targetIndex, int sourceIndex) {
-		this.namedNativeQueryContainer.moveContextElement(targetIndex, sourceIndex);
+		this.namedNativeQueryContainer.move(targetIndex, sourceIndex);
 		this.xmlQueryContainer.getNamedNativeQueries().move(targetIndex, sourceIndex);
 	}
 
@@ -221,31 +212,22 @@ public class GenericOrmQueryContainer
 	}
 
 	protected ContextListContainer<OrmNamedNativeQuery, XmlNamedNativeQuery> buildNamedNativeQueryContainer() {
-		NamedNativeQueryContainer container = new NamedNativeQueryContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(NAMED_NATIVE_QUERIES_LIST, new NamedNativeQueryContainerAdapter());
 	}
 
 	/**
-	 * named query container
+	 * named native query container adapter
 	 */
-	protected class NamedNativeQueryContainer
-		extends ContextListContainer<OrmNamedNativeQuery, XmlNamedNativeQuery>
+	public class NamedNativeQueryContainerAdapter
+		extends AbstractContainerAdapter<OrmNamedNativeQuery, XmlNamedNativeQuery>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return NAMED_NATIVE_QUERIES_LIST;
-		}
-		@Override
-		protected OrmNamedNativeQuery buildContextElement(XmlNamedNativeQuery resourceElement) {
+		public OrmNamedNativeQuery buildContextElement(XmlNamedNativeQuery resourceElement) {
 			return GenericOrmQueryContainer.this.buildNamedNativeQuery(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlNamedNativeQuery> getResourceElements() {
+		public ListIterable<XmlNamedNativeQuery> getResourceElements() {
 			return GenericOrmQueryContainer.this.getXmlNamedNativeQueries();
 		}
-		@Override
-		protected XmlNamedNativeQuery getResourceElement(OrmNamedNativeQuery contextElement) {
+		public XmlNamedNativeQuery extractResourceElement(OrmNamedNativeQuery contextElement) {
 			return contextElement.getXmlQuery();
 		}
 	}
@@ -254,11 +236,11 @@ public class GenericOrmQueryContainer
 	// ********** named stored procedure queries **********
 
 	public ListIterable<OrmNamedStoredProcedureQuery2_1> getNamedStoredProcedureQueries() {
-		return this.namedStoredProcedureQueryContainer.getContextElements();
+		return this.namedStoredProcedureQueryContainer;
 	}
 
 	public int getNamedStoredProcedureQueriesSize() {
-		return this.namedStoredProcedureQueryContainer.getContextElementsSize();
+		return this.namedStoredProcedureQueryContainer.size();
 	}
 
 	public OrmNamedStoredProcedureQuery2_1 addNamedStoredProcedureQuery() {
@@ -280,16 +262,16 @@ public class GenericOrmQueryContainer
 	}
 
 	public void removeNamedStoredProcedureQuery(NamedStoredProcedureQuery2_1 namedQuery) {
-		this.removeNamedStoredProcedureQuery(this.namedStoredProcedureQueryContainer.indexOfContextElement((OrmNamedStoredProcedureQuery2_1) namedQuery));
+		this.removeNamedStoredProcedureQuery(this.namedStoredProcedureQueryContainer.indexOf((OrmNamedStoredProcedureQuery2_1) namedQuery));
 	}
 
 	public void removeNamedStoredProcedureQuery(int index) {
-		this.namedStoredProcedureQueryContainer.removeContextElement(index);
+		this.namedStoredProcedureQueryContainer.remove(index);
 		this.xmlQueryContainer.getNamedStoredProcedureQueries().remove(index);
 	}
 
 	public void moveNamedStoredProcedureQuery(int targetIndex, int sourceIndex) {
-		this.namedStoredProcedureQueryContainer.moveContextElement(targetIndex, sourceIndex);
+		this.namedStoredProcedureQueryContainer.move(targetIndex, sourceIndex);
 		this.xmlQueryContainer.getNamedStoredProcedureQueries().move(targetIndex, sourceIndex);
 	}
 
@@ -309,31 +291,22 @@ public class GenericOrmQueryContainer
 	}
 
 	protected ContextListContainer<OrmNamedStoredProcedureQuery2_1, XmlNamedStoredProcedureQuery> buildNamedStoredProcedureQueryContainer() {
-		NamedStoredProcedureQueryContainer container = new NamedStoredProcedureQueryContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(NAMED_STORED_PROCEDURE_QUERIES_LIST, new NamedStoredProcedureQueryContainerAdapter());
 	}
 
 	/**
-	 * named query container
+	 * named stored procedure query container adapter
 	 */
-	protected class NamedStoredProcedureQueryContainer
-		extends ContextListContainer<OrmNamedStoredProcedureQuery2_1, XmlNamedStoredProcedureQuery>
+	public class NamedStoredProcedureQueryContainerAdapter
+		extends AbstractContainerAdapter<OrmNamedStoredProcedureQuery2_1, XmlNamedStoredProcedureQuery>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return NAMED_STORED_PROCEDURE_QUERIES_LIST;
-		}
-		@Override
-		protected OrmNamedStoredProcedureQuery2_1 buildContextElement(XmlNamedStoredProcedureQuery resourceElement) {
+		public OrmNamedStoredProcedureQuery2_1 buildContextElement(XmlNamedStoredProcedureQuery resourceElement) {
 			return GenericOrmQueryContainer.this.buildNamedStoredProcedureQuery(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlNamedStoredProcedureQuery> getResourceElements() {
+		public ListIterable<XmlNamedStoredProcedureQuery> getResourceElements() {
 			return GenericOrmQueryContainer.this.getXmlNamedStoredProcedureQueries();
 		}
-		@Override
-		protected XmlNamedStoredProcedureQuery getResourceElement(OrmNamedStoredProcedureQuery2_1 contextElement) {
+		public XmlNamedStoredProcedureQuery extractResourceElement(OrmNamedStoredProcedureQuery2_1 contextElement) {
 			return contextElement.getXmlQuery();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmReferenceTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmReferenceTable.java
index 85e9e55950..4cc369014c 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmReferenceTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmReferenceTable.java
@@ -14,10 +14,10 @@ import org.eclipse.jpt.common.utility.internal.iterable.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.IterableTools;
 import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterable;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
-import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
-import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
+import org.eclipse.jpt.jpa.core.context.JpaContextModel;
 import org.eclipse.jpt.jpa.core.context.ReferenceTable;
+import org.eclipse.jpt.jpa.core.context.SpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.Table;
 import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedReferenceTable;
@@ -83,11 +83,11 @@ public abstract class GenericOrmReferenceTable<P extends JpaContextModel, PA ext
 	// ********** specified join columns **********
 
 	public ListIterable<OrmSpecifiedJoinColumn> getSpecifiedJoinColumns() {
-		return this.specifiedJoinColumnContainer.getContextElements();
+		return this.specifiedJoinColumnContainer;
 	}
 
 	public int getSpecifiedJoinColumnsSize() {
-		return this.specifiedJoinColumnContainer.getContextElementsSize();
+		return this.specifiedJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedJoinColumns() {
@@ -95,7 +95,7 @@ public abstract class GenericOrmReferenceTable<P extends JpaContextModel, PA ext
 	}
 
 	public OrmSpecifiedJoinColumn getSpecifiedJoinColumn(int index) {
-		return this.specifiedJoinColumnContainer.getContextElement(index);
+		return this.specifiedJoinColumnContainer.get(index);
 	}
 
 	public OrmSpecifiedJoinColumn addSpecifiedJoinColumn() {
@@ -115,22 +115,22 @@ public abstract class GenericOrmReferenceTable<P extends JpaContextModel, PA ext
 	}
 
 	public void removeSpecifiedJoinColumn(SpecifiedJoinColumn joinColumn) {
-		this.removeSpecifiedJoinColumn(this.specifiedJoinColumnContainer.indexOfContextElement((OrmSpecifiedJoinColumn) joinColumn));
+		this.removeSpecifiedJoinColumn(this.specifiedJoinColumnContainer.indexOf((OrmSpecifiedJoinColumn) joinColumn));
 	}
 
 	public void removeSpecifiedJoinColumn(int index) {
-		this.specifiedJoinColumnContainer.removeContextElement(index);
+		this.specifiedJoinColumnContainer.remove(index);
 		this.getXmlTable().getJoinColumns().remove(index);
 		this.removeXmlTableIfUnset();
 	}
 
 	public void moveSpecifiedJoinColumn(int targetIndex, int sourceIndex) {
-		this.specifiedJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedJoinColumnContainer.move(targetIndex, sourceIndex);
 		this.getXmlTable().getJoinColumns().move(targetIndex, sourceIndex);
 	}
 
 	public void clearSpecifiedJoinColumns() {
-		this.specifiedJoinColumnContainer.clearContextList();
+		this.specifiedJoinColumnContainer.clear();
 		this.getXmlTable().getJoinColumns().clear();
 	}
 
@@ -147,31 +147,22 @@ public abstract class GenericOrmReferenceTable<P extends JpaContextModel, PA ext
 	}
 
 	protected ContextListContainer<OrmSpecifiedJoinColumn, XmlJoinColumn> buildSpecifiedJoinColumnContainer() {
-		SpecifiedJoinColumnContainer container =  new SpecifiedJoinColumnContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_JOIN_COLUMNS_LIST, new SpecifiedJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified join column container
+	 * specified join column container adapter
 	 */
-	protected class SpecifiedJoinColumnContainer
-		extends ContextListContainer<OrmSpecifiedJoinColumn, XmlJoinColumn>
+	public class SpecifiedJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<OrmSpecifiedJoinColumn, XmlJoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected OrmSpecifiedJoinColumn buildContextElement(XmlJoinColumn resourceElement) {
+		public OrmSpecifiedJoinColumn buildContextElement(XmlJoinColumn resourceElement) {
 			return GenericOrmReferenceTable.this.buildJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlJoinColumn> getResourceElements() {
+		public ListIterable<XmlJoinColumn> getResourceElements() {
 			return GenericOrmReferenceTable.this.getXmlJoinColumns();
 		}
-		@Override
-		protected XmlJoinColumn getResourceElement(OrmSpecifiedJoinColumn contextElement) {
+		public XmlJoinColumn extractResourceElement(OrmSpecifiedJoinColumn contextElement) {
 			return contextElement.getXmlColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmSecondaryTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmSecondaryTable.java
index fd7b4647bf..07083ccca0 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmSecondaryTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmSecondaryTable.java
@@ -15,13 +15,13 @@ import org.eclipse.jpt.common.utility.internal.iterable.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterable.IterableTools;
 import org.eclipse.jpt.common.utility.internal.iterable.SingleElementListIterable;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
+import org.eclipse.jpt.jpa.core.context.BaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.JpaContextModel;
-import org.eclipse.jpt.jpa.core.context.SpecifiedPrimaryKeyJoinColumn;
-import org.eclipse.jpt.jpa.core.context.BaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.NamedColumn;
 import org.eclipse.jpt.jpa.core.context.PrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.SecondaryTable;
+import org.eclipse.jpt.jpa.core.context.SpecifiedPrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmEntity;
 import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedPrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedSecondaryTable;
@@ -126,7 +126,7 @@ public class GenericOrmSecondaryTable
 	// ********** specified primary key join columns **********
 
 	public ListIterable<OrmSpecifiedPrimaryKeyJoinColumn> getSpecifiedPrimaryKeyJoinColumns() {
-		return this.specifiedPrimaryKeyJoinColumnContainer.getContextElements();
+		return this.specifiedPrimaryKeyJoinColumnContainer;
 	}
 
 	public OrmSpecifiedPrimaryKeyJoinColumn getSpecifiedPrimaryKeyJoinColumn(int index) {
@@ -134,7 +134,7 @@ public class GenericOrmSecondaryTable
 	}
 
 	public int getSpecifiedPrimaryKeyJoinColumnsSize() {
-		return this.specifiedPrimaryKeyJoinColumnContainer.getContextElementsSize();
+		return this.specifiedPrimaryKeyJoinColumnContainer.size();
 	}
 
 	protected boolean hasSpecifiedPrimaryKeyJoinColumns() {
@@ -157,11 +157,11 @@ public class GenericOrmSecondaryTable
 	}
 
 	public void removeSpecifiedPrimaryKeyJoinColumn(SpecifiedPrimaryKeyJoinColumn joinColumn) {
-		this.removeSpecifiedPrimaryKeyJoinColumn(this.specifiedPrimaryKeyJoinColumnContainer.indexOfContextElement((OrmSpecifiedPrimaryKeyJoinColumn) joinColumn));
+		this.removeSpecifiedPrimaryKeyJoinColumn(this.specifiedPrimaryKeyJoinColumnContainer.indexOf((OrmSpecifiedPrimaryKeyJoinColumn) joinColumn));
 	}
 
 	public void removeSpecifiedPrimaryKeyJoinColumn(int index) {
-		this.specifiedPrimaryKeyJoinColumnContainer.removeContextElement(index);
+		this.specifiedPrimaryKeyJoinColumnContainer.remove(index);
 		this.xmlSecondaryTable.getPrimaryKeyJoinColumns().remove(index);
 	}
 
@@ -180,12 +180,12 @@ public class GenericOrmSecondaryTable
 	}
 
 	public void clearSpecifiedPrimaryKeyJoinColumns() {
-		this.specifiedPrimaryKeyJoinColumnContainer.clearContextList();
+		this.specifiedPrimaryKeyJoinColumnContainer.clear();
 		this.xmlSecondaryTable.getPrimaryKeyJoinColumns().clear();
 	}
 
 	public void moveSpecifiedPrimaryKeyJoinColumn(int targetIndex, int sourceIndex) {
-		this.specifiedPrimaryKeyJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedPrimaryKeyJoinColumnContainer.move(targetIndex, sourceIndex);
 		this.xmlSecondaryTable.getPrimaryKeyJoinColumns().move(targetIndex, sourceIndex);
 	}
 
@@ -199,31 +199,22 @@ public class GenericOrmSecondaryTable
 	}
 
 	protected ContextListContainer<OrmSpecifiedPrimaryKeyJoinColumn, XmlPrimaryKeyJoinColumn> buildSpecifiedPrimaryKeyJoinColumnContainer() {
-		SpecifiedPrimaryKeyJoinColumnContainer container = new SpecifiedPrimaryKeyJoinColumnContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST, new SpecifiedPrimaryKeyJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified primary key join column container
+	 * specified primary key join column container adapter
 	 */
-	protected class SpecifiedPrimaryKeyJoinColumnContainer
-		extends ContextListContainer<OrmSpecifiedPrimaryKeyJoinColumn, XmlPrimaryKeyJoinColumn>
+	public class SpecifiedPrimaryKeyJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<OrmSpecifiedPrimaryKeyJoinColumn, XmlPrimaryKeyJoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_PRIMARY_KEY_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected OrmSpecifiedPrimaryKeyJoinColumn buildContextElement(XmlPrimaryKeyJoinColumn resourceElement) {
+		public OrmSpecifiedPrimaryKeyJoinColumn buildContextElement(XmlPrimaryKeyJoinColumn resourceElement) {
 			return GenericOrmSecondaryTable.this.buildPrimaryKeyJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlPrimaryKeyJoinColumn> getResourceElements() {
+		public ListIterable<XmlPrimaryKeyJoinColumn> getResourceElements() {
 			return GenericOrmSecondaryTable.this.getXmlPrimaryKeyJoinColumns();
 		}
-		@Override
-		protected XmlPrimaryKeyJoinColumn getResourceElement(OrmSpecifiedPrimaryKeyJoinColumn contextElement) {
+		public XmlPrimaryKeyJoinColumn extractResourceElement(OrmSpecifiedPrimaryKeyJoinColumn contextElement) {
 			return contextElement.getXmlColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmTableGenerator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmTableGenerator.java
index 70ec117405..d15258219f 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmTableGenerator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmTableGenerator.java
@@ -17,12 +17,12 @@ import org.eclipse.jpt.common.utility.internal.iterable.IterableTools;
 import org.eclipse.jpt.common.utility.iterable.ListIterable;
 import org.eclipse.jpt.jpa.core.context.DbGenerator;
 import org.eclipse.jpt.jpa.core.context.JpaContextModel;
-import org.eclipse.jpt.jpa.core.context.TableGenerator;
 import org.eclipse.jpt.jpa.core.context.SpecifiedUniqueConstraint;
-import org.eclipse.jpt.jpa.core.context.java.JavaTableGenerator;
+import org.eclipse.jpt.jpa.core.context.TableGenerator;
 import org.eclipse.jpt.jpa.core.context.java.JavaSpecifiedUniqueConstraint;
-import org.eclipse.jpt.jpa.core.context.orm.OrmTableGenerator;
+import org.eclipse.jpt.jpa.core.context.java.JavaTableGenerator;
 import org.eclipse.jpt.jpa.core.context.orm.OrmSpecifiedUniqueConstraint;
+import org.eclipse.jpt.jpa.core.context.orm.OrmTableGenerator;
 import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmDbGenerator;
 import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.jpa.core.resource.orm.XmlTableGenerator;
@@ -333,15 +333,15 @@ public class GenericOrmTableGenerator
 	// ********** unique constraints **********
 
 	public ListIterable<OrmSpecifiedUniqueConstraint> getUniqueConstraints() {
-		return this.uniqueConstraintContainer.getContextElements();
+		return this.uniqueConstraintContainer;
 	}
 
 	public int getUniqueConstraintsSize() {
-		return this.uniqueConstraintContainer.getContextElementsSize();
+		return this.uniqueConstraintContainer.size();
 	}
 
 	public OrmSpecifiedUniqueConstraint getUniqueConstraint(int index) {
-		return this.uniqueConstraintContainer.getContextElement(index);
+		return this.uniqueConstraintContainer.get(index);
 	}
 	
 	public OrmSpecifiedUniqueConstraint addUniqueConstraint() {
@@ -360,16 +360,16 @@ public class GenericOrmTableGenerator
 	}
 
 	public void removeUniqueConstraint(SpecifiedUniqueConstraint uniqueConstraint) {
-		this.removeUniqueConstraint(this.uniqueConstraintContainer.indexOfContextElement((OrmSpecifiedUniqueConstraint) uniqueConstraint));
+		this.removeUniqueConstraint(this.uniqueConstraintContainer.indexOf((OrmSpecifiedUniqueConstraint) uniqueConstraint));
 	}
 
 	public void removeUniqueConstraint(int index) {
-		this.uniqueConstraintContainer.removeContextElement(index);
+		this.uniqueConstraintContainer.remove(index);
 		this.xmlGenerator.getUniqueConstraints().remove(index);
 	}
 
 	public void moveUniqueConstraint(int targetIndex, int sourceIndex) {
-		this.uniqueConstraintContainer.moveContextElement(targetIndex, sourceIndex);
+		this.uniqueConstraintContainer.move(targetIndex, sourceIndex);
 		this.xmlGenerator.getUniqueConstraints().move(targetIndex, sourceIndex);
 	}
 
@@ -387,31 +387,22 @@ public class GenericOrmTableGenerator
 	}
 
 	protected ContextListContainer<OrmSpecifiedUniqueConstraint, XmlUniqueConstraint> buildUniqueConstraintContainer() {
-		UniqueConstraintContainer container = new UniqueConstraintContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(UNIQUE_CONSTRAINTS_LIST, new UniqueConstraintContainerAdapter());
 	}
 
 	/**
-	 * unique constraint container
+	 * unique constraint container adapter
 	 */
-	protected class UniqueConstraintContainer
-		extends ContextListContainer<OrmSpecifiedUniqueConstraint, XmlUniqueConstraint>
+	public class UniqueConstraintContainerAdapter
+		extends AbstractContainerAdapter<OrmSpecifiedUniqueConstraint, XmlUniqueConstraint>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return UNIQUE_CONSTRAINTS_LIST;
-		}
-		@Override
-		protected OrmSpecifiedUniqueConstraint buildContextElement(XmlUniqueConstraint resourceElement) {
+		public OrmSpecifiedUniqueConstraint buildContextElement(XmlUniqueConstraint resourceElement) {
 			return GenericOrmTableGenerator.this.buildUniqueConstraint(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlUniqueConstraint> getResourceElements() {
+		public ListIterable<XmlUniqueConstraint> getResourceElements() {
 			return GenericOrmTableGenerator.this.getXmlUniqueConstraints();
 		}
-		@Override
-		protected XmlUniqueConstraint getResourceElement(OrmSpecifiedUniqueConstraint contextElement) {
+		public XmlUniqueConstraint extractResourceElement(OrmSpecifiedUniqueConstraint contextElement) {
 			return contextElement.getXmlUniqueConstraint();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2/context/java/AbstractJavaElementCollectionMapping2_0.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2/context/java/AbstractJavaElementCollectionMapping2_0.java
index 821a96903f..a224ecb2cc 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2/context/java/AbstractJavaElementCollectionMapping2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2/context/java/AbstractJavaElementCollectionMapping2_0.java
@@ -1066,11 +1066,11 @@ public abstract class AbstractJavaElementCollectionMapping2_0
 	// ********** specified map key join columns **********
 
 	public ListIterable<JavaSpecifiedJoinColumn> getSpecifiedMapKeyJoinColumns() {
-		return this.specifiedMapKeyJoinColumnContainer.getContextElements();
+		return this.specifiedMapKeyJoinColumnContainer;
 	}
 
 	public int getSpecifiedMapKeyJoinColumnsSize() {
-		return this.specifiedMapKeyJoinColumnContainer.getContextElementsSize();
+		return this.specifiedMapKeyJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedMapKeyJoinColumns() {
@@ -1078,7 +1078,7 @@ public abstract class AbstractJavaElementCollectionMapping2_0
 	}
 
 	public JavaSpecifiedJoinColumn getSpecifiedMapKeyJoinColumn(int index) {
-		return this.specifiedMapKeyJoinColumnContainer.getContextElement(index);
+		return this.specifiedMapKeyJoinColumnContainer.get(index);
 	}
 
 	public JavaSpecifiedJoinColumn addSpecifiedMapKeyJoinColumn() {
@@ -1091,17 +1091,17 @@ public abstract class AbstractJavaElementCollectionMapping2_0
 	}
 
 	public void removeSpecifiedMapKeyJoinColumn(SpecifiedJoinColumn joinColumn) {
-		this.removeSpecifiedMapKeyJoinColumn(this.specifiedMapKeyJoinColumnContainer.indexOfContextElement((JavaSpecifiedJoinColumn) joinColumn));
+		this.removeSpecifiedMapKeyJoinColumn(this.specifiedMapKeyJoinColumnContainer.indexOf((JavaSpecifiedJoinColumn) joinColumn));
 	}
 
 	public void removeSpecifiedMapKeyJoinColumn(int index) {
 		this.removeMapKeyJoinColumnAnnotation(index);
-		this.specifiedMapKeyJoinColumnContainer.removeContextElement(index);
+		this.specifiedMapKeyJoinColumnContainer.remove(index);
 	}
 
 	public void moveSpecifiedMapKeyJoinColumn(int targetIndex, int sourceIndex) {
 		this.moveMapKeyJoinColumnAnnotation(targetIndex, sourceIndex);
-		this.specifiedMapKeyJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedMapKeyJoinColumnContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected void syncSpecifiedMapKeyJoinColumns() {
@@ -1109,31 +1109,22 @@ public abstract class AbstractJavaElementCollectionMapping2_0
 	}
 
 	protected ContextListContainer<JavaSpecifiedJoinColumn, MapKeyJoinColumnAnnotation2_0> buildSpecifiedMapKeyJoinColumnContainer() {
-		SpecifiedMapKeyJoinColumnContainer container = new SpecifiedMapKeyJoinColumnContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_MAP_KEY_JOIN_COLUMNS_LIST, new SpecifiedMapKeyJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified map key join column container
+	 * specified map key join column container adapter
 	 */
-	public class SpecifiedMapKeyJoinColumnContainer
-		extends ContextListContainer<JavaSpecifiedJoinColumn, MapKeyJoinColumnAnnotation2_0>
+	public class SpecifiedMapKeyJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<JavaSpecifiedJoinColumn, MapKeyJoinColumnAnnotation2_0>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_MAP_KEY_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected JavaSpecifiedJoinColumn buildContextElement(MapKeyJoinColumnAnnotation2_0 resourceElement) {
+		public JavaSpecifiedJoinColumn buildContextElement(MapKeyJoinColumnAnnotation2_0 resourceElement) {
 			return AbstractJavaElementCollectionMapping2_0.this.buildMapKeyJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<MapKeyJoinColumnAnnotation2_0> getResourceElements() {
+		public ListIterable<MapKeyJoinColumnAnnotation2_0> getResourceElements() {
 			return AbstractJavaElementCollectionMapping2_0.this.getMapKeyJoinColumnAnnotations();
 		}
-		@Override
-		protected MapKeyJoinColumnAnnotation2_0 getResourceElement(JavaSpecifiedJoinColumn contextElement) {
+		public MapKeyJoinColumnAnnotation2_0 extractResourceElement(JavaSpecifiedJoinColumn contextElement) {
 			return (MapKeyJoinColumnAnnotation2_0) contextElement.getColumnAnnotation();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2/context/orm/AbstractOrmElementCollectionMapping2_0.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2/context/orm/AbstractOrmElementCollectionMapping2_0.java
index aa2fee3bec..754d6151ff 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2/context/orm/AbstractOrmElementCollectionMapping2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2/context/orm/AbstractOrmElementCollectionMapping2_0.java
@@ -1045,11 +1045,11 @@ public abstract class AbstractOrmElementCollectionMapping2_0<X extends XmlElemen
 	// ********** specified map key join columns **********
 
 	public ListIterable<OrmSpecifiedJoinColumn> getSpecifiedMapKeyJoinColumns() {
-		return this.specifiedMapKeyJoinColumnContainer.getContextElements();
+		return this.specifiedMapKeyJoinColumnContainer;
 	}
 
 	public int getSpecifiedMapKeyJoinColumnsSize() {
-		return this.specifiedMapKeyJoinColumnContainer.getContextElementsSize();
+		return this.specifiedMapKeyJoinColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedMapKeyJoinColumns() {
@@ -1057,7 +1057,7 @@ public abstract class AbstractOrmElementCollectionMapping2_0<X extends XmlElemen
 	}
 
 	public OrmSpecifiedJoinColumn getSpecifiedMapKeyJoinColumn(int index) {
-		return this.specifiedMapKeyJoinColumnContainer.getContextElement(index);
+		return this.specifiedMapKeyJoinColumnContainer.get(index);
 	}
 
 	public OrmSpecifiedJoinColumn addSpecifiedMapKeyJoinColumn() {
@@ -1076,16 +1076,16 @@ public abstract class AbstractOrmElementCollectionMapping2_0<X extends XmlElemen
 	}
 
 	public void removeSpecifiedMapKeyJoinColumn(SpecifiedJoinColumn joinColumn) {
-		this.removeSpecifiedMapKeyJoinColumn(this.specifiedMapKeyJoinColumnContainer.indexOfContextElement((OrmSpecifiedJoinColumn) joinColumn));
+		this.removeSpecifiedMapKeyJoinColumn(this.specifiedMapKeyJoinColumnContainer.indexOf((OrmSpecifiedJoinColumn) joinColumn));
 	}
 
 	public void removeSpecifiedMapKeyJoinColumn(int index) {
-		this.specifiedMapKeyJoinColumnContainer.removeContextElement(index);
+		this.specifiedMapKeyJoinColumnContainer.remove(index);
 		this.getXmlAttributeMapping().getMapKeyJoinColumns().remove(index);
 	}
 
 	public void moveSpecifiedMapKeyJoinColumn(int targetIndex, int sourceIndex) {
-		this.specifiedMapKeyJoinColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedMapKeyJoinColumnContainer.move(targetIndex, sourceIndex);
 		this.getXmlAttributeMapping().getMapKeyJoinColumns().move(targetIndex, sourceIndex);
 	}
 
@@ -1099,31 +1099,22 @@ public abstract class AbstractOrmElementCollectionMapping2_0<X extends XmlElemen
 	}
 
 	protected ContextListContainer<OrmSpecifiedJoinColumn, XmlJoinColumn> buildSpecifiedMapKeyJoinColumnContainer() {
-		SpecifiedMapKeyJoinColumnContainer container = new SpecifiedMapKeyJoinColumnContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(SPECIFIED_MAP_KEY_JOIN_COLUMNS_LIST, new SpecifiedMapKeyJoinColumnContainerAdapter());
 	}
 
 	/**
-	 * specified join column container
+	 * specified map key join column container adapter
 	 */
-	public class SpecifiedMapKeyJoinColumnContainer
-		extends ContextListContainer<OrmSpecifiedJoinColumn, XmlJoinColumn>
+	public class SpecifiedMapKeyJoinColumnContainerAdapter
+		extends AbstractContainerAdapter<OrmSpecifiedJoinColumn, XmlJoinColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_MAP_KEY_JOIN_COLUMNS_LIST;
-		}
-		@Override
-		protected OrmSpecifiedJoinColumn buildContextElement(XmlJoinColumn resourceElement) {
+		public OrmSpecifiedJoinColumn buildContextElement(XmlJoinColumn resourceElement) {
 			return AbstractOrmElementCollectionMapping2_0.this.buildMapKeyJoinColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlJoinColumn> getResourceElements() {
+		public ListIterable<XmlJoinColumn> getResourceElements() {
 			return AbstractOrmElementCollectionMapping2_0.this.getXmlMapKeyJoinColumns();
 		}
-		@Override
-		protected XmlJoinColumn getResourceElement(OrmSpecifiedJoinColumn contextElement) {
+		public XmlJoinColumn extractResourceElement(OrmSpecifiedJoinColumn contextElement) {
 			return contextElement.getXmlColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/GenericJavaNamedStoredProcedureQuery2_1.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/GenericJavaNamedStoredProcedureQuery2_1.java
index 1bc9d023d1..dad1b07e1c 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/GenericJavaNamedStoredProcedureQuery2_1.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/java/GenericJavaNamedStoredProcedureQuery2_1.java
@@ -90,11 +90,11 @@ public class GenericJavaNamedStoredProcedureQuery2_1
 	// ************ parameters ***********
 
 	public ListIterable<JavaStoredProcedureParameter2_1> getParameters() {
-		return this.parameterContainer.getContextElements();
+		return this.parameterContainer;
 	}
 
 	public int getParametersSize() {
-		return this.parameterContainer.getContextElementsSize();
+		return this.parameterContainer.size();
 	}
 	
 	public JavaStoredProcedureParameter2_1 addParameter() {
@@ -107,17 +107,17 @@ public class GenericJavaNamedStoredProcedureQuery2_1
 	}
 
 	public void removeParameter(StoredProcedureParameter2_1 parameter) {
-		this.removeParameter(this.parameterContainer.indexOfContextElement((JavaStoredProcedureParameter2_1) parameter));
+		this.removeParameter(this.parameterContainer.indexOf((JavaStoredProcedureParameter2_1) parameter));
 	}
 
 	public void removeParameter(int index) {
 		this.queryAnnotation.removeParameter(index);
-		this.parameterContainer.removeContextElement(index);
+		this.parameterContainer.remove(index);
 	}
 
 	public void moveParameter(int targetIndex, int sourceIndex) {
 		this.queryAnnotation.moveParameter(targetIndex, sourceIndex);
-		this.parameterContainer.moveContextElement(targetIndex, sourceIndex);
+		this.parameterContainer.move(targetIndex, sourceIndex);
 	}
 
 	public JavaStoredProcedureParameter2_1 getParameter(int index) {
@@ -137,31 +137,22 @@ public class GenericJavaNamedStoredProcedureQuery2_1
 	}
 
 	protected ContextListContainer<JavaStoredProcedureParameter2_1, StoredProcedureParameterAnnotation2_1> buildParameterContainer() {
-		ParameterContainer container = new ParameterContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(PARAMETERS_LIST, new ParameterContainerAdapter());
 	}
 
 	/**
-	 * stored procedure parameter container
+	 * parameter container adapter
 	 */
-	protected class ParameterContainer
-		extends ContextListContainer<JavaStoredProcedureParameter2_1, StoredProcedureParameterAnnotation2_1>
+	public class ParameterContainerAdapter
+		extends AbstractContainerAdapter<JavaStoredProcedureParameter2_1, StoredProcedureParameterAnnotation2_1>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return PARAMETERS_LIST;
-		}
-		@Override
-		protected JavaStoredProcedureParameter2_1 buildContextElement(StoredProcedureParameterAnnotation2_1 resourceElement) {
+		public JavaStoredProcedureParameter2_1 buildContextElement(StoredProcedureParameterAnnotation2_1 resourceElement) {
 			return GenericJavaNamedStoredProcedureQuery2_1.this.buildParameter(resourceElement);
 		}
-		@Override
-		protected ListIterable<StoredProcedureParameterAnnotation2_1> getResourceElements() {
+		public ListIterable<StoredProcedureParameterAnnotation2_1> getResourceElements() {
 			return GenericJavaNamedStoredProcedureQuery2_1.this.getParameterAnnotations();
 		}
-		@Override
-		protected StoredProcedureParameterAnnotation2_1 getResourceElement(JavaStoredProcedureParameter2_1 contextElement) {
+		public StoredProcedureParameterAnnotation2_1 extractResourceElement(JavaStoredProcedureParameter2_1 contextElement) {
 			return contextElement.getStoredProcedureParameter2_1Annotation();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmNamedStoredProcedureQuery2_1.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmNamedStoredProcedureQuery2_1.java
index 398a77b439..92aad5c0c9 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmNamedStoredProcedureQuery2_1.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa2_1/context/orm/GenericOrmNamedStoredProcedureQuery2_1.java
@@ -88,11 +88,11 @@ public class GenericOrmNamedStoredProcedureQuery2_1
 	// ********** parameters **********
 
 	public ListIterable<OrmStoredProcedureParameter2_1> getParameters() {
-		return this.parameterContainer.getContextElements();
+		return this.parameterContainer;
 	}
 
 	public int getParametersSize() {
-		return this.parameterContainer.getContextElementsSize();
+		return this.parameterContainer.size();
 	}
 
 	public OrmStoredProcedureParameter2_1 addParameter() {
@@ -111,16 +111,16 @@ public class GenericOrmNamedStoredProcedureQuery2_1
 	}
 
 	public void removeParameter(StoredProcedureParameter2_1 parameter) {
-		this.removeParameter(this.parameterContainer.indexOfContextElement((OrmStoredProcedureParameter2_1) parameter));
+		this.removeParameter(this.parameterContainer.indexOf((OrmStoredProcedureParameter2_1) parameter));
 	}
 
 	public void removeParameter(int index) {
-		this.parameterContainer.removeContextElement(index);
+		this.parameterContainer.remove(index);
 		this.xmlQuery.getParameters().remove(index);
 	}
 
 	public void moveParameter(int targetIndex, int sourceIndex) {
-		this.parameterContainer.moveContextElement(targetIndex, sourceIndex);
+		this.parameterContainer.move(targetIndex, sourceIndex);
 		this.xmlQuery.getParameters().move(targetIndex, sourceIndex);
 	}
 
@@ -144,31 +144,22 @@ public class GenericOrmNamedStoredProcedureQuery2_1
 	}
 
 	protected ContextListContainer<OrmStoredProcedureParameter2_1, XmlStoredProcedureParameter> buildParameterContainer() {
-		ParameterContainer container = new ParameterContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(PARAMETERS_LIST, new ParameterContainerAdapter());
 	}
 
 	/**
-	 * parameter container
+	 * parameter container adapter
 	 */
-	protected class ParameterContainer
-		extends ContextListContainer<OrmStoredProcedureParameter2_1, XmlStoredProcedureParameter>
+	public class ParameterContainerAdapter
+		extends AbstractContainerAdapter<OrmStoredProcedureParameter2_1, XmlStoredProcedureParameter>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return PARAMETERS_LIST;
-		}
-		@Override
-		protected OrmStoredProcedureParameter2_1 buildContextElement(XmlStoredProcedureParameter resourceElement) {
+		public OrmStoredProcedureParameter2_1 buildContextElement(XmlStoredProcedureParameter resourceElement) {
 			return GenericOrmNamedStoredProcedureQuery2_1.this.buildParameter(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlStoredProcedureParameter> getResourceElements() {
+		public ListIterable<XmlStoredProcedureParameter> getResourceElements() {
 			return GenericOrmNamedStoredProcedureQuery2_1.this.getXmlParameters();
 		}
-		@Override
-		protected XmlStoredProcedureParameter getResourceElement(OrmStoredProcedureParameter2_1 contextElement) {
+		public XmlStoredProcedureParameter extractResourceElement(OrmStoredProcedureParameter2_1 contextElement) {
 			return contextElement.getXmlStoredProcedureParameter();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/java/EclipseLinkJavaConverterContainerImpl.java b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/java/EclipseLinkJavaConverterContainerImpl.java
index 1082d809a9..a68fd4cde2 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/java/EclipseLinkJavaConverterContainerImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/java/EclipseLinkJavaConverterContainerImpl.java
@@ -74,11 +74,11 @@ public class EclipseLinkJavaConverterContainerImpl
 	// ********** custom converters **********
 
 	public ListIterable<EclipseLinkJavaCustomConverter> getCustomConverters() {
-		return this.customConverterContainer.getContextElements();
+		return this.customConverterContainer;
 	}
 	
 	public int getCustomConvertersSize() {
-		return this.customConverterContainer.getContextElementsSize();
+		return this.customConverterContainer.size();
 	}
 
 	public EclipseLinkJavaCustomConverter addCustomConverter(String name) {
@@ -97,17 +97,17 @@ public class EclipseLinkJavaConverterContainerImpl
 	}
 
 	public void removeCustomConverter(EclipseLinkCustomConverter customConverter) {
-		this.removeCustomConverter(this.customConverterContainer.indexOfContextElement((EclipseLinkJavaCustomConverter) customConverter));
+		this.removeCustomConverter(this.customConverterContainer.indexOf((EclipseLinkJavaCustomConverter) customConverter));
 	}
 
 	public void removeCustomConverter(int index) {
 		this.getJavaResourceAnnotatedElement().removeAnnotation(index, ConverterAnnotation.ANNOTATION_NAME);
-		this.customConverterContainer.removeContextElement(index);
+		this.customConverterContainer.remove(index);
 	}
 
 	public void moveCustomConverter(int targetIndex, int sourceIndex) {
 		this.getJavaResourceAnnotatedElement().moveAnnotation(targetIndex, sourceIndex, ConverterAnnotation.ANNOTATION_NAME);
-		this.customConverterContainer.moveContextElement(targetIndex, sourceIndex);
+		this.customConverterContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected EclipseLinkJavaCustomConverter buildCustomConverter(ConverterAnnotation converterAnnotation) {
@@ -129,31 +129,22 @@ public class EclipseLinkJavaConverterContainerImpl
 	}
 
 	protected ContextListContainer<EclipseLinkJavaCustomConverter, ConverterAnnotation> buildCustomConverterContainer() {
-		CustomConverterContainer container = new CustomConverterContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(CUSTOM_CONVERTERS_LIST, new CustomConverterContainerAdapter());
 	}
 
 	/**
-	 * custom converter container
+	 * custom converter container adapter
 	 */
-	protected class CustomConverterContainer
-		extends ContextListContainer<EclipseLinkJavaCustomConverter, ConverterAnnotation>
+	public class CustomConverterContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkJavaCustomConverter, ConverterAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return CUSTOM_CONVERTERS_LIST;
-		}
-		@Override
-		protected EclipseLinkJavaCustomConverter buildContextElement(ConverterAnnotation resourceElement) {
+		public EclipseLinkJavaCustomConverter buildContextElement(ConverterAnnotation resourceElement) {
 			return EclipseLinkJavaConverterContainerImpl.this.buildCustomConverter(resourceElement);
 		}
-		@Override
-		protected ListIterable<ConverterAnnotation> getResourceElements() {
+		public ListIterable<ConverterAnnotation> getResourceElements() {
 			return EclipseLinkJavaConverterContainerImpl.this.getCustomConverterAnnotations();
 		}
-		@Override
-		protected ConverterAnnotation getResourceElement(EclipseLinkJavaCustomConverter contextElement) {
+		public ConverterAnnotation extractResourceElement(EclipseLinkJavaCustomConverter contextElement) {
 			return contextElement.getConverterAnnotation();
 		}
 	}
@@ -161,11 +152,11 @@ public class EclipseLinkJavaConverterContainerImpl
 	// ********** object type converters **********
 
 	public ListIterable<EclipseLinkJavaObjectTypeConverter> getObjectTypeConverters() {
-		return this.objectTypeConverterContainer.getContextElements();
+		return this.objectTypeConverterContainer;
 	}
 	
 	public int getObjectTypeConvertersSize() {
-		return this.objectTypeConverterContainer.getContextElementsSize();
+		return this.objectTypeConverterContainer.size();
 	}
 
 	public EclipseLinkJavaObjectTypeConverter addObjectTypeConverter(String name) {
@@ -184,17 +175,17 @@ public class EclipseLinkJavaConverterContainerImpl
 	}
 
 	public void removeObjectTypeConverter(EclipseLinkObjectTypeConverter objectTypeConverter) {
-		this.removeObjectTypeConverter(this.objectTypeConverterContainer.indexOfContextElement((EclipseLinkJavaObjectTypeConverter) objectTypeConverter));
+		this.removeObjectTypeConverter(this.objectTypeConverterContainer.indexOf((EclipseLinkJavaObjectTypeConverter) objectTypeConverter));
 	}
 
 	public void removeObjectTypeConverter(int index) {
 		this.getJavaResourceAnnotatedElement().removeAnnotation(index, ObjectTypeConverterAnnotation.ANNOTATION_NAME);
-		this.objectTypeConverterContainer.removeContextElement(index);
+		this.objectTypeConverterContainer.remove(index);
 	}
 
 	public void moveObjectTypeConverter(int targetIndex, int sourceIndex) {
 		this.getJavaResourceAnnotatedElement().moveAnnotation(targetIndex, sourceIndex, ObjectTypeConverterAnnotation.ANNOTATION_NAME);
-		this.objectTypeConverterContainer.moveContextElement(targetIndex, sourceIndex);
+		this.objectTypeConverterContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected EclipseLinkJavaObjectTypeConverter buildObjectTypeConverter(ObjectTypeConverterAnnotation converterAnnotation) {
@@ -216,31 +207,22 @@ public class EclipseLinkJavaConverterContainerImpl
 	}
 
 	protected ContextListContainer<EclipseLinkJavaObjectTypeConverter, ObjectTypeConverterAnnotation> buildObjectTypeConverterContainer() {
-		ObjectTypeConverterContainer container = new ObjectTypeConverterContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(OBJECT_TYPE_CONVERTERS_LIST, new ObjectTypeConverterContainerAdapter());
 	}
 
 	/**
-	 * objectType converter container
+	 * object type converter container adapter
 	 */
-	protected class ObjectTypeConverterContainer
-		extends ContextListContainer<EclipseLinkJavaObjectTypeConverter, ObjectTypeConverterAnnotation>
+	public class ObjectTypeConverterContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkJavaObjectTypeConverter, ObjectTypeConverterAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return OBJECT_TYPE_CONVERTERS_LIST;
-		}
-		@Override
-		protected EclipseLinkJavaObjectTypeConverter buildContextElement(ObjectTypeConverterAnnotation resourceElement) {
+		public EclipseLinkJavaObjectTypeConverter buildContextElement(ObjectTypeConverterAnnotation resourceElement) {
 			return EclipseLinkJavaConverterContainerImpl.this.buildObjectTypeConverter(resourceElement);
 		}
-		@Override
-		protected ListIterable<ObjectTypeConverterAnnotation> getResourceElements() {
+		public ListIterable<ObjectTypeConverterAnnotation> getResourceElements() {
 			return EclipseLinkJavaConverterContainerImpl.this.getObjectTypeConverterAnnotations();
 		}
-		@Override
-		protected ObjectTypeConverterAnnotation getResourceElement(EclipseLinkJavaObjectTypeConverter contextElement) {
+		public ObjectTypeConverterAnnotation extractResourceElement(EclipseLinkJavaObjectTypeConverter contextElement) {
 			return contextElement.getConverterAnnotation();
 		}
 	}
@@ -248,11 +230,11 @@ public class EclipseLinkJavaConverterContainerImpl
 	// ********** struct converters **********
 
 	public ListIterable<EclipseLinkJavaStructConverter> getStructConverters() {
-		return this.structConverterContainer.getContextElements();
+		return this.structConverterContainer;
 	}
 	
 	public int getStructConvertersSize() {
-		return this.structConverterContainer.getContextElementsSize();
+		return this.structConverterContainer.size();
 	}
 
 	public EclipseLinkJavaStructConverter addStructConverter(String name) {
@@ -271,17 +253,17 @@ public class EclipseLinkJavaConverterContainerImpl
 	}
 
 	public void removeStructConverter(EclipseLinkStructConverter structConverter) {
-		this.removeStructConverter(this.structConverterContainer.indexOfContextElement((EclipseLinkJavaStructConverter) structConverter));
+		this.removeStructConverter(this.structConverterContainer.indexOf((EclipseLinkJavaStructConverter) structConverter));
 	}
 
 	public void removeStructConverter(int index) {
 		this.getJavaResourceAnnotatedElement().removeAnnotation(index, StructConverterAnnotation.ANNOTATION_NAME);
-		this.structConverterContainer.removeContextElement(index);
+		this.structConverterContainer.remove(index);
 	}
 
 	public void moveStructConverter(int targetIndex, int sourceIndex) {
 		this.getJavaResourceAnnotatedElement().moveAnnotation(targetIndex, sourceIndex, StructConverterAnnotation.ANNOTATION_NAME);
-		this.structConverterContainer.moveContextElement(targetIndex, sourceIndex);
+		this.structConverterContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected EclipseLinkJavaStructConverter buildStructConverter(StructConverterAnnotation converterAnnotation) {
@@ -303,31 +285,22 @@ public class EclipseLinkJavaConverterContainerImpl
 	}
 
 	protected ContextListContainer<EclipseLinkJavaStructConverter, StructConverterAnnotation> buildStructConverterContainer() {
-		StructConverterContainer container = new StructConverterContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(STRUCT_CONVERTERS_LIST, new StructConverterContainerAdapter());
 	}
 
 	/**
-	 * struct converter container
+	 * struct converter container adapter
 	 */
-	protected class StructConverterContainer
-		extends ContextListContainer<EclipseLinkJavaStructConverter, StructConverterAnnotation>
+	public class StructConverterContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkJavaStructConverter, StructConverterAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return STRUCT_CONVERTERS_LIST;
-		}
-		@Override
-		protected EclipseLinkJavaStructConverter buildContextElement(StructConverterAnnotation resourceElement) {
+		public EclipseLinkJavaStructConverter buildContextElement(StructConverterAnnotation resourceElement) {
 			return EclipseLinkJavaConverterContainerImpl.this.buildStructConverter(resourceElement);
 		}
-		@Override
-		protected ListIterable<StructConverterAnnotation> getResourceElements() {
+		public ListIterable<StructConverterAnnotation> getResourceElements() {
 			return EclipseLinkJavaConverterContainerImpl.this.getStructConverterAnnotations();
 		}
-		@Override
-		protected StructConverterAnnotation getResourceElement(EclipseLinkJavaStructConverter contextElement) {
+		public StructConverterAnnotation extractResourceElement(EclipseLinkJavaStructConverter contextElement) {
 			return contextElement.getConverterAnnotation();
 		}
 	}
@@ -336,11 +309,11 @@ public class EclipseLinkJavaConverterContainerImpl
 	// ********** type converters **********
 
 	public ListIterable<EclipseLinkJavaTypeConverter> getTypeConverters() {
-		return this.typeConverterContainer.getContextElements();
+		return this.typeConverterContainer;
 	}
 	
 	public int getTypeConvertersSize() {
-		return this.typeConverterContainer.getContextElementsSize();
+		return this.typeConverterContainer.size();
 	}
 
 	public EclipseLinkJavaTypeConverter addTypeConverter(String name) {
@@ -359,17 +332,17 @@ public class EclipseLinkJavaConverterContainerImpl
 	}
 
 	public void removeTypeConverter(EclipseLinkTypeConverter typeConverter) {
-		this.removeTypeConverter(this.typeConverterContainer.indexOfContextElement((EclipseLinkJavaTypeConverter) typeConverter));
+		this.removeTypeConverter(this.typeConverterContainer.indexOf((EclipseLinkJavaTypeConverter) typeConverter));
 	}
 
 	public void removeTypeConverter(int index) {
 		this.getJavaResourceAnnotatedElement().removeAnnotation(index, TypeConverterAnnotation.ANNOTATION_NAME);
-		this.typeConverterContainer.removeContextElement(index);
+		this.typeConverterContainer.remove(index);
 	}
 
 	public void moveTypeConverter(int targetIndex, int sourceIndex) {
 		this.getJavaResourceAnnotatedElement().moveAnnotation(targetIndex, sourceIndex, TypeConverterAnnotation.ANNOTATION_NAME);
-		this.typeConverterContainer.moveContextElement(targetIndex, sourceIndex);
+		this.typeConverterContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected EclipseLinkJavaTypeConverter buildTypeConverter(TypeConverterAnnotation converterAnnotation) {
@@ -391,31 +364,22 @@ public class EclipseLinkJavaConverterContainerImpl
 	}
 
 	protected ContextListContainer<EclipseLinkJavaTypeConverter, TypeConverterAnnotation> buildTypeConverterContainer() {
-		TypeConverterContainer container = new TypeConverterContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(TYPE_CONVERTERS_LIST, new TypeConverterContainerAdapter());
 	}
 
 	/**
-	 * type converter container
+	 * type converter container adapter
 	 */
-	protected class TypeConverterContainer
-		extends ContextListContainer<EclipseLinkJavaTypeConverter, TypeConverterAnnotation>
+	public class TypeConverterContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkJavaTypeConverter, TypeConverterAnnotation>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return TYPE_CONVERTERS_LIST;
-		}
-		@Override
-		protected EclipseLinkJavaTypeConverter buildContextElement(TypeConverterAnnotation resourceElement) {
+		public EclipseLinkJavaTypeConverter buildContextElement(TypeConverterAnnotation resourceElement) {
 			return EclipseLinkJavaConverterContainerImpl.this.buildTypeConverter(resourceElement);
 		}
-		@Override
-		protected ListIterable<TypeConverterAnnotation> getResourceElements() {
+		public ListIterable<TypeConverterAnnotation> getResourceElements() {
 			return EclipseLinkJavaConverterContainerImpl.this.getTypeConverterAnnotations();
 		}
-		@Override
-		protected TypeConverterAnnotation getResourceElement(EclipseLinkJavaTypeConverter contextElement) {
+		public TypeConverterAnnotation extractResourceElement(EclipseLinkJavaTypeConverter contextElement) {
 			return contextElement.getConverterAnnotation();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/java/EclipseLinkJavaMultitenancyImpl2_3.java b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/java/EclipseLinkJavaMultitenancyImpl2_3.java
index 5cde411428..7ca200ace7 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/java/EclipseLinkJavaMultitenancyImpl2_3.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/java/EclipseLinkJavaMultitenancyImpl2_3.java
@@ -34,8 +34,8 @@ import org.eclipse.jpt.jpa.db.Table;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkEntity;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkMappedSuperclass;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkMultitenantType2_3;
-import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkTenantDiscriminatorColumn2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkSpecifiedTenantDiscriminatorColumn2_3;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkTenantDiscriminatorColumn2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkVirtualTenantDiscriminatorColumn2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.context.java.EclipseLinkJavaMultitenancy2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.context.java.EclipseLinkJavaNonEmbeddableTypeMapping;
@@ -43,8 +43,8 @@ import org.eclipse.jpt.jpa.eclipselink.core.context.java.EclipseLinkJavaSpecifie
 import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkEntityMappings;
 import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit;
 import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkTargetDatabase;
-import org.eclipse.jpt.jpa.eclipselink.core.internal.EclipseLinkJpaPlatformFactory2_4;
 import org.eclipse.jpt.jpa.eclipselink.core.internal.EclipseLinkJpaPlatformFactory.EclipseLinkJpaPlatformVersion;
+import org.eclipse.jpt.jpa.eclipselink.core.internal.EclipseLinkJpaPlatformFactory2_4;
 import org.eclipse.jpt.jpa.eclipselink.core.internal.context.EclipseLinkTenantDiscriminatorColumnValidator2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.internal.resource.java.EclipseLinkNullTenantDiscriminatorColumnAnnotation2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.resource.java.MultitenantAnnotation2_3;
@@ -267,7 +267,7 @@ public class EclipseLinkJavaMultitenancyImpl2_3
 	// ********** specified tenant discriminator columns **********
 
 	public ListIterable<EclipseLinkJavaSpecifiedTenantDiscriminatorColumn2_3> getSpecifiedTenantDiscriminatorColumns() {
-		return this.specifiedTenantDiscriminatorColumnContainer.getContextElements();
+		return this.specifiedTenantDiscriminatorColumnContainer;
 	}
 
 	protected ListIterable<EclipseLinkTenantDiscriminatorColumn2_3> getReadOnlySpecifiedTenantDiscriminatorColumns() {
@@ -275,7 +275,7 @@ public class EclipseLinkJavaMultitenancyImpl2_3
 	}
 
 	public int getSpecifiedTenantDiscriminatorColumnsSize() {
-		return this.specifiedTenantDiscriminatorColumnContainer.getContextElementsSize();
+		return this.specifiedTenantDiscriminatorColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedTenantDiscriminatorColumns() {
@@ -292,17 +292,17 @@ public class EclipseLinkJavaMultitenancyImpl2_3
 	}
 
 	public void removeSpecifiedTenantDiscriminatorColumn(EclipseLinkSpecifiedTenantDiscriminatorColumn2_3 tenantDiscriminatorColumn) {
-		this.removeSpecifiedTenantDiscriminatorColumn(this.specifiedTenantDiscriminatorColumnContainer.indexOfContextElement((EclipseLinkJavaSpecifiedTenantDiscriminatorColumn2_3) tenantDiscriminatorColumn));
+		this.removeSpecifiedTenantDiscriminatorColumn(this.specifiedTenantDiscriminatorColumnContainer.indexOf((EclipseLinkJavaSpecifiedTenantDiscriminatorColumn2_3) tenantDiscriminatorColumn));
 	}
 
 	public void removeSpecifiedTenantDiscriminatorColumn(int index) {
 		this.removeTenantDiscriminatorColumnAnnotation(index);
-		this.specifiedTenantDiscriminatorColumnContainer.removeContextElement(index);
+		this.specifiedTenantDiscriminatorColumnContainer.remove(index);
 	}
 
 	public void moveSpecifiedTenantDiscriminatorColumn(int targetIndex, int sourceIndex) {
 		this.moveTenantDiscriminatorColumnAnnotation(targetIndex, sourceIndex);
-		this.specifiedTenantDiscriminatorColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedTenantDiscriminatorColumnContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected EclipseLinkJavaSpecifiedTenantDiscriminatorColumn2_3 buildTenantDiscriminatorColumn(TenantDiscriminatorColumnAnnotation2_3 discriminatorColumnAnnotation) {
@@ -318,44 +318,35 @@ public class EclipseLinkJavaMultitenancyImpl2_3
 	}
 
 	protected ContextListContainer<EclipseLinkJavaSpecifiedTenantDiscriminatorColumn2_3, TenantDiscriminatorColumnAnnotation2_3> buildSpecifiedTenantDiscriminatorColumnContainer() {
-		SpecifiedTenantDiscriminatorColumnContainer container = new SpecifiedTenantDiscriminatorColumnContainer();
-		container.initialize();
-		return container;
-	}
-
-	protected EclipseLinkTenantDiscriminatorColumn2_3.ParentAdapter buildTenantDiscriminatorColumnParentAdapter() {
-		return new TenantDiscriminatorColumnParentAdapter();
+		return this.buildSpecifiedContextListContainer(SPECIFIED_TENANT_DISCRIMINATOR_COLUMNS_LIST, new SpecifiedTenantDiscriminatorColumnContainerAdapter());
 	}
 
 	/**
-	 * specified tenant discriminator column container
+	 * specified tenant discriminator column container adapter
 	 */
-	protected class SpecifiedTenantDiscriminatorColumnContainer
-		extends ContextListContainer<EclipseLinkJavaSpecifiedTenantDiscriminatorColumn2_3, TenantDiscriminatorColumnAnnotation2_3>
+	public class SpecifiedTenantDiscriminatorColumnContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkJavaSpecifiedTenantDiscriminatorColumn2_3, TenantDiscriminatorColumnAnnotation2_3>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_TENANT_DISCRIMINATOR_COLUMNS_LIST;
-		}
-		@Override
-		protected EclipseLinkJavaSpecifiedTenantDiscriminatorColumn2_3 buildContextElement(TenantDiscriminatorColumnAnnotation2_3 resourceElement) {
+		public EclipseLinkJavaSpecifiedTenantDiscriminatorColumn2_3 buildContextElement(TenantDiscriminatorColumnAnnotation2_3 resourceElement) {
 			return EclipseLinkJavaMultitenancyImpl2_3.this.buildTenantDiscriminatorColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<TenantDiscriminatorColumnAnnotation2_3> getResourceElements() {
+		public ListIterable<TenantDiscriminatorColumnAnnotation2_3> getResourceElements() {
 			return EclipseLinkJavaMultitenancyImpl2_3.this.getTenantDiscriminatorColumnAnnotations();
 		}
-		@Override
-		protected TenantDiscriminatorColumnAnnotation2_3 getResourceElement(EclipseLinkJavaSpecifiedTenantDiscriminatorColumn2_3 contextElement) {
+		public TenantDiscriminatorColumnAnnotation2_3 extractResourceElement(EclipseLinkJavaSpecifiedTenantDiscriminatorColumn2_3 contextElement) {
 			return contextElement.getColumnAnnotation();
 		}
 	}
 
+	protected EclipseLinkTenantDiscriminatorColumn2_3.ParentAdapter buildTenantDiscriminatorColumnParentAdapter() {
+		return new TenantDiscriminatorColumnParentAdapter();
+	}
+
 
 	// ********** default tenant discriminator columns **********
 
 	public ListIterable<EclipseLinkVirtualTenantDiscriminatorColumn2_3> getDefaultTenantDiscriminatorColumns() {
-		return this.defaultTenantDiscriminatorColumnContainer.getContextElements();
+		return this.defaultTenantDiscriminatorColumnContainer;
 	}
 
 	protected ListIterable<EclipseLinkTenantDiscriminatorColumn2_3> getReadOnlyDefaultTenantDiscriminatorColumns() {
@@ -363,11 +354,11 @@ public class EclipseLinkJavaMultitenancyImpl2_3
 	}
 
 	public int getDefaultTenantDiscriminatorColumnsSize() {
-		return this.defaultTenantDiscriminatorColumnContainer.getContextElementsSize();
+		return this.defaultTenantDiscriminatorColumnContainer.size();
 	}
 
 	protected void clearDefaultTenantDiscriminatorColumns() {
-		this.defaultTenantDiscriminatorColumnContainer.clearContextList();
+		this.defaultTenantDiscriminatorColumnContainer.clear();
 	}
 
 	/**
@@ -379,10 +370,6 @@ public class EclipseLinkJavaMultitenancyImpl2_3
 		this.defaultTenantDiscriminatorColumnContainer.update();
 	}
 
-	protected ContextListContainer<EclipseLinkVirtualTenantDiscriminatorColumn2_3, EclipseLinkTenantDiscriminatorColumn2_3> buildDefaultTenantDiscriminatorColumnContainer() {
-		return new DefaultTenantDiscriminatorColumnContainer();
-	}
-
 	protected EclipseLinkVirtualTenantDiscriminatorColumn2_3 buildVirtualTenantDiscriminatorColumn(EclipseLinkTenantDiscriminatorColumn2_3 tenantDiscriminatorColumn) {
 		return new EclipseLinkJavaVirtualTenantDiscriminatorColumn2_3(this.tenantDiscriminatorColumnParentAdapter, tenantDiscriminatorColumn);
 	}
@@ -429,27 +416,23 @@ public class EclipseLinkJavaMultitenancyImpl2_3
 		return this.parent.isMultitenantMetadataAllowed();
 	}
 
+	protected ContextListContainer<EclipseLinkVirtualTenantDiscriminatorColumn2_3, EclipseLinkTenantDiscriminatorColumn2_3> buildDefaultTenantDiscriminatorColumnContainer() {
+		return this.buildVirtualContextListContainer(DEFAULT_TENANT_DISCRIMINATOR_COLUMNS_LIST, new DefaultTenantDiscriminatorColumnContainerAdapter());
+	}
 
 	/**
-	 * default tenant discriminator column container
+	 * default tenant discriminator column container adapter
 	 */
-	protected class DefaultTenantDiscriminatorColumnContainer
-		extends ContextListContainer<EclipseLinkVirtualTenantDiscriminatorColumn2_3, EclipseLinkTenantDiscriminatorColumn2_3>
+	public class DefaultTenantDiscriminatorColumnContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkVirtualTenantDiscriminatorColumn2_3, EclipseLinkTenantDiscriminatorColumn2_3>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return DEFAULT_TENANT_DISCRIMINATOR_COLUMNS_LIST;
-		}
-		@Override
-		protected EclipseLinkVirtualTenantDiscriminatorColumn2_3 buildContextElement(EclipseLinkTenantDiscriminatorColumn2_3 resourceElement) {
+		public EclipseLinkVirtualTenantDiscriminatorColumn2_3 buildContextElement(EclipseLinkTenantDiscriminatorColumn2_3 resourceElement) {
 			return EclipseLinkJavaMultitenancyImpl2_3.this.buildVirtualTenantDiscriminatorColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<EclipseLinkTenantDiscriminatorColumn2_3> getResourceElements() {
+		public ListIterable<EclipseLinkTenantDiscriminatorColumn2_3> getResourceElements() {
 			return EclipseLinkJavaMultitenancyImpl2_3.this.getTenantDiscriminatorColumnsForDefaults();
 		}
-		@Override
-		protected EclipseLinkTenantDiscriminatorColumn2_3 getResourceElement(EclipseLinkVirtualTenantDiscriminatorColumn2_3 contextElement) {
+		public EclipseLinkTenantDiscriminatorColumn2_3 extractResourceElement(EclipseLinkVirtualTenantDiscriminatorColumn2_3 contextElement) {
 			return contextElement.getOverriddenColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/java/EclipseLinkJavaObjectTypeConverter.java b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/java/EclipseLinkJavaObjectTypeConverter.java
index e4bb9d447a..3a4ce8f5a5 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/java/EclipseLinkJavaObjectTypeConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/java/EclipseLinkJavaObjectTypeConverter.java
@@ -139,11 +139,11 @@ public class EclipseLinkJavaObjectTypeConverter
 	// ********** conversion values **********
 
 	public ListIterable<EclipseLinkJavaConversionValue> getConversionValues() {
-		return this.conversionValueContainer.getContextElements();
+		return this.conversionValueContainer;
 	}
 
 	public int getConversionValuesSize() {
-		return this.conversionValueContainer.getContextElementsSize();
+		return this.conversionValueContainer.size();
 	}
 
 	public EclipseLinkConversionValue getConversionValue(int index) {
@@ -160,17 +160,17 @@ public class EclipseLinkJavaObjectTypeConverter
 	}
   
 	public void removeConversionValue(EclipseLinkConversionValue conversionValue) {
-		this.removeConversionValue(this.conversionValueContainer.indexOfContextElement((EclipseLinkJavaConversionValue) conversionValue));
+		this.removeConversionValue(this.conversionValueContainer.indexOf((EclipseLinkJavaConversionValue) conversionValue));
 	}
 
 	public void removeConversionValue(int index) {
 		this.converterAnnotation.removeConversionValue(index);
-		this.conversionValueContainer.removeContextElement(index);
+		this.conversionValueContainer.remove(index);
 	}
 
 	public void moveConversionValue(int targetIndex, int sourceIndex) {
 		this.converterAnnotation.moveConversionValue(targetIndex, sourceIndex);
-		this.conversionValueContainer.moveContextElement(targetIndex, sourceIndex);
+		this.conversionValueContainer.move(targetIndex, sourceIndex);
 	}
 
 	protected EclipseLinkJavaConversionValue buildConversionValue(ConversionValueAnnotation conversionValueAnnotation) {
@@ -186,34 +186,22 @@ public class EclipseLinkJavaObjectTypeConverter
 	}
 
 	protected ContextListContainer<EclipseLinkJavaConversionValue, ConversionValueAnnotation> buildConversionValueContainer() {
-		ConversionValueContainer container = new ConversionValueContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(CONVERSION_VALUES_LIST, new ConversionValueContainerAdapter());
 	}
 
 	/**
-	 * conversion value container
+	 * conversion value container adapter
 	 */
-	protected class ConversionValueContainer
-			extends ContextListContainer<EclipseLinkJavaConversionValue, ConversionValueAnnotation> {
-		
-		@Override
-		protected String getContextElementsPropertyName() {
-			return CONVERSION_VALUES_LIST;
-		}
-		
-		@Override
-		protected EclipseLinkJavaConversionValue buildContextElement(ConversionValueAnnotation resourceElement) {
+	public class ConversionValueContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkJavaConversionValue, ConversionValueAnnotation>
+	{
+		public EclipseLinkJavaConversionValue buildContextElement(ConversionValueAnnotation resourceElement) {
 			return EclipseLinkJavaObjectTypeConverter.this.buildConversionValue(resourceElement);
 		}
-		
-		@Override
-		protected ListIterable<ConversionValueAnnotation> getResourceElements() {
+		public ListIterable<ConversionValueAnnotation> getResourceElements() {
 			return EclipseLinkJavaObjectTypeConverter.this.getConversionValueAnnotations();
 		}
-		
-		@Override
-		protected ConversionValueAnnotation getResourceElement(EclipseLinkJavaConversionValue contextElement) {
+		public ConversionValueAnnotation extractResourceElement(EclipseLinkJavaConversionValue contextElement) {
 			return contextElement.getConversionValueAnnotation();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkAbstractOrmConverterContainer.java b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkAbstractOrmConverterContainer.java
index 51250401c4..51fe6888bf 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkAbstractOrmConverterContainer.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkAbstractOrmConverterContainer.java
@@ -80,11 +80,11 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 	// ********** custom converters **********
 
 	public ListIterable<EclipseLinkOrmCustomConverter> getCustomConverters() {
-		return this.customConverterContainer.getContextElements();
+		return this.customConverterContainer;
 	}
 
 	public int getCustomConvertersSize() {
-		return this.customConverterContainer.getContextElementsSize();
+		return this.customConverterContainer.size();
 	}
 
 	public EclipseLinkOrmCustomConverter addCustomConverter(String name) {
@@ -105,16 +105,16 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 	}
 
 	public void removeCustomConverter(EclipseLinkCustomConverter converter) {
-		this.removeCustomConverter(this.customConverterContainer.indexOfContextElement((EclipseLinkOrmCustomConverter) converter));
+		this.removeCustomConverter(this.customConverterContainer.indexOf((EclipseLinkOrmCustomConverter) converter));
 	}
 
 	public void removeCustomConverter(int index) {
-		this.customConverterContainer.removeContextElement(index);
+		this.customConverterContainer.remove(index);
 		this.xmlConverterContainer.getConverters().remove(index);
 	}
 
 	public void moveCustomConverter(int targetIndex, int sourceIndex) {
-		this.customConverterContainer.moveContextElement(targetIndex, sourceIndex);
+		this.customConverterContainer.move(targetIndex, sourceIndex);
 		this.xmlConverterContainer.getConverters().move(targetIndex, sourceIndex);
 	}
 
@@ -136,31 +136,22 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 	}
 
 	protected ContextListContainer<EclipseLinkOrmCustomConverter, XmlConverter> buildCustomConverterContainer() {
-		CustomConverterContainer container = new CustomConverterContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(CUSTOM_CONVERTERS_LIST, new CustomConverterContainerAdapter());
 	}
 
 	/**
-	 * custom converter container
+	 * custom converter container adapter
 	 */
-	protected class CustomConverterContainer
-		extends ContextListContainer<EclipseLinkOrmCustomConverter, XmlConverter>
+	public class CustomConverterContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkOrmCustomConverter, XmlConverter>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return CUSTOM_CONVERTERS_LIST;
-		}
-		@Override
-		protected EclipseLinkOrmCustomConverter buildContextElement(XmlConverter resourceElement) {
+		public EclipseLinkOrmCustomConverter buildContextElement(XmlConverter resourceElement) {
 			return EclipseLinkAbstractOrmConverterContainer.this.buildCustomConverter(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlConverter> getResourceElements() {
+		public ListIterable<XmlConverter> getResourceElements() {
 			return EclipseLinkAbstractOrmConverterContainer.this.getXmlCustomConverters();
 		}
-		@Override
-		protected XmlConverter getResourceElement(EclipseLinkOrmCustomConverter contextElement) {
+		public XmlConverter extractResourceElement(EclipseLinkOrmCustomConverter contextElement) {
 			return contextElement.getXmlConverter();
 		}
 	}
@@ -169,11 +160,11 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 	// ********** object type converters **********
 
 	public ListIterable<EclipseLinkOrmObjectTypeConverter> getObjectTypeConverters() {
-		return this.objectTypeConverterContainer.getContextElements();
+		return this.objectTypeConverterContainer;
 	}
 
 	public int getObjectTypeConvertersSize() {
-		return this.objectTypeConverterContainer.getContextElementsSize();
+		return this.objectTypeConverterContainer.size();
 	}
 
 	public EclipseLinkOrmObjectTypeConverter addObjectTypeConverter(String name) {
@@ -194,16 +185,16 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 	}
 
 	public void removeObjectTypeConverter(EclipseLinkObjectTypeConverter converter) {
-		this.removeObjectTypeConverter(this.objectTypeConverterContainer.indexOfContextElement((EclipseLinkOrmObjectTypeConverter) converter));
+		this.removeObjectTypeConverter(this.objectTypeConverterContainer.indexOf((EclipseLinkOrmObjectTypeConverter) converter));
 	}
 
 	public void removeObjectTypeConverter(int index) {
-		this.objectTypeConverterContainer.removeContextElement(index);
+		this.objectTypeConverterContainer.remove(index);
 		this.xmlConverterContainer.getObjectTypeConverters().remove(index);
 	}
 
 	public void moveObjectTypeConverter(int targetIndex, int sourceIndex) {
-		this.objectTypeConverterContainer.moveContextElement(targetIndex, sourceIndex);
+		this.objectTypeConverterContainer.move(targetIndex, sourceIndex);
 		this.xmlConverterContainer.getObjectTypeConverters().move(targetIndex, sourceIndex);
 	}
 
@@ -221,31 +212,22 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 	}
 
 	protected ContextListContainer<EclipseLinkOrmObjectTypeConverter, XmlObjectTypeConverter> buildObjectTypeConverterContainer() {
-		ObjectTypeConverterContainer container = new ObjectTypeConverterContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(OBJECT_TYPE_CONVERTERS_LIST, new ObjectTypeConverterContainerAdapter());
 	}
 
 	/**
-	 * object type converter container
+	 * object type converter container adapter
 	 */
-	protected class ObjectTypeConverterContainer
-		extends ContextListContainer<EclipseLinkOrmObjectTypeConverter, XmlObjectTypeConverter>
+	public class ObjectTypeConverterContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkOrmObjectTypeConverter, XmlObjectTypeConverter>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return OBJECT_TYPE_CONVERTERS_LIST;
-		}
-		@Override
-		protected EclipseLinkOrmObjectTypeConverter buildContextElement(XmlObjectTypeConverter resourceElement) {
+		public EclipseLinkOrmObjectTypeConverter buildContextElement(XmlObjectTypeConverter resourceElement) {
 			return EclipseLinkAbstractOrmConverterContainer.this.buildObjectTypeConverter(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlObjectTypeConverter> getResourceElements() {
+		public ListIterable<XmlObjectTypeConverter> getResourceElements() {
 			return EclipseLinkAbstractOrmConverterContainer.this.getXmlObjectTypeConverters();
 		}
-		@Override
-		protected XmlObjectTypeConverter getResourceElement(EclipseLinkOrmObjectTypeConverter contextElement) {
+		public XmlObjectTypeConverter extractResourceElement(EclipseLinkOrmObjectTypeConverter contextElement) {
 			return contextElement.getXmlConverter();
 		}
 	}
@@ -253,11 +235,11 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 	// ********** struct converters **********
 
 	public ListIterable<EclipseLinkOrmStructConverter> getStructConverters() {
-		return this.structConverterContainer.getContextElements();
+		return this.structConverterContainer;
 	}
 
 	public int getStructConvertersSize() {
-		return this.structConverterContainer.getContextElementsSize();
+		return this.structConverterContainer.size();
 	}
 
 	public EclipseLinkOrmStructConverter addStructConverter(String name) {
@@ -278,16 +260,16 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 	}
 
 	public void removeStructConverter(EclipseLinkStructConverter converter) {
-		this.removeStructConverter(this.structConverterContainer.indexOfContextElement((EclipseLinkOrmStructConverter) converter));
+		this.removeStructConverter(this.structConverterContainer.indexOf((EclipseLinkOrmStructConverter) converter));
 	}
 
 	public void removeStructConverter(int index) {
-		this.structConverterContainer.removeContextElement(index);
+		this.structConverterContainer.remove(index);
 		this.xmlConverterContainer.getStructConverters().remove(index);
 	}
 
 	public void moveStructConverter(int targetIndex, int sourceIndex) {
-		this.structConverterContainer.moveContextElement(targetIndex, sourceIndex);
+		this.structConverterContainer.move(targetIndex, sourceIndex);
 		this.xmlConverterContainer.getStructConverters().move(targetIndex, sourceIndex);
 	}
 
@@ -305,31 +287,22 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 	}
 
 	protected ContextListContainer<EclipseLinkOrmStructConverter, XmlStructConverter> buildStructConverterContainer() {
-		StructConverterContainer container = new StructConverterContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(STRUCT_CONVERTERS_LIST, new StructConverterContainerAdapter());
 	}
 
 	/**
-	 * struct converter container
+	 * struct converter container adapter
 	 */
-	protected class StructConverterContainer
-		extends ContextListContainer<EclipseLinkOrmStructConverter, XmlStructConverter>
+	public class StructConverterContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkOrmStructConverter, XmlStructConverter>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return STRUCT_CONVERTERS_LIST;
-		}
-		@Override
-		protected EclipseLinkOrmStructConverter buildContextElement(XmlStructConverter resourceElement) {
+		public EclipseLinkOrmStructConverter buildContextElement(XmlStructConverter resourceElement) {
 			return EclipseLinkAbstractOrmConverterContainer.this.buildStructConverter(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlStructConverter> getResourceElements() {
+		public ListIterable<XmlStructConverter> getResourceElements() {
 			return EclipseLinkAbstractOrmConverterContainer.this.getXmlStructConverters();
 		}
-		@Override
-		protected XmlStructConverter getResourceElement(EclipseLinkOrmStructConverter contextElement) {
+		public XmlStructConverter extractResourceElement(EclipseLinkOrmStructConverter contextElement) {
 			return contextElement.getXmlConverter();
 		}
 	}
@@ -338,11 +311,11 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 	// ********** type converters **********
 
 	public ListIterable<EclipseLinkOrmTypeConverter> getTypeConverters() {
-		return this.typeConverterContainer.getContextElements();
+		return this.typeConverterContainer;
 	}
 
 	public int getTypeConvertersSize() {
-		return this.typeConverterContainer.getContextElementsSize();
+		return this.typeConverterContainer.size();
 	}
 
 	public EclipseLinkOrmTypeConverter addTypeConverter(String name) {
@@ -363,16 +336,16 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 	}
 
 	public void removeTypeConverter(EclipseLinkTypeConverter converter) {
-		this.removeTypeConverter(this.typeConverterContainer.indexOfContextElement((EclipseLinkOrmTypeConverter) converter));
+		this.removeTypeConverter(this.typeConverterContainer.indexOf((EclipseLinkOrmTypeConverter) converter));
 	}
 
 	public void removeTypeConverter(int index) {
-		this.typeConverterContainer.removeContextElement(index);
+		this.typeConverterContainer.remove(index);
 		this.xmlConverterContainer.getTypeConverters().remove(index);
 	}
 
 	public void moveTypeConverter(int targetIndex, int sourceIndex) {
-		this.typeConverterContainer.moveContextElement(targetIndex, sourceIndex);
+		this.typeConverterContainer.move(targetIndex, sourceIndex);
 		this.xmlConverterContainer.getTypeConverters().move(targetIndex, sourceIndex);
 	}
 
@@ -390,31 +363,22 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 	}
 
 	protected ContextListContainer<EclipseLinkOrmTypeConverter, XmlTypeConverter> buildTypeConverterContainer() {
-		TypeConverterContainer container = new TypeConverterContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(TYPE_CONVERTERS_LIST, new TypeConverterContainerAdapter());
 	}
 
 	/**
-	 * type converter container
+	 * type converter container adapter
 	 */
-	protected class TypeConverterContainer
-		extends ContextListContainer<EclipseLinkOrmTypeConverter, XmlTypeConverter>
+	public class TypeConverterContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkOrmTypeConverter, XmlTypeConverter>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return TYPE_CONVERTERS_LIST;
-		}
-		@Override
-		protected EclipseLinkOrmTypeConverter buildContextElement(XmlTypeConverter resourceElement) {
+		public EclipseLinkOrmTypeConverter buildContextElement(XmlTypeConverter resourceElement) {
 			return EclipseLinkAbstractOrmConverterContainer.this.buildTypeConverter(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlTypeConverter> getResourceElements() {
+		public ListIterable<XmlTypeConverter> getResourceElements() {
 			return EclipseLinkAbstractOrmConverterContainer.this.getXmlTypeConverters();
 		}
-		@Override
-		protected XmlTypeConverter getResourceElement(EclipseLinkOrmTypeConverter contextElement) {
+		public XmlTypeConverter extractResourceElement(EclipseLinkOrmTypeConverter contextElement) {
 			return contextElement.getXmlConverter();
 		}
 	}
@@ -548,25 +512,25 @@ public abstract class EclipseLinkAbstractOrmConverterContainer
 		if (result != null) {
 			return result;
 		}
-		for (EclipseLinkOrmCustomConverter converter : this.customConverterContainer.getContextElements()) {
+		for (EclipseLinkOrmCustomConverter converter : this.customConverterContainer) {
 			result = converter.getCompletionProposals(pos);
 			if (result != null) {
 				return result;
 			}
 		}
-		for (EclipseLinkOrmStructConverter converter : this.structConverterContainer.getContextElements()) {
+		for (EclipseLinkOrmStructConverter converter : this.structConverterContainer) {
 			result = converter.getCompletionProposals(pos);
 			if (result != null) {
 				return result;
 			}
 		}
-		for (EclipseLinkOrmObjectTypeConverter converter : this.objectTypeConverterContainer.getContextElements()) {
+		for (EclipseLinkOrmObjectTypeConverter converter : this.objectTypeConverterContainer) {
 			result = converter.getCompletionProposals(pos);
 			if (result != null) {
 				return result;
 			}
 		}
-		for (EclipseLinkOrmTypeConverter converter : this.typeConverterContainer.getContextElements()) {
+		for (EclipseLinkOrmTypeConverter converter : this.typeConverterContainer) {
 			result = converter.getCompletionProposals(pos);
 			if (result != null) {
 				return result;
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkEntityMappingsImpl.java b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkEntityMappingsImpl.java
index 5e6744317e..d51ebf6a0a 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkEntityMappingsImpl.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkEntityMappingsImpl.java
@@ -32,13 +32,13 @@ import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractEntityMappings;
 import org.eclipse.jpt.jpa.core.resource.orm.XmlConverter;
 import org.eclipse.jpt.jpa.db.Table;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkConverter;
-import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkTypeMapping;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkTenantDiscriminatorColumn2_3;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkTypeMapping;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkVirtualTenantDiscriminatorColumn2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkEntityMappings;
-import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkOrmTypeMapping;
 import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkOrmConverterContainer;
 import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3;
+import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkOrmTypeMapping;
 import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkOrmUuidGenerator;
 import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit;
 import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.EclipseLinkOrmFactory;
@@ -194,7 +194,7 @@ public class EclipseLinkEntityMappingsImpl
 	// ********** specified tenant discriminator columns **********
 
 	public ListIterable<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3> getSpecifiedTenantDiscriminatorColumns() {
-		return this.specifiedTenantDiscriminatorColumnContainer.getContextElements();
+		return this.specifiedTenantDiscriminatorColumnContainer;
 	}
 
 	protected ListIterable<EclipseLinkTenantDiscriminatorColumn2_3> getReadOnlySpecifiedTenantDiscriminatorColumns() {
@@ -202,7 +202,7 @@ public class EclipseLinkEntityMappingsImpl
 	}
 
 	public int getSpecifiedTenantDiscriminatorColumnsSize() {
-		return this.specifiedTenantDiscriminatorColumnContainer.getContextElementsSize();
+		return this.specifiedTenantDiscriminatorColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedTenantDiscriminatorColumns() {
@@ -210,7 +210,7 @@ public class EclipseLinkEntityMappingsImpl
 	}
 
 	public EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 getSpecifiedTenantDiscriminatorColumn(int index) {
-		return this.specifiedTenantDiscriminatorColumnContainer.getContextElement(index);
+		return this.specifiedTenantDiscriminatorColumnContainer.get(index);
 	}
 
 	public EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 addSpecifiedTenantDiscriminatorColumn() {
@@ -229,16 +229,16 @@ public class EclipseLinkEntityMappingsImpl
 	}
 
 	public void removeSpecifiedTenantDiscriminatorColumn(EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 tenantDiscriminatorColumn) {
-		this.removeSpecifiedTenantDiscriminatorColumn(this.specifiedTenantDiscriminatorColumnContainer.indexOfContextElement(tenantDiscriminatorColumn));
+		this.removeSpecifiedTenantDiscriminatorColumn(this.specifiedTenantDiscriminatorColumnContainer.indexOf(tenantDiscriminatorColumn));
 	}
 
 	public void removeSpecifiedTenantDiscriminatorColumn(int index) {
-		this.specifiedTenantDiscriminatorColumnContainer.removeContextElement(index);
+		this.specifiedTenantDiscriminatorColumnContainer.remove(index);
 		this.getXmlEntityMappings().getTenantDiscriminatorColumns().remove(index);
 	}
 
 	public void moveSpecifiedTenantDiscriminatorColumn(int targetIndex, int sourceIndex) {
-		this.specifiedTenantDiscriminatorColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedTenantDiscriminatorColumnContainer.move(targetIndex, sourceIndex);
 		this.getXmlEntityMappings().getTenantDiscriminatorColumns().move(targetIndex, sourceIndex);
 	}
 
@@ -254,26 +254,23 @@ public class EclipseLinkEntityMappingsImpl
 		return IterableTools.cloneLive(this.getXmlEntityMappings().getTenantDiscriminatorColumns());
 	}
 
+	protected ContextListContainer<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3, XmlTenantDiscriminatorColumn> buildSpecifiedTenantDiscriminatorColumnContainer() {
+		return this.buildSpecifiedContextListContainer(SPECIFIED_TENANT_DISCRIMINATOR_COLUMNS_LIST, new SpecifiedTenantDiscriminatorColumnContainerAdapter());
+	}
+
 	/**
-	 *  specified tenant discriminator column container
+	 * specified tenant discriminator column container adapter
 	 */
-	protected class SpecifiedTenantDiscriminatorColumnContainer
-		extends ContextListContainer<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3, XmlTenantDiscriminatorColumn>
+	public class SpecifiedTenantDiscriminatorColumnContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3, XmlTenantDiscriminatorColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_TENANT_DISCRIMINATOR_COLUMNS_LIST;
-		}
-		@Override
-		protected EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 buildContextElement(XmlTenantDiscriminatorColumn resourceElement) {
+		public EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 buildContextElement(XmlTenantDiscriminatorColumn resourceElement) {
 			return EclipseLinkEntityMappingsImpl.this.buildTenantDiscriminatorColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlTenantDiscriminatorColumn> getResourceElements() {
+		public ListIterable<XmlTenantDiscriminatorColumn> getResourceElements() {
 			return EclipseLinkEntityMappingsImpl.this.getXmlTenantDiscriminatorColumns();
 		}
-		@Override
-		protected XmlTenantDiscriminatorColumn getResourceElement(EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 contextElement) {
+		public XmlTenantDiscriminatorColumn extractResourceElement(EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 contextElement) {
 			return contextElement.getXmlColumn();
 		}
 	}
@@ -282,12 +279,6 @@ public class EclipseLinkEntityMappingsImpl
 		return new TenantDiscriminatorColumnParentAdapter();
 	}
 
-	protected SpecifiedTenantDiscriminatorColumnContainer buildSpecifiedTenantDiscriminatorColumnContainer() {
-		SpecifiedTenantDiscriminatorColumnContainer container = new SpecifiedTenantDiscriminatorColumnContainer();
-		container.initialize();
-		return container;
-	}
-
 	protected EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 buildTenantDiscriminatorColumn(XmlTenantDiscriminatorColumn xmlTenantDiscriminatorColumn) {
 		return new EclipseLinkOrmTenantDiscriminatorColumn2_3(this.tenantDiscriminatorColumnParentAdapter, xmlTenantDiscriminatorColumn);
 	}
@@ -296,7 +287,7 @@ public class EclipseLinkEntityMappingsImpl
 	// ********** default tenant discriminator columns **********
 
 	public ListIterable<EclipseLinkVirtualTenantDiscriminatorColumn2_3> getDefaultTenantDiscriminatorColumns() {
-		return this.defaultTenantDiscriminatorColumnContainer.getContextElements();
+		return this.defaultTenantDiscriminatorColumnContainer;
 	}
 
 	protected ListIterable<EclipseLinkTenantDiscriminatorColumn2_3> getReadOnlyDefaultTenantDiscriminatorColumns() {
@@ -304,11 +295,11 @@ public class EclipseLinkEntityMappingsImpl
 	}
 
 	public int getDefaultTenantDiscriminatorColumnsSize() {
-		return this.defaultTenantDiscriminatorColumnContainer.getContextElementsSize();
+		return this.defaultTenantDiscriminatorColumnContainer.size();
 	}
 
 	protected void clearDefaultTenantDiscriminatorColumns() {
-		this.defaultTenantDiscriminatorColumnContainer.clearContextList();
+		this.defaultTenantDiscriminatorColumnContainer.clear();
 	}
 
 	/**
@@ -332,7 +323,7 @@ public class EclipseLinkEntityMappingsImpl
 	}
 	
 	protected void moveDefaultTenantDiscriminatorColumn(int index, EclipseLinkVirtualTenantDiscriminatorColumn2_3 tenantDiscriminatorColumn) {
-		this.defaultTenantDiscriminatorColumnContainer.moveContextElement(index, tenantDiscriminatorColumn);
+		this.defaultTenantDiscriminatorColumnContainer.move(index, tenantDiscriminatorColumn);
 	}
 
 	protected EclipseLinkVirtualTenantDiscriminatorColumn2_3 addDefaultTenantDiscriminatorColumn(int index, EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 ormTenantDiscriminatorColumn) {
@@ -344,34 +335,26 @@ public class EclipseLinkEntityMappingsImpl
 	}
 
 	protected void removeDefaultTenantDiscriminatorColumn(EclipseLinkVirtualTenantDiscriminatorColumn2_3 tenantDiscriminatorColumn) {
-		this.defaultTenantDiscriminatorColumnContainer.removeContextElement(tenantDiscriminatorColumn);
+		this.defaultTenantDiscriminatorColumnContainer.remove(tenantDiscriminatorColumn);
 	}
 
-	protected DefaultTenantDiscriminatorColumnContainer buildDefaultTenantDiscriminatorColumnContainer() {
-		return new DefaultTenantDiscriminatorColumnContainer();
+	protected ContextListContainer<EclipseLinkVirtualTenantDiscriminatorColumn2_3, EclipseLinkTenantDiscriminatorColumn2_3> buildDefaultTenantDiscriminatorColumnContainer() {
+		return this.buildVirtualContextListContainer(DEFAULT_TENANT_DISCRIMINATOR_COLUMNS_LIST, new DefaultTenantDiscriminatorColumnContainerAdapter());
 	}
 
-
 	/**
-	 * default tenant discriminator column container
+	 * default tenant discriminator column container adapter
 	 */
-	protected class DefaultTenantDiscriminatorColumnContainer
-		extends ContextListContainer<EclipseLinkVirtualTenantDiscriminatorColumn2_3, EclipseLinkTenantDiscriminatorColumn2_3>
+	public class DefaultTenantDiscriminatorColumnContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkVirtualTenantDiscriminatorColumn2_3, EclipseLinkTenantDiscriminatorColumn2_3>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return DEFAULT_TENANT_DISCRIMINATOR_COLUMNS_LIST;
-		}
-		@Override
-		protected EclipseLinkVirtualTenantDiscriminatorColumn2_3 buildContextElement(EclipseLinkTenantDiscriminatorColumn2_3 resourceElement) {
+		public EclipseLinkVirtualTenantDiscriminatorColumn2_3 buildContextElement(EclipseLinkTenantDiscriminatorColumn2_3 resourceElement) {
 			return EclipseLinkEntityMappingsImpl.this.buildVirtualTenantDiscriminatorColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<EclipseLinkTenantDiscriminatorColumn2_3> getResourceElements() {
+		public ListIterable<EclipseLinkTenantDiscriminatorColumn2_3> getResourceElements() {
 			return EclipseLinkEntityMappingsImpl.this.getTenantDiscriminatorColumnsForDefaults();
 		}
-		@Override
-		protected EclipseLinkTenantDiscriminatorColumn2_3 getResourceElement(EclipseLinkVirtualTenantDiscriminatorColumn2_3 contextElement) {
+		public EclipseLinkTenantDiscriminatorColumn2_3 extractResourceElement(EclipseLinkVirtualTenantDiscriminatorColumn2_3 contextElement) {
 			return contextElement.getOverriddenColumn();
 		}
 	}
@@ -566,11 +549,11 @@ public class EclipseLinkEntityMappingsImpl
 	// ********** uuid generators **********
 
 	public ListIterable<EclipseLinkOrmUuidGenerator> getUuidGenerators() {
-		return this.uuidGeneratorContainer.getContextElements();
+		return this.uuidGeneratorContainer;
 	}
 
 	public int getUuidGeneratorsSize() {
-		return this.uuidGeneratorContainer.getContextElementsSize();
+		return this.uuidGeneratorContainer.size();
 	}
 
 	public EclipseLinkOrmUuidGenerator addUuidGenerator() {
@@ -593,16 +576,16 @@ public class EclipseLinkEntityMappingsImpl
 	}
 
 	public void removeUuidGenerator(EclipseLinkOrmUuidGenerator uuidGenerator) {
-		this.removeUuidGenerator(this.uuidGeneratorContainer.indexOfContextElement(uuidGenerator));
+		this.removeUuidGenerator(this.uuidGeneratorContainer.indexOf(uuidGenerator));
 	}
 
 	public void removeUuidGenerator(int index) {
-		this.uuidGeneratorContainer.removeContextElement(index);
+		this.uuidGeneratorContainer.remove(index);
 		this.getXmlEntityMappings().getUuidGenerators().remove(index);
 	}
 
 	public void moveUuidGenerator(int targetIndex, int sourceIndex) {
-		this.sequenceGeneratorContainer.moveContextElement(targetIndex, sourceIndex);
+		this.sequenceGeneratorContainer.move(targetIndex, sourceIndex);
 		this.xmlEntityMappings.getSequenceGenerators().move(targetIndex, sourceIndex);
 	}
 
@@ -616,31 +599,22 @@ public class EclipseLinkEntityMappingsImpl
 	}
 
 	protected ContextListContainer<EclipseLinkOrmUuidGenerator, XmlUuidGenerator_2_4> buildUuidGeneratorContainer() {
-		UuidGeneratorContainer container = new UuidGeneratorContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(UUID_GENERATORS_LIST, new UuidGeneratorContainerAdapter());
 	}
 
 	/**
-	 * sequence generator container
+	 * UUID generator container adapter
 	 */
-	protected class UuidGeneratorContainer
-		extends ContextListContainer<EclipseLinkOrmUuidGenerator, XmlUuidGenerator_2_4>
+	public class UuidGeneratorContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkOrmUuidGenerator, XmlUuidGenerator_2_4>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return UUID_GENERATORS_LIST;
-		}
-		@Override
-		protected EclipseLinkOrmUuidGenerator buildContextElement(XmlUuidGenerator_2_4 resourceElement) {
+		public EclipseLinkOrmUuidGenerator buildContextElement(XmlUuidGenerator_2_4 resourceElement) {
 			return EclipseLinkEntityMappingsImpl.this.buildUuidGenerator(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlUuidGenerator_2_4> getResourceElements() {
+		public ListIterable<XmlUuidGenerator_2_4> getResourceElements() {
 			return EclipseLinkEntityMappingsImpl.this.getXmlUuidGenerators();
 		}
-		@Override
-		protected XmlUuidGenerator_2_4 getResourceElement(EclipseLinkOrmUuidGenerator contextElement) {
+		public XmlUuidGenerator_2_4 extractResourceElement(EclipseLinkOrmUuidGenerator contextElement) {
 			return contextElement.getXmlGenerator();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmMultitenancyImpl2_3.java b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmMultitenancyImpl2_3.java
index fe6c5874cc..a9822eda5a 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmMultitenancyImpl2_3.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmMultitenancyImpl2_3.java
@@ -30,8 +30,8 @@ import org.eclipse.jpt.jpa.db.Table;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkEntity;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkMappedSuperclass;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkMultitenantType2_3;
-import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkTenantDiscriminatorColumn2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkSpecifiedTenantDiscriminatorColumn2_3;
+import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkTenantDiscriminatorColumn2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkVirtualTenantDiscriminatorColumn2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.context.java.EclipseLinkJavaMultitenancy2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.context.java.EclipseLinkJavaNonEmbeddableTypeMapping;
@@ -42,8 +42,8 @@ import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkOrmNonEmbedda
 import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkPersistenceUnit;
 import org.eclipse.jpt.jpa.eclipselink.core.context.persistence.EclipseLinkTargetDatabase;
-import org.eclipse.jpt.jpa.eclipselink.core.internal.EclipseLinkJpaPlatformFactory2_4;
 import org.eclipse.jpt.jpa.eclipselink.core.internal.EclipseLinkJpaPlatformFactory.EclipseLinkJpaPlatformVersion;
+import org.eclipse.jpt.jpa.eclipselink.core.internal.EclipseLinkJpaPlatformFactory2_4;
 import org.eclipse.jpt.jpa.eclipselink.core.internal.context.EclipseLinkTenantDiscriminatorColumnValidator2_3;
 import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.EclipseLinkOrmFactory;
 import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlMultitenant;
@@ -288,7 +288,7 @@ public class EclipseLinkOrmMultitenancyImpl2_3
 	// ********** specified tenant discriminator columns **********
 
 	public ListIterable<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3> getSpecifiedTenantDiscriminatorColumns() {
-		return this.specifiedTenantDiscriminatorColumnContainer.getContextElements();
+		return this.specifiedTenantDiscriminatorColumnContainer;
 	}
 
 	protected ListIterable<EclipseLinkTenantDiscriminatorColumn2_3> getReadOnlySpecifiedTenantDiscriminatorColumns() {
@@ -296,7 +296,7 @@ public class EclipseLinkOrmMultitenancyImpl2_3
 	}
 
 	public int getSpecifiedTenantDiscriminatorColumnsSize() {
-		return this.specifiedTenantDiscriminatorColumnContainer.getContextElementsSize();
+		return this.specifiedTenantDiscriminatorColumnContainer.size();
 	}
 
 	public boolean hasSpecifiedTenantDiscriminatorColumns() {
@@ -319,16 +319,16 @@ public class EclipseLinkOrmMultitenancyImpl2_3
 	}
 
 	public void removeSpecifiedTenantDiscriminatorColumn(EclipseLinkSpecifiedTenantDiscriminatorColumn2_3 tenantDiscriminatorColumn) {
-		this.removeSpecifiedTenantDiscriminatorColumn(this.specifiedTenantDiscriminatorColumnContainer.indexOfContextElement((EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3) tenantDiscriminatorColumn));
+		this.removeSpecifiedTenantDiscriminatorColumn(this.specifiedTenantDiscriminatorColumnContainer.indexOf((EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3) tenantDiscriminatorColumn));
 	}
 
 	public void removeSpecifiedTenantDiscriminatorColumn(int index) {
-		this.specifiedTenantDiscriminatorColumnContainer.removeContextElement(index);
+		this.specifiedTenantDiscriminatorColumnContainer.remove(index);
 		this.getXmlMultitenant().getTenantDiscriminatorColumns().remove(index);
 	}
 
 	public void moveSpecifiedTenantDiscriminatorColumn(int targetIndex, int sourceIndex) {
-		this.specifiedTenantDiscriminatorColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.specifiedTenantDiscriminatorColumnContainer.move(targetIndex, sourceIndex);
 		this.getXmlMultitenant().getTenantDiscriminatorColumns().move(targetIndex, sourceIndex);
 	}
 
@@ -345,26 +345,23 @@ public class EclipseLinkOrmMultitenancyImpl2_3
 		return IterableTools.cloneLive(this.getXmlMultitenant().getTenantDiscriminatorColumns());
 	}
 
+	protected ContextListContainer<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3, XmlTenantDiscriminatorColumn> buildSpecifiedTenantDiscriminatorColumnContainer() {
+		return this.buildSpecifiedContextListContainer(SPECIFIED_TENANT_DISCRIMINATOR_COLUMNS_LIST, new SpecifiedTenantDiscriminatorColumnContainerAdapter());
+	}
+
 	/**
-	 *  specified tenant discriminator column container
+	 * specified tenant discriminator column container adapter
 	 */
-	protected class SpecifiedTenantDiscriminatorColumnContainer
-		extends ContextListContainer<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3, XmlTenantDiscriminatorColumn>
+	public class SpecifiedTenantDiscriminatorColumnContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3, XmlTenantDiscriminatorColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return SPECIFIED_TENANT_DISCRIMINATOR_COLUMNS_LIST;
-		}
-		@Override
-		protected EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 buildContextElement(XmlTenantDiscriminatorColumn resourceElement) {
+		public EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 buildContextElement(XmlTenantDiscriminatorColumn resourceElement) {
 			return EclipseLinkOrmMultitenancyImpl2_3.this.buildTenantDiscriminatorColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlTenantDiscriminatorColumn> getResourceElements() {
+		public ListIterable<XmlTenantDiscriminatorColumn> getResourceElements() {
 			return EclipseLinkOrmMultitenancyImpl2_3.this.getXmlTenantDiscriminatorColumns();
 		}
-		@Override
-		protected XmlTenantDiscriminatorColumn getResourceElement(EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 contextElement) {
+		public XmlTenantDiscriminatorColumn extractResourceElement(EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 contextElement) {
 			return contextElement.getXmlColumn();
 		}
 	}
@@ -373,12 +370,6 @@ public class EclipseLinkOrmMultitenancyImpl2_3
 		return new TenantDiscriminatorColumnParentAdapter();
 	}
 
-	protected ContextListContainer<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3, XmlTenantDiscriminatorColumn> buildSpecifiedTenantDiscriminatorColumnContainer() {
-		SpecifiedTenantDiscriminatorColumnContainer container = new SpecifiedTenantDiscriminatorColumnContainer();
-		container.initialize();
-		return container;
-	}
-
 	protected EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 buildTenantDiscriminatorColumn(XmlTenantDiscriminatorColumn xmlTenantDiscriminatorColumn) {
 		return new EclipseLinkOrmTenantDiscriminatorColumn2_3(this.tenantDiscriminatorColumnParentAdapter, xmlTenantDiscriminatorColumn);
 	}
@@ -387,7 +378,7 @@ public class EclipseLinkOrmMultitenancyImpl2_3
 	// ********** default tenant discriminator columns **********
 
 	public ListIterable<EclipseLinkVirtualTenantDiscriminatorColumn2_3> getDefaultTenantDiscriminatorColumns() {
-		return this.defaultTenantDiscriminatorColumnContainer.getContextElements();
+		return this.defaultTenantDiscriminatorColumnContainer;
 	}
 
 	protected ListIterable<EclipseLinkTenantDiscriminatorColumn2_3> getReadOnlyDefaultTenantDiscriminatorColumns() {
@@ -395,11 +386,11 @@ public class EclipseLinkOrmMultitenancyImpl2_3
 	}
 
 	public int getDefaultTenantDiscriminatorColumnsSize() {
-		return this.defaultTenantDiscriminatorColumnContainer.getContextElementsSize();
+		return this.defaultTenantDiscriminatorColumnContainer.size();
 	}
 
 	protected void clearDefaultTenantDiscriminatorColumns() {
-		this.defaultTenantDiscriminatorColumnContainer.clearContextList();
+		this.defaultTenantDiscriminatorColumnContainer.clear();
 	}
 
 	/**
@@ -449,7 +440,7 @@ public class EclipseLinkOrmMultitenancyImpl2_3
 
 
 	protected void moveDefaultTenantDiscriminatorColumn(int index, EclipseLinkVirtualTenantDiscriminatorColumn2_3 tenantDiscriminatorColumn) {
-		this.defaultTenantDiscriminatorColumnContainer.moveContextElement(index, tenantDiscriminatorColumn);
+		this.defaultTenantDiscriminatorColumnContainer.move(index, tenantDiscriminatorColumn);
 	}
 
 	protected EclipseLinkVirtualTenantDiscriminatorColumn2_3 addDefaultTenantDiscriminatorColumn(int index, EclipseLinkJavaSpecifiedTenantDiscriminatorColumn2_3 javaTenantDiscriminatorColumn) {
@@ -461,11 +452,7 @@ public class EclipseLinkOrmMultitenancyImpl2_3
 	}
 
 	protected void removeDefaultTenantDiscriminatorColumn(EclipseLinkVirtualTenantDiscriminatorColumn2_3 tenantDiscriminatorColumn) {
-		this.defaultTenantDiscriminatorColumnContainer.removeContextElement(tenantDiscriminatorColumn);
-	}
-
-	protected ContextListContainer<EclipseLinkVirtualTenantDiscriminatorColumn2_3, EclipseLinkTenantDiscriminatorColumn2_3> buildDefaultTenantDiscriminatorColumnContainer() {
-		return new DefaultTenantDiscriminatorColumnContainer();
+		this.defaultTenantDiscriminatorColumnContainer.remove(tenantDiscriminatorColumn);
 	}
 
 	public boolean specifiedTenantDiscriminatorColumnsAllowed() {
@@ -482,27 +469,23 @@ public class EclipseLinkOrmMultitenancyImpl2_3
 		return this.parent.isMultitenantMetadataAllowed();
 	}
 
+	protected ContextListContainer<EclipseLinkVirtualTenantDiscriminatorColumn2_3, EclipseLinkTenantDiscriminatorColumn2_3> buildDefaultTenantDiscriminatorColumnContainer() {
+		return this.buildVirtualContextListContainer(DEFAULT_TENANT_DISCRIMINATOR_COLUMNS_LIST, new DefaultTenantDiscriminatorColumnContainerAdapter());
+	}
 
 	/**
-	 * default tenant discriminator column container
+	 * default tenant discriminator column container adapter
 	 */
-	protected class DefaultTenantDiscriminatorColumnContainer
-		extends ContextListContainer<EclipseLinkVirtualTenantDiscriminatorColumn2_3, EclipseLinkTenantDiscriminatorColumn2_3>
+	public class DefaultTenantDiscriminatorColumnContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkVirtualTenantDiscriminatorColumn2_3, EclipseLinkTenantDiscriminatorColumn2_3>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return DEFAULT_TENANT_DISCRIMINATOR_COLUMNS_LIST;
-		}
-		@Override
-		protected EclipseLinkVirtualTenantDiscriminatorColumn2_3 buildContextElement(EclipseLinkTenantDiscriminatorColumn2_3 resourceElement) {
+		public EclipseLinkVirtualTenantDiscriminatorColumn2_3 buildContextElement(EclipseLinkTenantDiscriminatorColumn2_3 resourceElement) {
 			return EclipseLinkOrmMultitenancyImpl2_3.this.buildVirtualTenantDiscriminatorColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<EclipseLinkTenantDiscriminatorColumn2_3> getResourceElements() {
+		public ListIterable<EclipseLinkTenantDiscriminatorColumn2_3> getResourceElements() {
 			return EclipseLinkOrmMultitenancyImpl2_3.this.getTenantDiscriminatorColumnsForDefaults();
 		}
-		@Override
-		protected EclipseLinkTenantDiscriminatorColumn2_3 getResourceElement(EclipseLinkVirtualTenantDiscriminatorColumn2_3 contextElement) {
+		public EclipseLinkTenantDiscriminatorColumn2_3 extractResourceElement(EclipseLinkVirtualTenantDiscriminatorColumn2_3 contextElement) {
 			return contextElement.getOverriddenColumn();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmObjectTypeConverter.java b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmObjectTypeConverter.java
index 0d8f74c9ed..64fb6bebb1 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmObjectTypeConverter.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmObjectTypeConverter.java
@@ -177,11 +177,11 @@ public class EclipseLinkOrmObjectTypeConverter
 	// ********** conversion values **********
 
 	public ListIterable<EclipseLinkOrmConversionValue> getConversionValues() {
-		return this.conversionValueContainer.getContextElements();
+		return this.conversionValueContainer;
 	}
 
 	public int getConversionValuesSize() {
-		return this.conversionValueContainer.getContextElementsSize();
+		return this.conversionValueContainer.size();
 	}
 
 	public EclipseLinkConversionValue getConversionValue(int index) {
@@ -204,16 +204,16 @@ public class EclipseLinkOrmObjectTypeConverter
 	}
 
 	public void removeConversionValue(EclipseLinkConversionValue conversionValue) {
-		this.removeConversionValue(this.conversionValueContainer.indexOfContextElement((EclipseLinkOrmConversionValue) conversionValue));
+		this.removeConversionValue(this.conversionValueContainer.indexOf((EclipseLinkOrmConversionValue) conversionValue));
 	}
 
 	public void removeConversionValue(int index) {
-		this.conversionValueContainer.removeContextElement(index);
+		this.conversionValueContainer.remove(index);
 		this.xmlConverter.getConversionValues().remove(index);
 	}
 
 	public void moveConversionValue(int targetIndex, int sourceIndex) {
-		this.conversionValueContainer.moveContextElement(targetIndex, sourceIndex);
+		this.conversionValueContainer.move(targetIndex, sourceIndex);
 		this.xmlConverter.getConversionValues().move(targetIndex, sourceIndex);
 	}
 
@@ -232,34 +232,22 @@ public class EclipseLinkOrmObjectTypeConverter
 	}
 
 	protected ContextListContainer<EclipseLinkOrmConversionValue, XmlConversionValue> buildConversionValueContainer() {
-		ConversionValueContainer container = new ConversionValueContainer();
-		container.initialize();
-		return container;
+		return this.buildSpecifiedContextListContainer(CONVERSION_VALUES_LIST, new ConversionValueContainerAdapter());
 	}
 
 	/**
-	 * conversion value container
+	 * conversion value container adapter
 	 */
-	protected class ConversionValueContainer
-			extends ContextListContainer<EclipseLinkOrmConversionValue, XmlConversionValue> {
-		
-		@Override
-		protected String getContextElementsPropertyName() {
-			return CONVERSION_VALUES_LIST;
-		}
-		
-		@Override
-		protected EclipseLinkOrmConversionValue buildContextElement(XmlConversionValue resourceElement) {
+	public class ConversionValueContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkOrmConversionValue, XmlConversionValue>
+	{
+		public EclipseLinkOrmConversionValue buildContextElement(XmlConversionValue resourceElement) {
 			return EclipseLinkOrmObjectTypeConverter.this.buildConversionValue(resourceElement);
 		}
-		
-		@Override
-		protected ListIterable<XmlConversionValue> getResourceElements() {
+		public ListIterable<XmlConversionValue> getResourceElements() {
 			return EclipseLinkOrmObjectTypeConverter.this.getXmlConversionValues();
 		}
-		
-		@Override
-		protected XmlConversionValue getResourceElement(EclipseLinkOrmConversionValue contextElement) {
+		public XmlConversionValue extractResourceElement(EclipseLinkOrmConversionValue contextElement) {
 			return contextElement.getXmlConversionValue();
 		}
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmPersistenceUnitDefaults.java b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmPersistenceUnitDefaults.java
index 834228180c..8162359fb6 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmPersistenceUnitDefaults.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.eclipselink.core/src/org/eclipse/jpt/jpa/eclipselink/core/internal/context/orm/EclipseLinkOrmPersistenceUnitDefaults.java
@@ -24,8 +24,8 @@ import org.eclipse.jpt.jpa.core.internal.context.NullJpaValidator;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.orm.AbstractOrmPersistenceUnitDefaults;
 import org.eclipse.jpt.jpa.db.Table;
 import org.eclipse.jpt.jpa.eclipselink.core.context.EclipseLinkTenantDiscriminatorColumn2_3;
-import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkPersistenceUnitDefaults;
 import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3;
+import org.eclipse.jpt.jpa.eclipselink.core.context.orm.EclipseLinkPersistenceUnitDefaults;
 import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.EclipseLinkOrmFactory;
 import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlAccessMethods;
 import org.eclipse.jpt.jpa.eclipselink.core.resource.orm.XmlPersistenceUnitDefaults;
@@ -92,11 +92,11 @@ public class EclipseLinkOrmPersistenceUnitDefaults
 	// ********** tenant discriminator columns **********
 
 	public ListIterable<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3> getTenantDiscriminatorColumns() {
-		return this.tenantDiscriminatorColumnContainer.getContextElements();
+		return this.tenantDiscriminatorColumnContainer;
 	}
 
 	public int getTenantDiscriminatorColumnsSize() {
-		return this.tenantDiscriminatorColumnContainer.getContextElementsSize();
+		return this.tenantDiscriminatorColumnContainer.size();
 	}
 
 	public boolean hasTenantDiscriminatorColumns() {
@@ -104,7 +104,7 @@ public class EclipseLinkOrmPersistenceUnitDefaults
 	}
 
 	public EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 getTenantDiscriminatorColumn(int index) {
-		return this.tenantDiscriminatorColumnContainer.getContextElement(index);
+		return this.tenantDiscriminatorColumnContainer.get(index);
 	}
 
 	public EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 addTenantDiscriminatorColumn() {
@@ -123,16 +123,16 @@ public class EclipseLinkOrmPersistenceUnitDefaults
 	}
 
 	public void removeTenantDiscriminatorColumn(EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 tenantDiscriminatorColumn) {
-		this.removeTenantDiscriminatorColumn(this.tenantDiscriminatorColumnContainer.indexOfContextElement(tenantDiscriminatorColumn));
+		this.removeTenantDiscriminatorColumn(this.tenantDiscriminatorColumnContainer.indexOf(tenantDiscriminatorColumn));
 	}
 
 	public void removeTenantDiscriminatorColumn(int index) {
-		this.tenantDiscriminatorColumnContainer.removeContextElement(index);
+		this.tenantDiscriminatorColumnContainer.remove(index);
 		this.getXmlDefaults().getTenantDiscriminatorColumns().remove(index);
 	}
 
 	public void moveTenantDiscriminatorColumn(int targetIndex, int sourceIndex) {
-		this.tenantDiscriminatorColumnContainer.moveContextElement(targetIndex, sourceIndex);
+		this.tenantDiscriminatorColumnContainer.move(targetIndex, sourceIndex);
 		this.getXmlDefaults().getTenantDiscriminatorColumns().move(targetIndex, sourceIndex);
 	}
 
@@ -148,26 +148,23 @@ public class EclipseLinkOrmPersistenceUnitDefaults
 		return IterableTools.cloneLive(this.getXmlDefaults().getTenantDiscriminatorColumns());
 	}
 
+	protected ContextListContainer<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3, XmlTenantDiscriminatorColumn> buildTenantDiscriminatorColumnContainer() {
+		return this.buildSpecifiedContextListContainer(TENANT_DISCRIMINATOR_COLUMNS_LIST, new TenantDiscriminatorColumnContainerAdapter());
+	}
+
 	/**
-	 *  tenant discriminator column container
+	 * tenant discriminator column container adapter
 	 */
-	protected class TenantDiscriminatorColumnContainer
-		extends ContextListContainer<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3, XmlTenantDiscriminatorColumn>
+	public class TenantDiscriminatorColumnContainerAdapter
+		extends AbstractContainerAdapter<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3, XmlTenantDiscriminatorColumn>
 	{
-		@Override
-		protected String getContextElementsPropertyName() {
-			return TENANT_DISCRIMINATOR_COLUMNS_LIST;
-		}
-		@Override
-		protected EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 buildContextElement(XmlTenantDiscriminatorColumn resourceElement) {
+		public EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 buildContextElement(XmlTenantDiscriminatorColumn resourceElement) {
 			return EclipseLinkOrmPersistenceUnitDefaults.this.buildTenantDiscriminatorColumn(resourceElement);
 		}
-		@Override
-		protected ListIterable<XmlTenantDiscriminatorColumn> getResourceElements() {
+		public ListIterable<XmlTenantDiscriminatorColumn> getResourceElements() {
 			return EclipseLinkOrmPersistenceUnitDefaults.this.getXmlTenantDiscriminatorColumns();
 		}
-		@Override
-		protected XmlTenantDiscriminatorColumn getResourceElement(EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 contextElement) {
+		public XmlTenantDiscriminatorColumn extractResourceElement(EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3 contextElement) {
 			return contextElement.getXmlColumn();
 		}
 	}
@@ -180,12 +177,6 @@ public class EclipseLinkOrmPersistenceUnitDefaults
 		return new EclipseLinkOrmTenantDiscriminatorColumn2_3(this.tenantDiscriminatorColumnParentAdapter, xmlTenantDiscriminatorColumn);
 	}
 
-	protected ContextListContainer<EclipseLinkOrmSpecifiedTenantDiscriminatorColumn2_3, XmlTenantDiscriminatorColumn> buildTenantDiscriminatorColumnContainer() {
-		TenantDiscriminatorColumnContainer container = new TenantDiscriminatorColumnContainer();
-		container.initialize();
-		return container;
-	}
-
 
 	// ********** tenant discriminator column parent adapter **********