jsf/plugins/org.eclipse.jst.jsf.common.runtime/src/org/eclipse/jst/jsf/common/runtime/internal/model/ViewObject.java - jsf/webtools.jsf - Git at Google

 /*******************************************************************************
  * Copyright (c) 2001, 2008 Oracle Corporation and others.
  * All rights reserved. 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 Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jst.jsf.common.runtime.internal.model;

 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.Decorator;

 /**
  * The base type of all objects that participate in the lifecycle of a view.
  * This may be used to hold either design time or runtime information.
  *
  * @author cbateman
  *
  */
 public abstract class ViewObject implements Serializable /* IAdaptable? */
 {
     private final ViewObjectData    _data;

     /**
      *
      */
     private static final long serialVersionUID = 1592205691642453075L;

     /**
      *
      */
     protected ViewObject()
     {
         this(new ViewObjectData(false));
     }

     /**
      * @param delegate
      */
     protected ViewObject(final ViewObjectData delegate)
     {
         _data = delegate;
         _data.setOwner(this);
     }

     /**
      * @return the object containing all this view object's data
      */
     protected ViewObjectData getData()
     {
         return _data;
     }

     /**
      * IMPORTANT: if this method returns false, then calling a mutator method
      * (basically anything that is not a get/isX() will throw any
      * IllegalStateException).
      *
      * @return if the object can still be modified.
      */
     public final boolean isModifiable()
     {
         return !getData().isProtected();
     }

     /**
      * Calling this method sets the state to not modifiable
      */
     public final void setProtected()
     {
         getData().setLocked();
     }

     /**
      * This call may be create a new data structure and should be considered of
      * much higher cost than most calls.
      *
      * @return all decorators of this object. List should be assumed by clients
      *         to be unmodifiable and may throw mutation exceptions
      */
     public List getAllDecorators()
     {
         final int size = getDecoratorMap().size();

         if (size == 0)
         {
             return Collections.EMPTY_LIST;
         }

         final List allDecorators = new ArrayList();
         for (final Iterator entryIt = getDecoratorMap().entrySet().iterator(); entryIt
         .hasNext();)
         {
             final Map.Entry entry = (Map.Entry) entryIt.next();
             final List decorators = (List) entry.getValue();
             allDecorators.addAll(decorators);
         }

         return Collections.unmodifiableList(allDecorators);
     }

     /**
      * @param decoratorType
      * @return all decorators of this object associated with the class type. The
      *         returned list should be assumed to be unmodifiable. Returns an
      *         empty list if no decorators are associated with decoratorType
      */
     public List getDecorators(final Class decoratorType)
     {
         final List decorators = (List) getDecoratorMap().get(decoratorType);

         if (decorators == null)
         {
             return Collections.EMPTY_LIST;
         }
         return Collections.unmodifiableList(decorators);
     }

     /**
      * Add the decorator using decorator.getClass to associate the type. Must be
      * equivalent to addDecorator(decorator, decorator.getClass());
      *
      * @param decorator
      *            the decorator to add. <b>Must NOT be null.</b>
      * @throws IllegalArgumentException
      *             if decorator is null.
      */
     public void addDecorator(final Decorator decorator)
     {
         _data.addDecorator(decorator);
     }

     /**
      * Add the decorator using the associatedType. Normally you should call
      * {@link #addDecorator(Decorator)} however in some cases you may wish to
      * associated a decorator with a class type other than its own. For example,
      * sub-classes of ValidatorDecorator will want to associated with
      * ValidatorDecorator.getClass() in most cases so that it is included in any
      * common examination of component validators.
      *
      * @param decorator
      *            to add. <b>Must NOT be null.</b>
      * @param associatedType
      *            the key to store decorator <b>Must NOT be null</b>
      * @throws IllegalArgumentException
      *             if decorator or associatedType is null
      */
     public void addDecorator(final Decorator decorator,
             final Class associatedType)
     {
         _data.addDecorator(decorator, associatedType);
     }

     /**
      * Removes decorator if it is associated to associatedType on this view
      * object.
      *
      * @param decorator
      * @param associatedType
      * @return true if the decorator was found and removed.
      * @throws IllegalArgumentException
      *             if decorator or associatedType is null
      */
     public boolean removeDecorator(final Decorator decorator,
             final Class associatedType)
     {
         return _data.removeDecorator(decorator, associatedType);
     }

     /**
      * <p>
      * Get the adapter associated the class key.
      * </p>
      *
      * <p>
      * If addAdapter has been called with adapterType, then this adapter object
      * should always be called. In the default implementation, if there is no
      * explicit adapter, "this" is returned if (this instanceof adapterType).
      *
      * @param adapterType
      * @return the interface adapter associated with the class key or null if
      *         not found
      */
     public Object getAdapter(final Class adapterType)
     {
         if (adapterType == null)
         {
             return null;
         }

         Object adapter = getAdapterMap().get(adapterType);

         if (adapter == null)
         {
             if (adapterType.isInstance(this))
             {
                 adapter = this;
             }
         }

         return adapter;
     }

     /**
      * Adds the interface adapter object under adapterType key. There can be at
      * most one adapter registered for each class key.
      *
      * It is an error (throws exception) to try to add an adapter for
      * adapterType which this is already instance. This restriction is necessary
      * because otherwise local getters/setters would need to be aware of the
      * adapter mechanism and verify inheritance hierarchies on every calls. This
      * mechanism is intended only for adding interfaces to view object impls
      * that don't already have them.
      *
      * @param adapterType
      * @param adapter
      * @throws IllegalArgumentException
      *             if adapterType or adapter is null or if casting adapter to
      *             adapterType would * cause a ClassCastException (i.e. if
      *             !(adapter instanceof adapterType)) OR if this is already an
      *             instance of adapterType.
      */
     public void addAdapter(final Class adapterType, final Object adapter)
     {
         _data.addAdapter(adapterType, adapter);
     }

     /**
      * Note that {@link #getAdapter(Class)} may still return non-null after this
      * is called if (this instanceof adapterType).
      *
      * @param adapterType
      * @return the adapter for adapterType that was just removed or null if not
      *         found
      */
     public Object removeAdapter(final Class adapterType)
     {
         return getAdapterMap().remove(adapterType);
     }

     /**
      * Note that this only returns those adapters added using
      * {@link #addAdapter(Class, Object)}. It does not return any implicit
      * adapters resulting from (this instanceof type).
      *
      * @return the map of all adapters. Maps is immutable and may throw
      *         exceptions on attempts to mutate.
      */
     public Map getAllAdapters()
     {
         if (getAdapterMap().size() == 0)
         {
             return Collections.EMPTY_MAP;
         }
         return Collections.unmodifiableMap(getAdapterMap());
     }

     /**
      * <p>
      * The contract for this method is that it must always return a usable Map
      * and that map must be the same on every call. Lazy construction may be
      * used (as it is by default). The default map size is 4 and load factor is
      * 3 meaning that there should be decent tradeoff between wasted table size
      * and overhead used to increase it should the number of decorators exceed
      * 3. <b>Must never return null.</b>
      * </p>
      *
      * <p>
      * Generally, the method should not need to be overridden, however it is
      * provided to allow sub-classes to change the way the decorators map is
      * constructed.
      * </p>
      *
      * @return the map containing lists of decorators keyed by class.
      *
      */
     protected Map getDecoratorMap()
     {
         return _data.getDecoratorMap();
     }

     /**
      * <p>
      * The contract for this method is that it must always return a usable Map
      * and that map must be the same on every call. Lazy construction may be
      * used (as it is by default). The default map size is 4 and load factor is
      * 3 meaning that there should be decent tradeoff between wasted table size
      * and overhead used to increase it should the number of decorators exceed
      * 3. <b>Must never return null.</b>
      * </p>
      *
      * <p>
      * Generally, the method should not need to be overridden, however it is
      * provided to allow sub-classes to change the way the decorators map is
      * constructed.
      * </p>
      *
      * @return the map containing lists of adapters keyed by class.
      *
      */
     protected Map getAdapterMap()
     {
         return _data.getAdapterMap();
     }

     // ALL ViewObject's must use reference equals
     public final boolean equals(final Object obj)
     {
         return super.equals(obj);
     }

     public final int hashCode()
     {
         return super.hashCode();
     }

     /**
      * The protectable view object data.
      *
      */
     public static class ViewObjectData extends ProtectedDataObject
     {
         /**
          *
          */
         private static final long serialVersionUID = -4216980607447926035L;
         private Map _decorators;
         private Map _adapters;
         private Object _owner;

         /**
          * @param isProtected
          */
         public ViewObjectData(final boolean isProtected)
         {
             super(isProtected);
         }

         private void setOwner(final ViewObject viewObject)
         {
             _owner = viewObject;
         }

         /**
          * For serialization only.
          */
         //        public ViewObjectData()
         //        {
         //            // for serializability
         //            super(false);
         //        }

         /**
          * @param decorator
          * @param associatedType
          * @return true if the decorator was removed.
          */
         public boolean removeDecorator(final Decorator decorator, final Class associatedType)
         {
             enforceProtection();

             if (decorator == null || associatedType == null)
             {
                 throw new IllegalArgumentException("Arguments must not be null"); //$NON-NLS-1$
             }

             final List decoratorsByType = (List) getDecoratorMap().get(
                     associatedType);

             if (decoratorsByType != null)
             {
                 return decoratorsByType.remove(decorator);
             }

             return false;
         }

         /**
          * @param adapterType
          * @param adapter
          */
         public void addAdapter(final Class adapterType, final Object adapter)
         {
             enforceProtection();

             if (adapterType == null || adapter == null)
             {
                 throw new IllegalArgumentException("Arguments must not be null"); //$NON-NLS-1$
             }

             if (!adapterType.isInstance(adapter))
             {
                 throw new IllegalArgumentException("adapter: " + adapter //$NON-NLS-1$
                         + " must be cast compatible to class: " + adapterType); //$NON-NLS-1$
             }
             else if (adapterType.isInstance(_owner))
             {
                 throw new IllegalArgumentException("this: " + _owner //$NON-NLS-1$
                         + " must not already be an instance of class: " //$NON-NLS-1$
                         + adapterType);
             }
             getAdapterMap().put(adapterType, adapter);
         }

         /**
          * @param decorator
          */
         public void addDecorator(final Decorator decorator)
         {
             enforceProtection();

             if (decorator == null)
             {
                 throw new IllegalArgumentException("Arguments must not be null"); //$NON-NLS-1$
             }
             final Class associationType = decorator.getClass();
             addDecorator(decorator, associationType);
         }

         /**
          * @param decorator
          * @param associatedType
          */
         public void addDecorator(final Decorator decorator, final Class associatedType)
         {
             enforceProtection();

             if (decorator == null || associatedType == null)
             {
                 throw new IllegalArgumentException("Arguments must not be null"); //$NON-NLS-1$
             }

             List decoratorsByType = (List) getDecoratorMap().get(associatedType);

             if (decoratorsByType == null)
             {
                 decoratorsByType = new ArrayList(2);
                 getDecoratorMap().put(associatedType, decoratorsByType);
             }

             decoratorsByType.add(decorator);
         }

         /**
          * @return the decorator map, creating it if necessary
          */
         protected synchronized Map getDecoratorMap()
         {
             if (_decorators == null)
             {
                 if (isProtected())
                 {
                     _decorators = Collections.EMPTY_MAP;
                 }
                 _decorators = new HashMap(4);
             }
             return _decorators;
         }

         /**
          * @return the adapter map, creating if necessary.
          */
         protected synchronized Map getAdapterMap()
         {
             if (_adapters == null)
             {
                 _adapters = new HashMap(4);
             }

             return _adapters;
         }
     }

     /**
      * An object that enforces that mutation can only happen up to point where
      * the object is designated protected at which point is it is forever
      * immutable.
      *
      */
     public static abstract class ProtectedDataObject implements Serializable
     {
         /**
          *
          */
         private static final long serialVersionUID = 4470279408370430399L;
         private boolean _isProtected;

         /**
          * @param isProtected
          */
         public ProtectedDataObject(final boolean isProtected)
         {
             _isProtected = isProtected;
         }

         /**
          * @throws UnsupportedOperationException
          */
         protected final synchronized void enforceProtection() throws UnsupportedOperationException
         {
             if (isProtected())
             {
                 throw new UnsupportedOperationException("Object "+this.toString()+ " is locked for modification"); //$NON-NLS-1$ //$NON-NLS-2$
             }
         }

         /**
          * @return true if this object is protected and irrevocablly immutable.
          */
         public final synchronized boolean isProtected()
         {
             return _isProtected;
         }

         /**
          * Executed right before setProtected irrevocably sets the protection
          * flag. Does nothing by default
          */
         protected void doBeforeProtecting()
         {
             // do nothing by default
         }
         /**
          * Makes this object irrevocably immutable.
          */
         public final synchronized void setLocked()
         {
             doBeforeProtecting();
             _isProtected = true;
         }
     }
 }
	/*******************************************************************************
	* Copyright (c) 2001, 2008 Oracle Corporation and others.
	* All rights reserved. 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 Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jst.jsf.common.runtime.internal.model;

	import java.io.Serializable;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.Decorator;

	/**
	* The base type of all objects that participate in the lifecycle of a view.
	* This may be used to hold either design time or runtime information.
	*
	* @author cbateman
	*
	*/
	public abstract class ViewObject implements Serializable /* IAdaptable? */
	{
	private final ViewObjectData _data;

	/**
	*
	*/
	private static final long serialVersionUID = 1592205691642453075L;

	/**
	*
	*/
	protected ViewObject()
	{
	this(new ViewObjectData(false));
	}

	/**
	* @param delegate
	*/
	protected ViewObject(final ViewObjectData delegate)
	{
	_data = delegate;
	_data.setOwner(this);
	}

	/**
	* @return the object containing all this view object's data
	*/
	protected ViewObjectData getData()
	{
	return _data;
	}

	/**
	* IMPORTANT: if this method returns false, then calling a mutator method
	* (basically anything that is not a get/isX() will throw any
	* IllegalStateException).
	*
	* @return if the object can still be modified.
	*/
	public final boolean isModifiable()
	{
	return !getData().isProtected();
	}

	/**
	* Calling this method sets the state to not modifiable
	*/
	public final void setProtected()
	{
	getData().setLocked();
	}

	/**
	* This call may be create a new data structure and should be considered of
	* much higher cost than most calls.
	*
	* @return all decorators of this object. List should be assumed by clients
	* to be unmodifiable and may throw mutation exceptions
	*/
	public List getAllDecorators()
	{
	final int size = getDecoratorMap().size();

	if (size == 0)
	{
	return Collections.EMPTY_LIST;
	}

	final List allDecorators = new ArrayList();
	for (final Iterator entryIt = getDecoratorMap().entrySet().iterator(); entryIt
	.hasNext();)
	{
	final Map.Entry entry = (Map.Entry) entryIt.next();
	final List decorators = (List) entry.getValue();
	allDecorators.addAll(decorators);
	}

	return Collections.unmodifiableList(allDecorators);
	}

	/**
	* @param decoratorType
	* @return all decorators of this object associated with the class type. The
	* returned list should be assumed to be unmodifiable. Returns an
	* empty list if no decorators are associated with decoratorType
	*/
	public List getDecorators(final Class decoratorType)
	{
	final List decorators = (List) getDecoratorMap().get(decoratorType);

	if (decorators == null)
	{
	return Collections.EMPTY_LIST;
	}
	return Collections.unmodifiableList(decorators);
	}

	/**
	* Add the decorator using decorator.getClass to associate the type. Must be
	* equivalent to addDecorator(decorator, decorator.getClass());
	*
	* @param decorator
	* the decorator to add. <b>Must NOT be null.</b>
	* @throws IllegalArgumentException
	* if decorator is null.
	*/
	public void addDecorator(final Decorator decorator)
	{
	_data.addDecorator(decorator);
	}

	/**
	* Add the decorator using the associatedType. Normally you should call
	* {@link #addDecorator(Decorator)} however in some cases you may wish to
	* associated a decorator with a class type other than its own. For example,
	* sub-classes of ValidatorDecorator will want to associated with
	* ValidatorDecorator.getClass() in most cases so that it is included in any
	* common examination of component validators.
	*
	* @param decorator
	* to add. <b>Must NOT be null.</b>
	* @param associatedType
	* the key to store decorator <b>Must NOT be null</b>
	* @throws IllegalArgumentException
	* if decorator or associatedType is null
	*/
	public void addDecorator(final Decorator decorator,
	final Class associatedType)
	{
	_data.addDecorator(decorator, associatedType);
	}

	/**
	* Removes decorator if it is associated to associatedType on this view
	* object.
	*
	* @param decorator
	* @param associatedType
	* @return true if the decorator was found and removed.
	* @throws IllegalArgumentException
	* if decorator or associatedType is null
	*/
	public boolean removeDecorator(final Decorator decorator,
	final Class associatedType)
	{
	return _data.removeDecorator(decorator, associatedType);
	}

	/**
	* <p>
	* Get the adapter associated the class key.
	* </p>
	*
	* <p>
	* If addAdapter has been called with adapterType, then this adapter object
	* should always be called. In the default implementation, if there is no
	* explicit adapter, "this" is returned if (this instanceof adapterType).
	*
	* @param adapterType
	* @return the interface adapter associated with the class key or null if
	* not found
	*/
	public Object getAdapter(final Class adapterType)
	{
	if (adapterType == null)
	{
	return null;
	}

	Object adapter = getAdapterMap().get(adapterType);

	if (adapter == null)
	{
	if (adapterType.isInstance(this))
	{
	adapter = this;
	}
	}

	return adapter;
	}

	/**
	* Adds the interface adapter object under adapterType key. There can be at
	* most one adapter registered for each class key.
	*
	* It is an error (throws exception) to try to add an adapter for
	* adapterType which this is already instance. This restriction is necessary
	* because otherwise local getters/setters would need to be aware of the
	* adapter mechanism and verify inheritance hierarchies on every calls. This
	* mechanism is intended only for adding interfaces to view object impls
	* that don't already have them.
	*
	* @param adapterType
	* @param adapter
	* @throws IllegalArgumentException
	* if adapterType or adapter is null or if casting adapter to
	* adapterType would * cause a ClassCastException (i.e. if
	* !(adapter instanceof adapterType)) OR if this is already an
	* instance of adapterType.
	*/
	public void addAdapter(final Class adapterType, final Object adapter)
	{
	_data.addAdapter(adapterType, adapter);
	}

	/**
	* Note that {@link #getAdapter(Class)} may still return non-null after this
	* is called if (this instanceof adapterType).
	*
	* @param adapterType
	* @return the adapter for adapterType that was just removed or null if not
	* found
	*/
	public Object removeAdapter(final Class adapterType)
	{
	return getAdapterMap().remove(adapterType);
	}

	/**
	* Note that this only returns those adapters added using
	* {@link #addAdapter(Class, Object)}. It does not return any implicit
	* adapters resulting from (this instanceof type).
	*
	* @return the map of all adapters. Maps is immutable and may throw
	* exceptions on attempts to mutate.
	*/
	public Map getAllAdapters()
	{
	if (getAdapterMap().size() == 0)
	{
	return Collections.EMPTY_MAP;
	}
	return Collections.unmodifiableMap(getAdapterMap());
	}

	/**
	* <p>
	* The contract for this method is that it must always return a usable Map
	* and that map must be the same on every call. Lazy construction may be
	* used (as it is by default). The default map size is 4 and load factor is
	* 3 meaning that there should be decent tradeoff between wasted table size
	* and overhead used to increase it should the number of decorators exceed
	* 3. <b>Must never return null.</b>
	* </p>
	*
	* <p>
	* Generally, the method should not need to be overridden, however it is
	* provided to allow sub-classes to change the way the decorators map is
	* constructed.
	* </p>
	*
	* @return the map containing lists of decorators keyed by class.
	*
	*/
	protected Map getDecoratorMap()
	{
	return _data.getDecoratorMap();
	}

	/**
	* <p>
	* The contract for this method is that it must always return a usable Map
	* and that map must be the same on every call. Lazy construction may be
	* used (as it is by default). The default map size is 4 and load factor is
	* 3 meaning that there should be decent tradeoff between wasted table size
	* and overhead used to increase it should the number of decorators exceed
	* 3. <b>Must never return null.</b>
	* </p>
	*
	* <p>
	* Generally, the method should not need to be overridden, however it is
	* provided to allow sub-classes to change the way the decorators map is
	* constructed.
	* </p>
	*
	* @return the map containing lists of adapters keyed by class.
	*
	*/
	protected Map getAdapterMap()
	{
	return _data.getAdapterMap();
	}

	// ALL ViewObject's must use reference equals
	public final boolean equals(final Object obj)
	{
	return super.equals(obj);
	}

	public final int hashCode()
	{
	return super.hashCode();
	}

	/**
	* The protectable view object data.
	*
	*/
	public static class ViewObjectData extends ProtectedDataObject
	{
	/**
	*
	*/
	private static final long serialVersionUID = -4216980607447926035L;
	private Map _decorators;
	private Map _adapters;
	private Object _owner;

	/**
	* @param isProtected
	*/
	public ViewObjectData(final boolean isProtected)
	{
	super(isProtected);
	}

	private void setOwner(final ViewObject viewObject)
	{
	_owner = viewObject;
	}

	/**
	* For serialization only.
	*/
	// public ViewObjectData()
	// {
	// // for serializability
	// super(false);
	// }

	/**
	* @param decorator
	* @param associatedType
	* @return true if the decorator was removed.
	*/
	public boolean removeDecorator(final Decorator decorator, final Class associatedType)
	{
	enforceProtection();

	if (decorator == null \|\| associatedType == null)
	{
	throw new IllegalArgumentException("Arguments must not be null"); //$NON-NLS-1$
	}

	final List decoratorsByType = (List) getDecoratorMap().get(
	associatedType);

	if (decoratorsByType != null)
	{
	return decoratorsByType.remove(decorator);
	}

	return false;
	}

	/**
	* @param adapterType
	* @param adapter
	*/
	public void addAdapter(final Class adapterType, final Object adapter)
	{
	enforceProtection();

	if (adapterType == null \|\| adapter == null)
	{
	throw new IllegalArgumentException("Arguments must not be null"); //$NON-NLS-1$
	}

	if (!adapterType.isInstance(adapter))
	{
	throw new IllegalArgumentException("adapter: " + adapter //$NON-NLS-1$
	+ " must be cast compatible to class: " + adapterType); //$NON-NLS-1$
	}
	else if (adapterType.isInstance(_owner))
	{
	throw new IllegalArgumentException("this: " + _owner //$NON-NLS-1$
	+ " must not already be an instance of class: " //$NON-NLS-1$
	+ adapterType);
	}
	getAdapterMap().put(adapterType, adapter);
	}

	/**
	* @param decorator
	*/
	public void addDecorator(final Decorator decorator)
	{
	enforceProtection();

	if (decorator == null)
	{
	throw new IllegalArgumentException("Arguments must not be null"); //$NON-NLS-1$
	}
	final Class associationType = decorator.getClass();
	addDecorator(decorator, associationType);
	}

	/**
	* @param decorator
	* @param associatedType
	*/
	public void addDecorator(final Decorator decorator, final Class associatedType)
	{
	enforceProtection();

	if (decorator == null \|\| associatedType == null)
	{
	throw new IllegalArgumentException("Arguments must not be null"); //$NON-NLS-1$
	}

	List decoratorsByType = (List) getDecoratorMap().get(associatedType);

	if (decoratorsByType == null)
	{
	decoratorsByType = new ArrayList(2);
	getDecoratorMap().put(associatedType, decoratorsByType);
	}

	decoratorsByType.add(decorator);
	}

	/**
	* @return the decorator map, creating it if necessary
	*/
	protected synchronized Map getDecoratorMap()
	{
	if (_decorators == null)
	{
	if (isProtected())
	{
	_decorators = Collections.EMPTY_MAP;
	}
	_decorators = new HashMap(4);
	}
	return _decorators;
	}

	/**
	* @return the adapter map, creating if necessary.
	*/
	protected synchronized Map getAdapterMap()
	{
	if (_adapters == null)
	{
	_adapters = new HashMap(4);
	}

	return _adapters;
	}
	}

	/**
	* An object that enforces that mutation can only happen up to point where
	* the object is designated protected at which point is it is forever
	* immutable.
	*
	*/
	public static abstract class ProtectedDataObject implements Serializable
	{
	/**
	*
	*/
	private static final long serialVersionUID = 4470279408370430399L;
	private boolean _isProtected;

	/**
	* @param isProtected
	*/
	public ProtectedDataObject(final boolean isProtected)
	{
	_isProtected = isProtected;
	}

	/**
	* @throws UnsupportedOperationException
	*/
	protected final synchronized void enforceProtection() throws UnsupportedOperationException
	{
	if (isProtected())
	{
	throw new UnsupportedOperationException("Object "+this.toString()+ " is locked for modification"); //$NON-NLS-1$ //$NON-NLS-2$
	}
	}

	/**
	* @return true if this object is protected and irrevocablly immutable.
	*/
	public final synchronized boolean isProtected()
	{
	return _isProtected;
	}

	/**
	* Executed right before setProtected irrevocably sets the protection
	* flag. Does nothing by default
	*/
	protected void doBeforeProtecting()
	{
	// do nothing by default
	}
	/**
	* Makes this object irrevocably immutable.
	*/
	public final synchronized void setLocked()
	{
	doBeforeProtecting();
	_isProtected = true;
	}
	}
	}