/*******************************************************************************
* 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;
}
}
}