/*******************************************************************************
* 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.component;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import org.eclipse.jst.jsf.common.runtime.internal.model.ViewObject;
import org.eclipse.jst.jsf.common.runtime.internal.model.component.AbstractVisitor.VisitationPolicy;
import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.FacetDecorator;
/**
* Models a basic UI component instance
*
* TODO: should implement a visitor pattern to traverse component trees
*
* @author cbateman
*
*/
public class ComponentInfo extends ViewObject implements Serializable,
IVisitable
{
/**
* serializable id
*/
private static final long serialVersionUID = 2517204356825585699L;
private final static int DEFAULT_ARRAY_SIZE = 4;
private transient BeanPropertyManager _beanPropertyManager;
/**
* Encapsulates all of the data for the view object
*/
protected final ComponentInfoData _data;
// initialized
// by
// getBeanProperties
/**
* @param id
* @param parent
* @param componentTypeInfo
* @param isRendered
*/
protected ComponentInfo(final String id, final ComponentInfo parent,
final ComponentTypeInfo componentTypeInfo, final boolean isRendered)
{
super(new ComponentInfoData(id, parent, componentTypeInfo, isRendered));
_data = (ComponentInfoData) super.getData();
final Set propExclude = new HashSet();
propExclude.add("attributeNames"); //$NON-NLS-1$
propExclude.add("componentTypeInfo"); //$NON-NLS-1$
propExclude.add("valueChangeListeners"); //$NON-NLS-1$
propExclude.add("visitableChildren"); //$NON-NLS-1$
_beanPropertyManager = new BeanPropertyManager(this, propExclude);
}
/**
* @param data
*/
protected ComponentInfo(final ComponentInfoData data)
{
super(data);
_data = data;
}
/**
* Construct a new component info using the attributes keyed by name in
* attributes to set values. The names must match the corresponding bean
* property names. Primitives should be wrapped in their corresponding
* object types. Exceptions will be thrown if there is a type mismatch on an
* expected type. Number will be used for all numeric primitive wrappers an
* the corresponding "to" will be called.
*
* @param parent
* @param componentTypeInfo
* @param attributes
* @throws ClassCastException
* if an attribute's value doesn't match the expected type
* @throws NullPointerException
* if an attribute value is null for a value whose type is
* expected to be primitive
* @throws IllegalArgumentException
* if attributes does not contain a required key.
*/
protected ComponentInfo(final ComponentInfo parent,
final ComponentTypeInfo componentTypeInfo, final Map attributes)
{
this(getStringProperty("id", attributes, false), parent, //$NON-NLS-1$
componentTypeInfo, getBooleanProperty("rendered", attributes, false)); //$NON-NLS-1$
}
/**
* @param key
* @param attributes
* @param mandatory
* @return the value in attributes at location key, forcing a
* ClassCastException if it turns out not to be a String.
* @throws ClassCastException
* if the attribute for key is not a String
* @throws IllegalArgumentException
* if the attribute for key is null but mandatory is true.
*/
protected static String getStringProperty(final String key,
final Map attributes, final boolean mandatory)
{
final Object value = attributes.get(key);
if (mandatory && value == null)
{
throw new IllegalArgumentException(key
+ " is a mandatory attribute"); //$NON-NLS-1$
}
return (String) value;
}
/**
* @param key
* @param attributes
* @param mandatory
*
* @return the value in attributes at location, forcing a ClassCastExceptio
* if it is not a Boolean and mandatory. returns false if no value
* and not mandatory
* @throws IllegalArgumentException
* if key is not found and value is mandatory
*/
protected static boolean getBooleanProperty(final String key,
final Map attributes, final boolean mandatory)
{
final Boolean value = (Boolean) attributes.get(key);
if (value == null)
{
if (mandatory)
{
throw new IllegalArgumentException(key + "is mandatory"); //$NON-NLS-1$
}
return false;
}
return value.booleanValue();
}
/**
* @param key
* @param attributes
* @return the integer property for key. Casts the value to Number and calls
* Number.intValue(). 0 if no value.
*/
protected static int getIntegerProperty(final String key,
final Map attributes)
{
final Number value = (Number) attributes.get(key);
if (value == null)
{
return 0;
}
return value.intValue();
}
/**
* @param key
* @param attributes
* @return the component info value from attributes
*/
protected static ComponentInfo getComponentProperty(final String key,
final Map attributes)
{
return (ComponentInfo) attributes.get(key);
}
/**
* @return the id
*/
public final String getId()
{
return _data.getId();
}
/**
* @return the component type info
*/
public final ComponentTypeInfo getComponentTypeInfo()
{
return _data.getComponentTypeInfo();
}
/**
* Pre-condition: isModifiable() == true Post-condition: getChildren() will
* return an empty list.
*/
protected final void clearChildren()
{
_data.getChildren().clear();
}
/**
* @return the children. List is unmodifiable. List contains all children
* including facets.
*/
public final List/* <ComponentInfo> */getChildren()
{
if (_data.isProtected())
{
return _data.getChildren();
}
return Collections.unmodifiableList(_data.getChildren());
}
/**
* Get the sub-set of {@link #getChildren()} that are facets. This is a
* convenience method for {@link #getDecorators(Class)}
*
* @return all component children that are facets
*/
public final List getFacets()
{
return getDecorators(ComponentFactory.FACET);
}
/**
* @param childComponent
*/
public final void addChild(final ComponentInfo childComponent)
{
if (childComponent == this)
{
throw new IllegalArgumentException(
"A component cannot be its own child"); //$NON-NLS-1$
}
_data.addChild(childComponent);
// we need to reset the child's parent to me
childComponent.setParent(this);
}
/**
* @param parent
*/
public final void setParent(ComponentInfo parent)
{
_data.setParent(parent);
}
/**
* @param name
* @param facetComponent
*/
public final void addFacet(final String name,
final ComponentInfo facetComponent)
{
addChild(facetComponent);
addDecorator(new FacetDecorator(name, facetComponent));
}
/**
* @param component
* @return if component corresponds to a facet of this component, returns
* the name of that facet. Returns null if not found.
*/
public final String getFacetName(final ComponentInfo component)
{
if (component == null)
{
return null;
}
final List facets = getDecorators(ComponentFactory.FACET);
for (final Iterator it = facets.iterator(); it.hasNext();)
{
final FacetDecorator facet = (FacetDecorator) it.next();
if (component == facet.getDecorates())
{
return facet.getName();
}
}
// component is not a facet
return null;
}
/**
* @param name
* @return if this has a facet called name, then returns it's single root
* component.
*/
public final ComponentInfo getFacet(final String name)
{
if (name == null)
{
return null;
}
final List facets = getDecorators(ComponentFactory.FACET);
for (final Iterator it = facets.iterator(); it.hasNext();)
{
final FacetDecorator facet = (FacetDecorator) it.next();
if (name.equals(facet.getName()))
{
return facet.getDecorates();
}
}
// not found
return null;
}
public String toString()
{
final String parentId = getParent() != null ? getParent().getId()
: "null"; //$NON-NLS-1$
String toString = getMostSpecificComponentName() + ": id=" //$NON-NLS-1$
+ _data.getId() + ", parentId: " + parentId + ", family=" //$NON-NLS-1$ //$NON-NLS-2$
+ getComponentTypeInfo().getComponentFamily() + ", render=" //$NON-NLS-1$
+ getComponentTypeInfo().getRenderFamily() + ", rendered=" //$NON-NLS-1$
+ isRendered();
// use bean introspection to dump child properties
if (this.getClass() != ComponentInfo.class)
{
toString += dumpProperties();
}
return toString;
}
private String dumpProperties()
{
String properties = ""; //$NON-NLS-1$
try
{
final BeanInfo beanInfo = Introspector.getBeanInfo(this.getClass(),
ComponentInfo.class);
final PropertyDescriptor[] descriptors = beanInfo
.getPropertyDescriptors();
for (int i = 0; i < descriptors.length; i++)
{
final PropertyDescriptor desc = descriptors[i];
final String name = desc.getName();
final Object valueObj = desc.getValue(name);
final String value = valueObj != null ? valueObj.toString()
: "null"; //$NON-NLS-1$
properties += ", " + name + "=" + value; //$NON-NLS-1$ //$NON-NLS-2$
}
}
catch (final IntrospectionException e)
{
return "Error introspecting bean: " + e.getLocalizedMessage(); //$NON-NLS-1$
}
return properties;
}
/**
* @return used for toString. Clients should not use.
*/
protected String getMostSpecificComponentName()
{
return "UIComponent"; //$NON-NLS-1$
}
/**
* @return the parent of this component or null.
*/
public final ComponentInfo getParent()
{
return _data.getParent();
}
/**
* @return the rendered flag
*/
public final boolean isRendered()
{
return _data.isRendered();
}
public synchronized void addAdapter(final Class adapterType,
final Object adapter)
{
super.addAdapter(adapterType, adapter);
// force an update on the next call to getBeanProperties
_beanPropertyManager.reset();
}
public synchronized Object removeAdapter(final Class adapterType)
{
final Object removed = super.removeAdapter(adapterType);
_beanPropertyManager.reset();
return removed;
}
/**
* @return the set of all bean property names for this component. The set is
* unmodifiable and will throw exceptions if modification is
* attempted.
*/
protected final Map/* <String, ComponentBeanProperty> */getBeanProperties()
{
return Collections.unmodifiableMap(_beanPropertyManager
.getBeanProperties());
}
/**
* @author cbateman
*
*/
public static class ComponentInfoData extends ViewObjectData
{
/**
*
*/
private static final long serialVersionUID = 5052732412917986062L;
/**
* the component id
*/
private final String _id;
/**
* the component's parent or null if none
*/
private ComponentInfo _parent;
/**
* the type info for this component
*/
protected final ComponentTypeInfo _componentTypeInfo;
/**
* the rendered flage
*/
protected final boolean _isRendered;
private List /* <ComponentInfo> */_children = new ArrayList(
DEFAULT_ARRAY_SIZE);
/**
* @param id
* @param parent
* @param componentTypeInfo
* @param isRendered
*/
public ComponentInfoData(final String id, ComponentInfo parent,
ComponentTypeInfo componentTypeInfo, boolean isRendered)
{
super(false);
_id = id;
_parent = parent;
_componentTypeInfo = componentTypeInfo;
_isRendered = isRendered;
}
/**
* @param childComponent
*/
protected void addChild(ComponentInfo childComponent)
{
enforceProtection();
getChildren().add(childComponent);
}
/**
* @return the modifiable list of children
*/
protected final List/* <ComponentInfo> */getChildren()
{
return _children;
}
protected void doBeforeProtecting()
{
super.doBeforeProtecting();
// compact the children array list
if (_children.size() > 0)
{
_children = Collections.unmodifiableList(_children);
}
else
{
_children = Collections.EMPTY_LIST;
}
}
/**
* @return the isRendered flag
*/
protected final boolean isRendered()
{
return _isRendered;
}
/**
* @return the component type info flag
*/
protected final ComponentTypeInfo getComponentTypeInfo()
{
return _componentTypeInfo;
}
/**
* @return the parent or null if no parent
*/
protected final ComponentInfo getParent()
{
return _parent;
}
/**
* @param parent
*/
protected final void setParent(ComponentInfo parent)
{
enforceProtection();
_parent = parent;
}
/**
* @return the component id
*/
protected final String getId()
{
return _id;
}
}
/**
* This is similar to the runtime getAttributes().get(name) call. The reason
* we don't implement a Map of all attribute values is that the implicit
* property structure can change at any time due to add/removeAdapter. To
* get all attributes known for a component, instead use:
*
* The synchronized block is advised to protect against concurrent
* modification exceptions on the keySet iterator.
*
* @param name
*
* @return the value of the attribute or null if none.
*
*/
public synchronized ComponentBeanProperty getAttribute(final String name)
{
return (ComponentBeanProperty) getBeanProperties().get(name);
}
/**
* @return the set of valid attribute names. The Set is not modifiable.
*/
public synchronized Set/* <String> */getAttributeNames()
{
return getBeanProperties().keySet();
}
/**
* Stores a bean property descriptor along information about which
* implementation class declares it and what key to pass to getAdapter() in
* order to get it.
*
*/
public final static class ComponentBeanProperty
{
private final PropertyDescriptor _propertyDescriptor;
private final Object _declaringImplementation;
private final Class _adapterKeyClass;
// only instantiable locally
private ComponentBeanProperty(Class adapterKeyClass,
Object declaringImplementationClass,
PropertyDescriptor propertyDescriptor)
{
super();
_adapterKeyClass = adapterKeyClass;
_declaringImplementation = declaringImplementationClass;
_propertyDescriptor = propertyDescriptor;
}
/**
* @return the value of property
*/
public final Object getValue()
{
final Method method = _propertyDescriptor.getReadMethod();
if (method != null)
{
try
{
method.setAccessible(true);
return method.invoke(_declaringImplementation,
new Object[0]);
}
catch (IllegalArgumentException e)
{
e.printStackTrace();
}
catch (IllegalAccessException e)
{
e.printStackTrace();
}
catch (InvocationTargetException e)
{
e.printStackTrace();
}
}
// if any step fails, return null
return null;
}
/**
* @return the property descriptor
*/
public final PropertyDescriptor getPropertyDescriptor()
{
return _propertyDescriptor;
}
/**
* @return the implemenation
*/
public final Object getDeclaringImplementationClass()
{
return _declaringImplementation;
}
/**
* @return the adapter class for the interface that the declaring
* implementation is providing the impl for
*/
public final Class getAdapterKeyClass()
{
return _adapterKeyClass;
}
}
/**
* Manages bean property information for a component
*
* @author cbateman
*
*/
protected final static class BeanPropertyManager
{
/**
* a map of the bean property names exposed by this component including
* all those added by addAdapter().
*
* this is synthetic based the class definition and installed adapters
* so as long that info is available, no need to serialize.
*/
protected transient Map /*
* <String,
* ComponentBeanProperty>
*/_beanProperties; // lazily
private final transient ComponentInfo _component;
private final transient Set _excludeNames;
/**
* @param component
* @param excludeNames
*/
protected BeanPropertyManager(final ComponentInfo component,
final Set excludeNames)
{
_component = component;
_excludeNames = excludeNames;
}
/**
* Will throw exception of the calling thread already holds the "this"
* monitor lock. This is to ensure that caller always acquires locks in
* appropriate order to prevent deadlock.
*
* @return the internal set of bean properties. This Set may be modified
* internally.
*/
public Map getBeanProperties()
{
if (Thread.holdsLock(this))
{
throw new IllegalStateException(
"Must not already own this lock"); //$NON-NLS-1$
}
// must always acquire component lock first to prevent deadlock
synchronized (_component)
{
synchronized (this)
{
if (_beanProperties == null)
{
_beanProperties = calculateAllBeanPropNames(ViewObject.class);
}
return _beanProperties;
}
}
}
/**
* Will throw exception if the calling thread already holds the "this"
* monitor lock. This is to ensure that caller always acquires locks in
* appropriate order to prevent deadlock.
*
* Clears the internal map and sets to null. This will force it to be
* completely new built on the next call to getBeanProperties
*/
public void reset()
{
if (Thread.holdsLock(this))
{
throw new IllegalStateException(
"Must not already own this lock"); //$NON-NLS-1$
}
// must always acquire component lock first to prevent deadlock
synchronized (_component)
{
synchronized (this)
{
if (_beanProperties != null)
{
_beanProperties.clear();
_beanProperties = null;
}
}
}
}
/**
* @param stopClass
* @return a synchronized map of all bean property names on this class
* up to stopClass, as well as all adapter property names (as
* though this really implemented them).
*/
private Map calculateAllBeanPropNames(final Class stopClass)
{
// use a set to prevents the duplicates
final Map allProperties = new HashMap();
{
final Class myClass = _component.getClass();
final List myProperties = getOrCreateBeanProperties(myClass,
stopClass);
addToMap(myProperties, _component, myClass, allProperties, _excludeNames);
}
{
for (final Iterator it = _component.getAdapterMap().entrySet()
.iterator(); it.hasNext();)
{
Map.Entry entry = (Entry) it.next();
final Class adapterClass = (Class) entry.getKey();
final Object declaringClass = entry.getValue();
// get all props, excluding the ones on Object.
final List props = getOrCreateBeanProperties(adapterClass,
null);
addToMap(props, declaringClass, adapterClass, allProperties,
_excludeNames);
}
}
return Collections.synchronizedMap(allProperties);
}
private static void addToMap(
final List/* <ComponentBeanProperty> */addThese,
final Object declaringObject, final Class declaringAdapter,
final Map toMe,
Set excludeNames)
{
for (final Iterator it = addThese.iterator(); it.hasNext();)
{
final PropertyDescriptor desc = (PropertyDescriptor) it.next();
if (!toMe.containsKey(desc.getName())
&& !excludeNames.contains(desc.getName()))
{
toMe.put(desc.getName(), new ComponentBeanProperty(
declaringAdapter, declaringObject, desc));
}
}
}
/**
* lazily loaded with the local properties (those not defined using
* adapters)
*
* MUST INITIALIZE early so can synchronize on it
*/
private transient static Map /* <Class, List<PropertyDescriptor> */PROPERTY_MAP = new HashMap();
/**
* @param startClass
* @param stopClass
* @return a unmodifiable list of properties starting from startClass.
* stopClass is only used if an entry doesn't already exist in
* PROPERTY_MAP for startClass. The method is synchronized on
* the PROPERTY_MAP it updates.
*/
protected static List/* <PropertyDescriptor */getOrCreateBeanProperties(
final Class startClass, final Class stopClass)
{
synchronized (PROPERTY_MAP)
{
List localBeanProps = (List) PROPERTY_MAP.get(startClass);
if (localBeanProps == null)
{
localBeanProps = calculateBeanProperties(startClass,
stopClass);
PROPERTY_MAP.put(startClass, Collections
.unmodifiableList(localBeanProps));
}
return localBeanProps;
}
}
/**
* @param startClass
* @param stopClass
* @return a List<String> containing all of the bean names between
* startClass and stopClass. Start class must be a descendant
* (sub-class, sub-sub-class etc.) of stopClass. The properties
* on stopClass are excluded from analysis.
*/
private static List/* <PropertyDescriptor> */calculateBeanProperties(
final Class startClass, final Class stopClass)
{
BeanInfo beanInfo;
List names = new ArrayList();
try
{
beanInfo = Introspector.getBeanInfo(startClass, stopClass);
final PropertyDescriptor[] descriptors = beanInfo
.getPropertyDescriptors();
if (descriptors != null)
{
names = Arrays.asList(descriptors);
}
}
catch (final IntrospectionException e)
{
e.printStackTrace();
}
return names;
}
}
/**
* Visits this node and it's entire tree and makes all nodes protected.
*/
public final void setSubtreeProtected()
{
// lock children first
final ComponentTreeVisitor protectionVisitor = new ComponentTreeVisitor(VisitationPolicy.ChildrenFirstPolicy)
{
public void visit(ComponentInfo component)
{
component.setProtected();
}
};
accept(protectionVisitor);
}
public void accept(AbstractVisitor visitor)
{
// check policy ordering
if (visitor.getPolicy().getOrdering() == VisitationPolicy.VISIT_PARENT_FIRST)
{
visitor.visit(this);
visitChildren(visitor);
}
else
{
visitChildren(visitor);
visitor.visit(this);
}
}
private void visitChildren(AbstractVisitor visitor)
{
for (final Iterator it = getVisitableChildren(); it.hasNext();)
{
visitor.visit(it.next());
}
}
public Iterator getVisitableChildren()
{
return getChildren().iterator();
}
}