/*******************************************************************************
* 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.designtime.internal.view;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.eclipse.jdt.core.Signature;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
import org.eclipse.jst.jsf.common.runtime.internal.model.ViewObject;
import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.ActionSourceInfo;
import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.ActionSourceInfo2;
import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.EditableValueHolderInfo;
import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.INamingContainerInfo;
import org.eclipse.jst.jsf.common.runtime.internal.model.behavioural.ValueHolderInfo;
import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentFactory;
import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentInfo;
import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentTypeInfo;
import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterDecorator;
import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterTypeInfo;
import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValidatorDecorator;
import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValidatorTypeInfo;
import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.IComponentPropertyHandler;
import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.IComponentTagElement;
import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.IConverterTagElement;
import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ITagAttributeHandler;
import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ITagElement;
import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.IValidatorTagElement;
import org.eclipse.jst.jsf.common.util.JDTBeanProperty;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContextFactory;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
import org.eclipse.jst.jsf.designtime.internal.view.XMLViewObjectMappingService.ElementData;
import org.eclipse.jst.jsf.designtime.internal.view.mapping.ICustomViewMapper;
import org.eclipse.jst.jsf.designtime.internal.view.mapping.ICustomViewMapper.PropertyMapping;
import org.eclipse.jst.jsf.designtime.internal.view.mapping.viewmapping.CustomViewMapperExtensionLoader;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
/**
* A strategy for constructing view objects.
*
* @author cbateman
*
*/
public class XMLViewObjectConstructionStrategy extends
ViewObjectConstructionStrategy<Element>
{
private static final String GENERATED_ID = "_generatedId"; //$NON-NLS-1$
private final ComponentConstructionData _constructionData;
private final XMLViewDefnAdapter _adapter;
private final XMLViewObjectMappingService _mappingService;
/**
* @param adapter
* MUST NOT BE NULL
* @param constructionData
* MUST NOT BE NULL
* @param mappingService
* MAY BE NULL
*/
public XMLViewObjectConstructionStrategy(final XMLViewDefnAdapter adapter,
final ComponentConstructionData constructionData,
final XMLViewObjectMappingService mappingService)
{
super();
if (adapter == null || constructionData == null)
{
throw new IllegalArgumentException(
"adapter and constructionData must not be null"); //$NON-NLS-1$
}
_constructionData = constructionData;
_adapter = adapter;
_mappingService = mappingService;
}
@Override
public ViewObject createViewObject(final Element element,
final ITagElement tagElement)
{
try
{
if (tagElement instanceof IComponentTagElement)
{
String id = null;
// only generate ids for non-viewroot components. This will
// make the generated id's more faithful to runtime since the
// running count won't be incremented for view roots (as they
// won't at runtime).
final ComponentTypeInfo typeInfo = ((IComponentTagElement) tagElement)
.getComponent();
if (!"javax.faces.ViewRoot".equals(typeInfo.getComponentType())) //$NON-NLS-1$
{
id = calculateId(element, _constructionData);
}
return findBestComponent(tagElement.getUri(), element, id,
(IComponentTagElement) tagElement);
}
else if (tagElement instanceof IConverterTagElement)
{
final ConverterTypeInfo typeInfo = ((IConverterTagElement) tagElement)
.getConverter();
// TODO: validate when no parent
ComponentInfo parent = _constructionData.getParent();
parent = findFirstParent(
ComponentFactory.INTERFACE_VALUEHOLDER, parent);
if (parent != null)
{
parent.addDecorator(
new ConverterDecorator(parent, typeInfo),
ComponentFactory.CONVERTER);
}
// TODO: else validate problem
}
else if (tagElement instanceof IValidatorTagElement)
{
final ValidatorTypeInfo typeInfo = ((IValidatorTagElement) tagElement)
.getValidator();
ComponentInfo parent = _constructionData.getParent();
parent = findFirstParent(
ComponentFactory.INTERFACE_EDITABLEVALUEHOLDER, parent);
if (parent != null)
{
parent.addDecorator(
new ValidatorDecorator(parent, typeInfo),
ComponentFactory.VALIDATOR);
}
// TODO :else validate problem
}
}
catch (final Exception e)
{
// log and ignore if an individual construction fails
JSFCorePlugin.log(e, "Error constructing view object"); //$NON-NLS-1$
}
return null;
}
private ComponentInfo findFirstParent(final String matchingType,
final ComponentInfo start)
{
ComponentInfo parent = start;
while (parent != null && parent.getComponentTypeInfo() != null
&& !parent.getComponentTypeInfo().isInstanceOf(matchingType))
{
parent = parent.getParent();
}
return parent;
}
private ComponentInfo findBestComponent(final String uri,
final Element srcElement, final String id,
final IComponentTagElement tagElement)
{
ComponentInfo bestComponent = null;
final ComponentInfo parent = _constructionData.getParent();
final Map<String, Object> initMap = new HashMap<String, Object>();
final Map<String, String> attributeToPropertyMap = new HashMap<String, String>();
populateInitMap(uri, initMap, srcElement, tagElement,
attributeToPropertyMap);
if (initMap.get("id") == null) //$NON-NLS-1$
{
// id must be set
initMap.put("id", id); //$NON-NLS-1$
}
final ComponentTypeInfo typeInfo = tagElement.getComponent();
// if we have a well-established base type, try that first
// sub-classes must occur before superclasses to ensure most accurate
// detection.
if (typeInfo.isInstanceOf(ComponentFactory.BASE_CLASS_UIINPUT))
{
bestComponent = ComponentFactory.createUIInputInfo(parent,
typeInfo, initMap);
}
else if (typeInfo.isInstanceOf(ComponentFactory.BASE_CLASS_UIOUTPUT))
{
bestComponent = ComponentFactory.createUIOutputInfo(parent,
typeInfo, initMap);
}
else if (typeInfo.isInstanceOf(ComponentFactory.BASE_CLASS_UICOMMAND))
{
bestComponent = ComponentFactory.createUICommandInfo(parent,
typeInfo, initMap);
}
else if (typeInfo.isInstanceOf(ComponentFactory.BASE_CLASS_UIDATA))
{
bestComponent = ComponentFactory.createUIDataInfo(parent, typeInfo,
initMap);
}
else if (typeInfo.isInstanceOf(ComponentFactory.BASE_CLASS_UIFORM))
{
// TODO: how handle prepend ids?
bestComponent = ComponentFactory.createUIFormInfo(parent, typeInfo,
initMap);
}
else
{
// default
bestComponent = ComponentFactory.createComponentInfo(
_constructionData.getParent(), typeInfo, initMap);
}
addTypeAdapters(bestComponent);
maybeMapXMLToViewObjects(bestComponent, srcElement,
attributeToPropertyMap, _constructionData.getDocument());
maybeUpdateViewObject(bestComponent, srcElement, tagElement);
return bestComponent;
}
// TODO: move to view definition adapter?
private void populateInitMap(final String uri,
final Map<String, Object> initMap, final Element srcElement,
final IComponentTagElement tagElement,
final Map<String, String> attributeToPropertyMap)
{
final ComponentTypeInfo typeInfo = tagElement.getComponent();
final Map<String, ITagAttributeHandler> attributeHandlers = tagElement
.getAttributeHandlers();
final NamedNodeMap nodeMap = srcElement.getAttributes();
if (nodeMap != null && attributeHandlers != null)
{
Map<String, JDTBeanProperty> properties = null;
for (int i = 0; i < nodeMap.getLength(); i++)
{
final Attr attr = (Attr) nodeMap.item(i);
if (attr != null)
{
final String name = attr.getLocalName();
if (name != null)
{
final ITagAttributeHandler attrHandler = attributeHandlers
.get(name);
if (attrHandler instanceof IComponentPropertyHandler)
{
if (properties == null)
{
properties = DTComponentIntrospector.getBeanProperties(typeInfo, _constructionData.getProject());
}
mapComponentProperty(uri, srcElement, properties,
(IComponentPropertyHandler) attrHandler,
attr, name, initMap, attributeHandlers,
attributeToPropertyMap);
}
}
}
}
}
}
private void mapComponentProperty(final String uri,
final Element srcElement,
final Map<String, JDTBeanProperty> properties,
final IComponentPropertyHandler attrHandler, final Attr attr,
final String attributeName, final Map initMap,
final Map<String, ITagAttributeHandler> attributeHandlers,
final Map<String, String> attributeToPropertyMap)
{
final String propertyName = attrHandler.getPropertyName();
if (properties.containsKey(propertyName))
{
final String id = attrHandler.getCustomHandler();
ICustomViewMapper mapper = null;
if (id != null)
{
mapper = CustomViewMapperExtensionLoader
.getCustomViewMapper(id);
if (mapper != null)
{
final PropertyMapping mapping = mapper
.mapToComponentProperty(uri, srcElement, attr);
if (mapping != null)
{
initMap.put(mapping.getName(), mapping.getProperty());
attributeToPropertyMap.put(attributeName, mapping
.getName());
return;
}
}
}
final String value = attr.getValue();
if (value != null)
{
final Object convertedValue = convertFromString(value,
properties.get(propertyName));
initMap.put(propertyName, convertedValue);
}
attributeToPropertyMap.put(attributeName, propertyName);
}
}
private void maybeMapXMLToViewObjects(final ViewObject mappedObject,
final Element node,
final Map<String, String> attributeToProperties,
final IDocument document)
{
if (mappedObject != null && _mappingService != null)
{
final String uri = _adapter.getNamespace(node, document);
final IStructuredDocumentContext context = IStructuredDocumentContextFactory.INSTANCE
.getContext(document, node);
final ElementData elementData = XMLViewObjectMappingService
.createElementData(uri, node.getLocalName(), context,
attributeToProperties);
//Bug 269050 - IllegalArgumentException in createMapping() method
if (elementData != null) {
_mappingService.createMapping(elementData, mappedObject);
}
}
}
private void maybeUpdateViewObject(final ComponentInfo bestComponent,
final Element srcElement, final ITagElement tagElement)
{
if (srcElement.getAttributes() == null)
return;
for (int i = 0; i < srcElement.getAttributes().getLength(); i++)
{
final Attr attr = (Attr) srcElement.getAttributes().item(i);
final Map<String, ITagAttributeHandler> attributeHandlers = tagElement
.getAttributeHandlers();
if (attributeHandlers != null)
{
final ITagAttributeHandler handler = attributeHandlers.get(attr
.getLocalName());
if (handler != null)
{
final String id = handler.getCustomHandler();
ICustomViewMapper mapper = null;
if (id != null)
{
mapper = CustomViewMapperExtensionLoader
.getCustomViewMapper(id);
if (mapper != null)
{
mapper.doAttributeActions(bestComponent,
srcElement, attr);
}
}
}
}
}
}
private Object convertFromString(final String convertValue,
final JDTBeanProperty ofThisType)
{
final String signature = ofThisType.getTypeSignature();
Object result = null;
switch (Signature.getTypeSignatureKind(signature))
{
case Signature.BASE_TYPE_SIGNATURE:
result = convertFromBaseType(convertValue, signature);
break;
case Signature.CLASS_TYPE_SIGNATURE:
if (TypeConstants.TYPE_STRING.equals(signature))
{
result = convertValue;
}
else if (TypeConstants.TYPE_JAVAOBJECT.equals(signature))
{
result = convertValue;
}
break;
}
return result;
}
// TODO: does this belong somewhere else?
private Object convertFromBaseType(final String convertValue,
final String signature)
{
if (Signature.SIG_BOOLEAN.equals(signature))
{
return Boolean.valueOf(convertValue);
}
else if (Signature.SIG_INT.equals(signature)
|| Signature.SIG_BYTE.equals(signature)
|| Signature.SIG_SHORT.equals(signature))
{
try
{
return Integer.valueOf(convertValue);
}
catch (final NumberFormatException nfe)
{
return null;
}
}
else if (Signature.SIG_LONG.equals(convertValue))
{
try
{
return Long.valueOf(convertValue);
}
catch (final NumberFormatException nfe)
{
return null;
}
}
return null;
}
private void addTypeAdapters(final ComponentInfo component)
{
final String[] interfaceNames = component.getComponentTypeInfo()
.getInterfaces();
final Set interfaceNameSets = new HashSet();
for (final String interfaceName : interfaceNames)
{
interfaceNameSets.add(interfaceName);
}
// don't replace intrinsic adapters
if (interfaceNameSets.contains(ComponentFactory.INTERFACE_ACTIONSOURCE))
{
// an ActionSource2 is-a ActionSource
if (interfaceNameSets
.contains(ComponentFactory.INTERFACE_ACTIONSOURCE2)
&& component.getAdapter(ComponentFactory.ACTION_SOURCE2) == null)
{
component.addAdapter(ComponentFactory.ACTION_SOURCE2,
new ActionSourceInfo2(null, null, false, null));
}
if (component.getAdapter(ComponentFactory.ACTION_SOURCE) == null)
{
component.addAdapter(ComponentFactory.ACTION_SOURCE,
new ActionSourceInfo(null, null, false));
}
}
if (interfaceNameSets.contains(ComponentFactory.INTERFACE_VALUEHOLDER))
{
// a EditableValueHolder is-a ValueHolder
if (interfaceNameSets
.contains(ComponentFactory.INTERFACE_EDITABLEVALUEHOLDER)
&& component
.getAdapter(ComponentFactory.EDITABLE_VALUE_HOLDER) == null)
{
component.addAdapter(ComponentFactory.EDITABLE_VALUE_HOLDER,
new EditableValueHolderInfo(null, null, null, false,
false, true, false, null, null, null));
}
if (component.getAdapter(ComponentFactory.VALUE_HOLDER) == null)
{
component.addAdapter(ComponentFactory.VALUE_HOLDER,
new ValueHolderInfo(null, null, null));
}
}
if (interfaceNameSets
.contains(ComponentFactory.INTERFACE_NAMINGCONTAINER)
&& component.getAdapter(ComponentFactory.NAMING_CONTAINER) == null)
{
component.addAdapter(ComponentFactory.NAMING_CONTAINER,
INamingContainerInfo.ADAPTER);
}
}
/**
* @param element
* @param constructionData
* @return the id for element either derived from the element using getId or
* if not present, using a generation algorithm
*/
protected String calculateId(final Element element,
final ComponentConstructionData constructionData)
{
final String id = _adapter.getId(element);
if (id != null)
{
return id;
}
// TODO: improve this
final String prefix = _adapter.getGeneratedIdPrefix();
return (prefix != null ? prefix : GENERATED_ID)
+ constructionData.increment();
}
/**
* @return the construction data for this strategy
*/
public final ComponentConstructionData getConstructionData()
{
return _constructionData;
}
}