diff options
Diffstat (limited to 'jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry')
58 files changed, 9950 insertions, 0 deletions
diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/ELProxyContributor.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/ELProxyContributor.java new file mode 100644 index 000000000..c000bbc3c --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/ELProxyContributor.java @@ -0,0 +1,53 @@ +package org.eclipse.jst.jsf.facelet.core.internal.registry; + +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.jdt.core.IJavaProject; +import org.eclipse.jdt.core.IType; +import org.eclipse.jdt.core.JavaCore; +import org.eclipse.jem.internal.proxy.core.ConfigurationContributorAdapter; +import org.eclipse.jem.internal.proxy.core.IConfigurationContributionController; +import org.eclipse.jst.jsf.facelet.core.internal.FaceletCorePlugin; +import org.osgi.framework.Bundle; + +/** + * Contributes additional, sometimes fake, jars to the JEM classpath to allow + * for smooth instantiation of introspected objects. + * + * @author cbateman + * + */ +public class ELProxyContributor extends ConfigurationContributorAdapter +{ + private final IProject _project; + + /** + * @param project + */ + public ELProxyContributor(final IProject project) + { + _project = project; + } + + @Override + public void contributeClasspaths( + final IConfigurationContributionController controller) + throws CoreException + { + if (_project.isAccessible()) + { + final IJavaProject javaProject = JavaCore.create(_project); + final IType type = javaProject.findType("java.el.ELException"); //$NON-NLS-1$ + + // if we can't find ELException on the classpath,then inject + // our fake el jar to aid linkage while introspecting facelet libs + if (type == null) + { + final Bundle faceletBundle = FaceletCorePlugin.getDefault().getBundle(); + controller.contributeClasspath(faceletBundle, "/jars/fake_el.jar", //$NON-NLS-1$ + IConfigurationContributionController.APPEND_USER_CLASSPATH, + false); + } + } + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/FaceletMetaResolvingStrategy.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/FaceletMetaResolvingStrategy.java new file mode 100644 index 000000000..9319cbd0a --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/FaceletMetaResolvingStrategy.java @@ -0,0 +1,210 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry; + +import java.util.Iterator; + +import org.eclipse.core.resources.IProject; +import org.eclipse.emf.common.util.EList; +import org.eclipse.jst.jsf.common.dom.TagIdentifier; +import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentTypeInfo; +import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterTypeInfo; +import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValidatorTypeInfo; +import org.eclipse.jst.jsf.common.runtime.internal.model.types.TypeInfo; +import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ITagElement; +import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.IHandlerTagElement.TagHandlerType; +import org.eclipse.jst.jsf.core.internal.tld.TagIdentifierFactory; +import org.eclipse.jst.jsf.designtime.internal.Messages; +import org.eclipse.jst.jsf.designtime.internal.view.mapping.ViewMetadataLoader; +import org.eclipse.jst.jsf.designtime.internal.view.mapping.ViewMetadataMapper; +import org.eclipse.jst.jsf.designtime.internal.view.mapping.viewmapping.TagMapping; +import org.eclipse.jst.jsf.designtime.internal.view.mapping.viewmapping.TagToViewObjectMapping; +import org.eclipse.jst.jsf.designtime.internal.view.model.jsp.AbstractTagResolvingStrategy; +import org.eclipse.jst.jsf.designtime.internal.view.model.jsp.DefaultTagTypeInfo; +import org.eclipse.jst.jsf.facelet.core.internal.cm.FaceletDocumentFactory; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.ComponentTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.ConverterTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.HandlerTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.NoArchetypeFaceletTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.ValidatorTag; +import org.osgi.framework.Version; + +/** + * Resolves facelet tags from JSF framework metadata. + * + * @author cbateman + * + */ +public class FaceletMetaResolvingStrategy + extends + AbstractTagResolvingStrategy<IFaceletTagResolvingStrategy.TLDWrapper, String> + implements IFaceletTagResolvingStrategy +{ + + /** + * strategy id + */ + public final static String ID = "org.eclipse.jst.jsf.facelet.metadata.FaceletMetaResolvingStrategy"; //$NON-NLS-1$ + /** + * displayable nameb + */ + public final static String DISPLAY_NAME = Messages.DefaultJSPTagResolver_DisplayName; + + private final ViewMetadataLoader _loader; + private final ViewMetadataMapper _mapper; + private final FaceletDocumentFactory _factory; + + /** + * @param project + * @param factory + */ + public FaceletMetaResolvingStrategy(final IProject project, + final FaceletDocumentFactory factory) + { + _factory = factory; + _loader = new ViewMetadataLoader(project); + _mapper = new ViewMetadataMapper(); + } + + @Override + public ITagElement resolve( + final IFaceletTagResolvingStrategy.TLDWrapper elementDecl) + { + // final IProjectFacetVersion version = JSFAppConfigUtils + // .getProjectFacet(_project); + // final String versionAsString = version.getVersionString(); + // final JSFVersion jsfVersion = + // JSFVersion.valueOfString(versionAsString); + + final String uri = elementDecl.getUri(); + final String tagName = elementDecl.getTagDefn().getName(); + final TagIdentifier tagId = TagIdentifierFactory.createJSPTagWrapper( + uri, tagName); + // final DefaultTagTypeInfo defaultTagTypeInfo = new + // DefaultTagTypeInfo(); + final TagMapping mapping = _loader.getTagToViewMapping(tagId); + + TypeInfo elementType = null; + if (mapping != null) + { + elementType = findTypeInfo(mapping, "1.1", null); //$NON-NLS-1$ + } + + if (elementType instanceof ComponentTypeInfo) + { + return new ComponentTag(uri, tagName, + (ComponentTypeInfo) elementType, null, _factory, + new MetadataAttributeAdvisor(tagId, _loader)); + } + else if (elementType instanceof ConverterTypeInfo) + { + return new ConverterTag(uri, tagName, + (ConverterTypeInfo) elementType, null, _factory, + new MetadataAttributeAdvisor(tagId, _loader)); + } + else if (elementType instanceof ValidatorTypeInfo) + { + return new ValidatorTag(uri, tagName, + (ValidatorTypeInfo) elementType, null, _factory, + new MetadataAttributeAdvisor(tagId, _loader)); + } + else if (elementType instanceof TagHandlerType) + { + return new HandlerTag(uri, tagName, + (TagHandlerType) elementType, null, _factory, + new MetadataAttributeAdvisor( + tagId, _loader)); + } + else if (DefaultTagTypeInfo.isDefaultLib(tagId.getUri())) + { + return new NoArchetypeFaceletTag(uri, tagName, _factory, new MetadataAttributeAdvisor(tagId, _loader)); + } + + // not found + return null; + } + + private TypeInfo findTypeInfo(final TagMapping mapping, + final String jsfVersion, final String libVersion) + { + final EList list = mapping.getVersionedTagToViewMappings(); + + FIND_BY_VERSION: for (final Iterator<?> it = list.iterator(); it + .hasNext();) + { + Object obj = it.next(); + + if (obj instanceof TagToViewObjectMapping) + { + final TagToViewObjectMapping viewMapping = (TagToViewObjectMapping) obj; + + final String minJsfVersionString = viewMapping + .getMinJSFVersion(); + if (minJsfVersionString != null) + { + try + { + final Version version = new Version(jsfVersion); + final Version minVersion = Version + .parseVersion(minJsfVersionString); + + if (version.compareTo(minVersion) < 0) + { + // my version is less than the minimum specified + // by this meta-data + continue FIND_BY_VERSION; + } + } + catch (final IllegalArgumentException iae) + { + continue FIND_BY_VERSION; + } + } + final String minLibVersionString = viewMapping + .getMinLibraryVersion(); + if (libVersion != null && minLibVersionString != null) + { + try + { + final Version version = new Version(libVersion); + final Version minLibVersion = Version + .parseVersion(minLibVersionString); + + if (version.compareTo(minLibVersion) < 0) + { + // my lib version is less than the minimum specified + // by the meta-data + continue FIND_BY_VERSION; + } + } + catch (IllegalArgumentException iae) + { + continue FIND_BY_VERSION; + } + } + return _mapper.mapToFrameworkData(viewMapping.getTypeInfo()); + } + } + return null; + } + + @Override + public String getId() + { + return ID; + } + + public String getDisplayName() + { + return DISPLAY_NAME; + } + +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/FaceletRegistryManager.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/FaceletRegistryManager.java new file mode 100644 index 000000000..239cb6f88 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/FaceletRegistryManager.java @@ -0,0 +1,112 @@ +package org.eclipse.jst.jsf.facelet.core.internal.registry; + +import org.eclipse.core.resources.IProject; +import org.eclipse.jst.jsf.common.internal.resource.ResourceSingletonObjectManager; +import org.eclipse.jst.jsf.designtime.internal.view.model.ITagRegistry; +import org.eclipse.jst.jsf.designtime.internal.view.model.TagRegistryFactory; +import org.eclipse.jst.jsf.facelet.core.internal.FaceletCoreTraceOptions; + +/** + * A per-resource singleton manager for TLDTagRegistry's. + * + * @author cbateman + * + */ +public final class FaceletRegistryManager extends + ResourceSingletonObjectManager<FaceletTagRegistry, IProject> +{ + // STATIC + private static FaceletRegistryManager INSTANCE; + + /** + * @return the singleton instance + */ + private static FaceletRegistryManager getGlobalManager() + { + if (FaceletCoreTraceOptions.TRACE_REGISTRYMANAGER) + { + FaceletCoreTraceOptions + .log("FaceletRegistryManager: Initializing FaceletRegistryManager singleton"); //$NON-NLS-1$ + } + + synchronized(FaceletRegistryManager.class) + { + if (INSTANCE == null) + { + INSTANCE = new FaceletRegistryManager(); + } + + return INSTANCE; + } + } + + private FaceletRegistryManager() + { + // do nothing + } + + @Override + protected FaceletTagRegistry createNewInstance(final IProject project) + { + if (FaceletCoreTraceOptions.TRACE_REGISTRYMANAGER) + { + FaceletCoreTraceOptions.log("FaceletRegistryManager: creating new instance for " //$NON-NLS-1$ + + project.toString()); + } + + return new FaceletTagRegistry(project); + } + + @Override + protected void runAfterGetInstance(final IProject resource) + { + if (FaceletCoreTraceOptions.TRACE_REGISTRYMANAGER) + { + FaceletCoreTraceOptions.log("FaceletRegistryManager: Acquired instance for " //$NON-NLS-1$ + + resource.toString()); + } + } + + @Override + protected void runBeforeGetInstance(final IProject resource) + { + if (FaceletCoreTraceOptions.TRACE_REGISTRYMANAGER) + { + FaceletCoreTraceOptions.log("FaceletRegistryManager: Getting registry for " //$NON-NLS-1$ + + resource.toString()); + } + } + + /** + * Adapter used to allow creation by extension point. + * + * @author cbateman + * + */ + public static class MyRegistryFactory extends TagRegistryFactory + { + @Override + public ITagRegistry createTagRegistry(IProject project) throws TagRegistryFactoryException + { + try + { + return getGlobalManager().getInstance(project); + } + catch (ManagedObjectException e) + { + throw new TagRegistryFactoryException(e); + } + } + + @Override + public boolean isInstance(IProject project) + { + return getGlobalManager().isInstance(project); + } + + public String getDisplayName() + { + return Messages.FaceletRegistryManager_REGISTRY_FACTORY_DISPLAYNAME; + } + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/FaceletTagRegistry.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/FaceletTagRegistry.java new file mode 100644 index 000000000..1d0d8ce3b --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/FaceletTagRegistry.java @@ -0,0 +1,383 @@ +package org.eclipse.jst.jsf.facelet.core.internal.registry; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentLinkedQueue; + +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.MultiStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.core.runtime.jobs.Job; +import org.eclipse.jdt.core.JavaCore; +import org.eclipse.jdt.core.JavaModelException; +import org.eclipse.jst.jsf.common.internal.managedobject.IManagedObject; +import org.eclipse.jst.jsf.common.internal.managedobject.ObjectManager.ManagedObjectException; +import org.eclipse.jst.jsf.common.internal.policy.IdentifierOrderedIteratorPolicy; +import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.Namespace; +import org.eclipse.jst.jsf.core.internal.JSFCorePlugin; +import org.eclipse.jst.jsf.core.internal.JSFCoreTraceOptions; +import org.eclipse.jst.jsf.designtime.internal.view.model.AbstractTagRegistry; +import org.eclipse.jst.jsf.designtime.internal.view.model.jsp.CompositeTagResolvingStrategy; +import org.eclipse.jst.jsf.facelet.core.internal.FaceletCorePlugin; +import org.eclipse.jst.jsf.facelet.core.internal.FaceletCoreTraceOptions; +import org.eclipse.jst.jsf.facelet.core.internal.cm.FaceletDocumentFactory; +import org.eclipse.jst.jsf.facelet.core.internal.registry.IFaceletTagResolvingStrategy.TLDWrapper; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.FaceletTagIndex; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.IFaceletTagRecord; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.IProjectTaglibDescriptor; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.Listener; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.FaceletNamespace; + +/** + * Registry of all facelet tag registries: at most one per project. + * + */ +public final class FaceletTagRegistry extends AbstractTagRegistry implements + IManagedObject +{ + // INSTANCE + private final ConcurrentLinkedQueue<LibraryOperation> _changeOperations = new ConcurrentLinkedQueue<LibraryOperation>(); + + private final IProject _project; + private final Map<String, FaceletNamespace> _nsResolved; + private final Set<FaceletNamespace> _unResolved; + private final CompositeTagResolvingStrategy<TLDWrapper> _resolver; + private final FaceletDocumentFactory _factory; + private final LibraryOperationFactory _operationFactory = new LibraryOperationFactory( + this); + private boolean _isInitialized; + + private ChangeJob _changeJob; + private MyTaglibListener _listener; + + FaceletTagRegistry(final IProject project) + { + _project = project; + _nsResolved = new HashMap<String, FaceletNamespace>(); + _unResolved = new HashSet<FaceletNamespace>(); + + final List<String> ids = new ArrayList<String>(); + ids.add(FaceletMetaResolvingStrategy.ID); + ids.add(FaceletTagResolvingStrategy.ID); + final IdentifierOrderedIteratorPolicy<String> policy = new IdentifierOrderedIteratorPolicy<String>( + ids); + + // exclude things that are not explicitly listed in the policy. That + // way preference-based disablement will cause those strategies to + // be excluded. + policy.setExcludeNonExplicitValues(true); + _resolver = new CompositeTagResolvingStrategy<TLDWrapper>(policy); + + _factory = new FaceletDocumentFactory(project); + // add the strategies + _resolver.addStrategy(new FaceletTagResolvingStrategy(_project, + _factory)); + _resolver.addStrategy(new FaceletMetaResolvingStrategy(_project, _factory)); + + // _resolver.addStrategy(new DefaultJSPTagResolver(_project)); + // makes sure that a tag element will always be created for any + // given tag definition even if other methods fail + // _resolver.addStrategy(new UnresolvedJSPTagResolvingStrategy()); + _changeJob = new ChangeJob(project.getName()); + } + + /** + * @return a copy of all tag libs, both with namespaces resolved and without + * Changing the returned may has no effect on the registry, however + * the containned objects are not copies. + */ + @Override + public synchronized Collection<FaceletNamespace> getAllTagLibraries() + { + final Set<FaceletNamespace> allTagLibraries = new HashSet<FaceletNamespace>(); + if (!_isInitialized) + { + try + { + initialize(false); + _isInitialized = true; + } + catch (final JavaModelException e) + { + FaceletCorePlugin.log("Problem during initialization", e); //$NON-NLS-1$ + } + catch (final CoreException e) + { + FaceletCorePlugin.log("Problem during initialization", e); //$NON-NLS-1$ + } + } + allTagLibraries.addAll(_nsResolved.values()); + allTagLibraries.addAll(_unResolved); + return allTagLibraries; + } + + private void initialize(boolean fireEvent) throws JavaModelException, CoreException + { + if (!_project.exists() || !_project.hasNature(JavaCore.NATURE_ID)) + { + throw new CoreException(new Status(IStatus.ERROR, + FaceletCorePlugin.PLUGIN_ID, + "Project either does not exists or is not a java project: " //$NON-NLS-1$ + + _project)); + } + + final FaceletTagIndex index = FaceletTagIndex.getInstance(); + + IProjectTaglibDescriptor tagDesc; + try + { + tagDesc = index.getInstance(_project); + } + catch (ManagedObjectException e) + { + throw new CoreException( + new Status( + IStatus.ERROR, + FaceletCorePlugin.PLUGIN_ID, + "Error instantiating facelet tag index for project: " + _project.getName(), e)); //$NON-NLS-1$ + } + + if (tagDesc != null) + { + for (final IFaceletTagRecord taglib : tagDesc.getTagLibraries()) + { + initialize(taglib, fireEvent); + } + + _listener = new MyTaglibListener(); + tagDesc.addListener(_listener); + } + } + + FaceletNamespace initialize(final IFaceletTagRecord tagRecord, + final boolean fireEvent) + { + if (JSFCoreTraceOptions.TRACE_JSPTAGREGISTRY_CHANGES) + { + FaceletCoreTraceOptions + .log("TLDTagRegistry.initialize_TagRecord: Initializing new tld record: " + tagRecord.toString()); //$NON-NLS-1$ + } + // long startTime = 0; + // + // if (JSFCoreTraceOptions.TRACE_JSPTAGREGISTRY_PERF) + // { + // startTime = System.nanoTime(); + // } + final FaceletNamespace ns = new FaceletNamespace(tagRecord, _resolver); + _nsResolved.put(tagRecord.getURI(), ns); + + if (fireEvent) + { + fireEvent(new TagRegistryChangeEvent(this, + TagRegistryChangeEvent.EventType.ADDED_NAMESPACE, + Collections.singletonList(ns))); + } + + // if (FaceletCoreTraceOptions.TRACE_JSPTAGREGISTRY_PERF) + // { + // System.out.printf("Time to update namespace %s was %d\n", //$NON-NLS-1$ + // ns.getNSUri(), Long.valueOf(System.nanoTime() + // - startTime)); + // } + return ns; + } + + void remove(final IFaceletTagRecord tagRecord) + { + final FaceletNamespace ns = _nsResolved.remove(tagRecord.getURI()); + + if (ns != null) + { + fireEvent(new TagRegistryChangeEvent(this, + TagRegistryChangeEvent.EventType.REMOVED_NAMESPACE, + Collections.singletonList(ns))); + } + } + + @Override + public synchronized Namespace getTagLibrary(final String uri) + { + // TODO: + getAllTagLibraries(); + return _nsResolved.get(uri); + } + + @Override + protected Job getRefreshJob(final boolean flushCaches) + { + return new Job("Refreshing Facelet tag registry for " + _project.getName()) //$NON-NLS-1$ + { + @Override + protected IStatus run(final IProgressMonitor monitor) + { +// if (FaceletCoreTraceOptions.TRACE_JSPTAGREGISTRY) +// { +// JSFCoreTraceOptions.log("FaceletTagRegistry.refresh: start"); //$NON-NLS-1$ +// } + + synchronized (FaceletTagRegistry.this) + { + if (JSFCoreTraceOptions.TRACE_JSPTAGREGISTRY) + { + JSFCoreTraceOptions + .log("FaceletTagRegistry.refresh: start"); //$NON-NLS-1$ + } + + final List<Namespace> namespaces = new ArrayList( + _nsResolved.values()); + + if (flushCaches) + { + FaceletTagIndex.getInstance().flush(_project); + } + // if we aren't flushing caches, then check point the + // current namespace data, so it isn't lost when we clear + // THE NAMESPACES + else + { + checkpoint(); + } + + _nsResolved.clear(); + + fireEvent(new TagRegistryChangeEvent(FaceletTagRegistry.this, + TagRegistryChangeEvent.EventType.REMOVED_NAMESPACE, + namespaces)); + try + { + initialize(true); + } + catch (JavaModelException e) + { + return new Status(IStatus.ERROR, FaceletCorePlugin.PLUGIN_ID, "Problem refreshing registry", e); //$NON-NLS-1$ + } + catch (CoreException e) + { + return new Status(IStatus.ERROR, FaceletCorePlugin.PLUGIN_ID, "Problem refreshing registry", e); //$NON-NLS-1$ + } + +// if (JSFCoreTraceOptions.TRACE_JSPTAGREGISTRY) +// { +// JSFCoreTraceOptions +// .log("TLDTagRegistry.refresh: finished"); +// } + return Status.OK_STATUS; + } + } + }; + } + + private class MyTaglibListener extends Listener + { + @Override + public void changed(TaglibChangedEvent event) + { + switch (event.getChangeType()) + { + case ADDED: + addLibraryOperation(_operationFactory + .createAddOperation(event.getNewValue())); + break; + case CHANGED: + addLibraryOperation(_operationFactory + .createChangeOperation(event.getNewValue())); + break; + case REMOVED: + addLibraryOperation(_operationFactory + .createRemoveOperation(event.getOldValue())); + break; + } + } + } + + private void addLibraryOperation(final LibraryOperation operation) + { + _changeOperations.add(operation); + _changeJob.schedule(); + } + + private class ChangeJob extends Job + { + private int _rescheduleTime = -1; + + public ChangeJob(final String projectName) + { + super("Update job for project " + projectName); //$NON-NLS-1$ + } + + @Override + protected IStatus run(final IProgressMonitor monitor) + { + synchronized (FaceletTagRegistry.this) + { + _rescheduleTime = -1; + + LibraryOperation operation = null; + final MultiStatus multiStatus = new MultiStatus( + JSFCorePlugin.PLUGIN_ID, 0, "Result of change job", //$NON-NLS-1$ + new Throwable()); + while ((operation = _changeOperations.poll()) != null) + { + _rescheduleTime = 10000; // ms + + operation.run(); + multiStatus.add(operation.getResult()); + } + + if (_rescheduleTime >= 0 && !monitor.isCanceled()) + { + // if any operations were found on this run, reschedule + // to run again in 10seconds based on the assumption that + // events may be coming in bursts + schedule(_rescheduleTime); + } + + return multiStatus; + } + } + } + + @Override + protected void doDispose() + { + if (_listener != null) + { + FaceletTagIndex index = FaceletTagIndex.getInstance(); + try + { + IProjectTaglibDescriptor instance = index.getInstance(_project); + instance.removeListener(_listener); + } + catch (ManagedObjectException e) + { + FaceletCorePlugin + .log( + "Disposing facelet tag registry for project: " + _project.getName(), e); //$NON-NLS-1$ + } + + _nsResolved.clear(); + } + } + + @Override + protected void cleanupPersistentState() + { + // TODO ?? + + } + + public void checkpoint() + { + // TODO ?? + + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/FaceletTagResolvingStrategy.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/FaceletTagResolvingStrategy.java new file mode 100644 index 000000000..b3f70afa8 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/FaceletTagResolvingStrategy.java @@ -0,0 +1,167 @@ +package org.eclipse.jst.jsf.facelet.core.internal.registry; + +import org.eclipse.core.resources.IProject; +import org.eclipse.jem.internal.proxy.core.IConfigurationContributor; +import org.eclipse.jst.jsf.common.dom.TagIdentifier; +import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentTypeInfo; +import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterTypeInfo; +import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValidatorTypeInfo; +import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ITagElement; +import org.eclipse.jst.jsf.core.internal.tld.TagIdentifierFactory; +import org.eclipse.jst.jsf.designtime.internal.view.DTComponentIntrospector; +import org.eclipse.jst.jsf.designtime.internal.view.mapping.ViewMetadataLoader; +import org.eclipse.jst.jsf.designtime.internal.view.model.jsp.AbstractTagResolvingStrategy; +import org.eclipse.jst.jsf.designtime.internal.view.model.jsp.IAttributeAdvisor; +import org.eclipse.jst.jsf.facelet.core.internal.cm.FaceletDocumentFactory; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.HandlerTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.SourceTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.ComponentTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.ConverterTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.FaceletTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.HandlerTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.NoArchetypeFaceletTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.SourceTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.ValidatorTag; + +/*package*/class FaceletTagResolvingStrategy + extends + AbstractTagResolvingStrategy<IFaceletTagResolvingStrategy.TLDWrapper, String> + implements IFaceletTagResolvingStrategy +{ + public final static String ID = "org.eclipse.jst.jsf.facelet.core.FaceletTagResolvingStrategy"; //$NON-NLS-1$ + private final IProject _project; + private final FaceletDocumentFactory _factory; + private final ViewMetadataLoader _viewLoader; + + public FaceletTagResolvingStrategy(final IProject project, + final FaceletDocumentFactory factory) + { + _project = project; + _factory = factory; + _viewLoader = new ViewMetadataLoader(project); + } + + @Override + public final String getId() + { + return ID; + } + + @Override + public final ITagElement resolve(final TLDWrapper tldWrapper) + { + return createFaceletTag(tldWrapper.getUri(), tldWrapper.getTagDefn()); + } + + public final String getDisplayName() + { + return Messages.FaceletTagResolvingStrategy_FACELET_TAG_RESOLVER_DISPLAY_NAME; + } + + private FaceletTag createFaceletTag(final String uri, final TagDefn tagDefn) + { + final String tagName = tagDefn.getName(); + final TagIdentifier tagId = TagIdentifierFactory.createJSPTagWrapper( + uri, tagName); + + final IAttributeAdvisor advisor = new MetadataAttributeAdvisor(tagId, + _viewLoader); + + if (tagDefn instanceof ComponentTagDefn) + { + final ComponentTagDefn componentTagDefn = (ComponentTagDefn) tagDefn; + final String componentType = componentTagDefn.getComponentType(); + final String componentClass = DTComponentIntrospector + .findComponentClass(componentType, _project); + + ComponentTypeInfo typeInfo = null; + + if (componentClass != null) + { + typeInfo = DTComponentIntrospector.getComponent(componentType, + componentClass, _project, + new IConfigurationContributor[] + { new ELProxyContributor(_project) }); + } + return new ComponentTag(uri, tagName, typeInfo, safeGetString(componentTagDefn.getHandlerClass()), _factory, advisor); + } + // render type is optional, but must have component type + else if (tagDefn instanceof ValidatorTagDefn) + { + final ValidatorTagDefn validatorTagDefn = (ValidatorTagDefn) tagDefn; + final String validatorId = validatorTagDefn.getValidatorId(); + + ValidatorTypeInfo typeInfo; + + if (validatorId != null) + { + final String validatorClass = DTComponentIntrospector + .findValidatorClass(validatorId, _project); + typeInfo = new ValidatorTypeInfo(validatorClass, validatorId); + } + else + { + typeInfo = ValidatorTypeInfo.UNKNOWN; + } + + return new ValidatorTag(uri, tagName, typeInfo, safeGetString(validatorTagDefn.getHandlerClass()), _factory, + advisor); + } + // render type is optional, but must have converter id + else if (tagDefn instanceof ConverterTagDefn) + { + final ConverterTagDefn converterTagDefn = (ConverterTagDefn) tagDefn; + final String converterId = converterTagDefn.getConverterId(); + + ConverterTypeInfo typeInfo; + + if (converterId != null) + { + final String converterClass = DTComponentIntrospector + .findConverterClass(converterId, _project); + typeInfo = new ConverterTypeInfo(converterClass, converterId); + } + else + { + typeInfo = ConverterTypeInfo.UNKNOWN; + } + + // for now, all converters are unknown + return new ConverterTag(uri, tagName, typeInfo, + safeGetString(converterTagDefn.getHandlerClass()), _factory, advisor); + } + else if (tagDefn instanceof HandlerTagDefn) + { + final String handlerClass = safeGetString(((HandlerTagDefn)tagDefn).getHandlerClass()); + return new HandlerTag(uri, tagName, null, handlerClass, _factory, advisor); + } + else if (tagDefn instanceof SourceTagDefn) + { + final String source = ((SourceTagDefn)tagDefn).getSource(); + return new SourceTag(uri, tagName, source, _factory, advisor); + } + + return new NoArchetypeFaceletTag(uri, tagName, _factory, advisor); + } + + private static String safeGetString(final String value) + { + if (value == null) + { + return null; + } + + final String trimmed = value.trim(); + + if ("".equals(trimmed)) //$NON-NLS-1$ + { + return null; + } + + return trimmed; + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/IFaceletTagResolvingStrategy.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/IFaceletTagResolvingStrategy.java new file mode 100644 index 000000000..5de18c8ee --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/IFaceletTagResolvingStrategy.java @@ -0,0 +1,63 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry; + +import org.eclipse.jst.jsf.designtime.internal.view.model.jsp.ITagResolvingStrategy; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn; + +/** + * @author cbateman + * + */ +public interface IFaceletTagResolvingStrategy extends + ITagResolvingStrategy<IFaceletTagResolvingStrategy.TLDWrapper, String> +{ + + /** + * Wraps data for Facelet tag information to used by the resolving strategy + * + * @author cbateman + * + */ + public static class TLDWrapper + { + private final String _uri; + private final TagDefn _tagDefn; + + /** + * @param tagDefn + * @param uri + */ + public TLDWrapper(TagDefn tagDefn, String uri) + { + super(); + _tagDefn = tagDefn; + _uri = uri; + } + + /** + * @return the uri for the tld namespace + */ + public final String getUri() + { + return _uri; + } + + /** + * @return the tag definition information + */ + public final TagDefn getTagDefn() + { + return _tagDefn; + } + + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/LibraryOperation.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/LibraryOperation.java new file mode 100644 index 000000000..51a5d4d1d --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/LibraryOperation.java @@ -0,0 +1,47 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry; + +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.jst.jsf.facelet.core.internal.FaceletCorePlugin; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.IFaceletTagRecord; + +abstract class LibraryOperation +{ + protected final IFaceletTagRecord _changeRecord; + private IStatus _result; + + protected LibraryOperation(final IFaceletTagRecord changeRecord) + { + _changeRecord = changeRecord; + } + + public final void run() + { + try + { + _result = doRun(); + } + catch (final Exception e) + { + _result = new Status(IStatus.ERROR, FaceletCorePlugin.PLUGIN_ID, + "Problem during run", e); //$NON-NLS-1$ + } + } + + public IStatus getResult() + { + return _result; + } + + protected abstract IStatus doRun(); +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/LibraryOperationFactory.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/LibraryOperationFactory.java new file mode 100644 index 000000000..c69cbfed9 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/LibraryOperationFactory.java @@ -0,0 +1,122 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry; + +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.IFaceletTagRecord; + +class LibraryOperationFactory +{ + private final FaceletTagRegistry _tagRegistry; + + public LibraryOperationFactory(final FaceletTagRegistry tagRegistry) + { + _tagRegistry = tagRegistry; + } + + LibraryOperation createAddOperation(final IFaceletTagRecord changeRecord) + { + return new AddTagLibrary(_tagRegistry, changeRecord); + } + + LibraryOperation createRemoveOperation(final IFaceletTagRecord changeRecord) + { + return new RemoveTagLibrary(_tagRegistry, changeRecord); + } + + LibraryOperation createChangeOperation(final IFaceletTagRecord changeRecord) + { + if (changeRecord == null) + { + throw new IllegalArgumentException(); + } + return new ChangeTagLibrary(_tagRegistry, changeRecord); + } + + private static class AddTagLibrary extends LibraryOperation + { + private final FaceletTagRegistry _tagRegistry; + + public AddTagLibrary(final FaceletTagRegistry tagRegistry, + final IFaceletTagRecord newRecord) + { + super(newRecord); + _tagRegistry = tagRegistry; + } + + @Override + protected IStatus doRun() + { + synchronized (_tagRegistry) + { + // fire change event if applicable + _tagRegistry.initialize(_changeRecord, true); + return Status.OK_STATUS; + } + } + } + + private static class RemoveTagLibrary extends LibraryOperation + { + private final FaceletTagRegistry _tagRegistry; + + protected RemoveTagLibrary(final FaceletTagRegistry tagRegistry, + final IFaceletTagRecord changeRecord) + { + super(changeRecord); + _tagRegistry = tagRegistry; + } + + @Override + protected IStatus doRun() + { + _tagRegistry.remove(_changeRecord); + return Status.OK_STATUS; + + } + + } + + private static class ChangeTagLibrary extends LibraryOperation + { + private final FaceletTagRegistry _tagRegistry; + + protected ChangeTagLibrary(final FaceletTagRegistry tagRegistry, + final IFaceletTagRecord changeRecord) + { + super(changeRecord); + _tagRegistry = tagRegistry; + } + + @Override + protected IStatus doRun() + { + IStatus result = null; + + synchronized (_tagRegistry) + { + result = new RemoveTagLibrary(_tagRegistry, _changeRecord).doRun(); + + if (result.getSeverity() != IStatus.ERROR + && result.getSeverity() != IStatus.CANCEL) + { + result = new AddTagLibrary(_tagRegistry, _changeRecord) + .doRun(); + } + } + + return result; + } + + } + +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/Messages.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/Messages.java new file mode 100644 index 000000000..1a4f0d641 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/Messages.java @@ -0,0 +1,46 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry; + +import org.eclipse.osgi.util.NLS; + +/** + * Externalized string manager. + * + * @author cbateman + * + */ +public final class Messages extends NLS +{ + private static final String BUNDLE_NAME = "org.eclipse.jst.jsf.facelet.core.internal.registry.messages"; //$NON-NLS-1$ + /** + * see messages.properties + */ + public static String FaceletRegistryManager_REGISTRY_FACTORY_DISPLAYNAME; + /** + * see messages.properties + */ + public static String FaceletTagRegistry_TAG_REGISTRY_REFRESH_JOB_DESCRIPTION; + /** + * see messages.properties + */ + public static String FaceletTagResolvingStrategy_FACELET_TAG_RESOLVER_DISPLAY_NAME; + static + { + // initialize resource bundle + NLS.initializeMessages(BUNDLE_NAME, Messages.class); + } + + private Messages() + { + // no instantiation + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/MetadataAttributeAdvisor.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/MetadataAttributeAdvisor.java new file mode 100644 index 000000000..4fda2e538 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/MetadataAttributeAdvisor.java @@ -0,0 +1,63 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry; + +import org.eclipse.jst.jsf.common.dom.TagIdentifier; +import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ComponentPropertyHandler; +import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ITagAttributeHandler; +import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.TagAttributeHandler; +import org.eclipse.jst.jsf.designtime.internal.view.mapping.ViewMetadataLoader; +import org.eclipse.jst.jsf.designtime.internal.view.mapping.viewmapping.AttributeToPropertyMapping; +import org.eclipse.jst.jsf.designtime.internal.view.model.jsp.IAttributeAdvisor; + +/** + * An attribute advisor that composes multiple strategies for deriving information + * about Facelet tags. + * + * @author cbateman + * + */ +/*package*/ class MetadataAttributeAdvisor implements IAttributeAdvisor +{ + private final TagIdentifier _tagId; + private final ViewMetadataLoader _loader; + + /** + * @param tagId + * @param loader + */ + public MetadataAttributeAdvisor(final TagIdentifier tagId, + final ViewMetadataLoader loader) + { + _tagId = tagId; + _loader = loader; + } + + public ITagAttributeHandler createAttributeHandler(final String name) + throws UnknownAttributeException + { + final AttributeToPropertyMapping mapping = _loader.getAttributeMapping( + _tagId, name); + if (mapping != null) + { + final String customHandler = mapping.getCustomConversionFactoryId(); + final boolean isELAllowed = mapping.isElAllowed(); + final String propertyName = mapping.getPropertyName(); + if (propertyName != null) + { + return new ComponentPropertyHandler(customHandler, name, + isELAllowed, propertyName); + } + return new TagAttributeHandler(customHandler, name, isELAllowed); + } + return new TagAttributeHandler(null, name, false); + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/ServletBeanProxyContributor.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/ServletBeanProxyContributor.java new file mode 100644 index 000000000..23947381b --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/ServletBeanProxyContributor.java @@ -0,0 +1,58 @@ +/** + * + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry; + +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IPath; +import org.eclipse.core.runtime.Platform; +import org.eclipse.jem.internal.proxy.core.ConfigurationContributorAdapter; +import org.eclipse.jem.internal.proxy.core.IConfigurationContributionController; +import org.eclipse.jst.jsf.core.JSFVersion; +import org.osgi.framework.Bundle; + +/** + * Contributes dummy jsp servlet api to smooth the JEM instantiation for introspection. + * + * @author cbateman + * + */ +public class ServletBeanProxyContributor extends ConfigurationContributorAdapter +{ + private static final String JAVAX_SERVLET_JSP = "javax.servlet.jsp"; //$NON-NLS-1$ + private static final String JAVAX_SERVLET = "javax.servlet"; //$NON-NLS-1$ + private final JSFVersion _jsfVersion; + + /** + * @param jsfVersion + */ + public ServletBeanProxyContributor(final JSFVersion jsfVersion) + { + if (jsfVersion == null) + { + throw new IllegalArgumentException("jsfVersion must not be null"); //$NON-NLS-1$ + } + + _jsfVersion = jsfVersion; + } + + @Override + public void contributeClasspaths( + final IConfigurationContributionController controller) + throws CoreException + { + if (_jsfVersion != JSFVersion.V1_2) + { + final Bundle servletBundle = Platform.getBundle(JAVAX_SERVLET); + controller.contributeClasspath(servletBundle, (IPath) null, + IConfigurationContributionController.APPEND_USER_CLASSPATH, + true); + + final Bundle jspBundle = Platform.getBundle(JAVAX_SERVLET_JSP); + controller.contributeClasspath(jspBundle, (IPath) null, + IConfigurationContributionController.APPEND_USER_CLASSPATH, + true); + } + + } +}
\ No newline at end of file diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/VeryTemporaryDefaultFaceletResolver.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/VeryTemporaryDefaultFaceletResolver.java new file mode 100644 index 000000000..7bf66fe0e --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/VeryTemporaryDefaultFaceletResolver.java @@ -0,0 +1,215 @@ +package org.eclipse.jst.jsf.facelet.core.internal.registry; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.core.resources.IProject; +import org.eclipse.jst.jsf.common.dom.TagIdentifier; +import org.eclipse.jst.jsf.common.runtime.internal.model.component.ComponentTypeInfo; +import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ConverterTypeInfo; +import org.eclipse.jst.jsf.common.runtime.internal.model.decorator.ValidatorTypeInfo; +import org.eclipse.jst.jsf.common.runtime.internal.model.types.TypeInfo; +import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.ITagElement; +import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.IHandlerTagElement.TagHandlerType; +import org.eclipse.jst.jsf.core.JSFVersion; +import org.eclipse.jst.jsf.core.internal.tld.TagIdentifierFactory; +import org.eclipse.jst.jsf.core.jsfappconfig.JSFAppConfigUtils; +import org.eclipse.jst.jsf.designtime.internal.view.mapping.ViewMetadataLoader; +import org.eclipse.jst.jsf.designtime.internal.view.model.jsp.AbstractTagResolvingStrategy; +import org.eclipse.jst.jsf.designtime.internal.view.model.jsp.DefaultTagTypeInfo; +import org.eclipse.jst.jsf.facelet.core.internal.cm.FaceletDocumentFactory; +import org.eclipse.jst.jsf.facelet.core.internal.registry.IFaceletTagResolvingStrategy.TLDWrapper; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.ComponentTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.ConverterTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.HandlerTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.IFaceletTagConstants; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.NoArchetypeFaceletTag; +import org.eclipse.jst.jsf.facelet.core.internal.tagmodel.ValidatorTag; +import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion; + +/** + * Temporary hard-coded tag resolver (to be replaced by meta-data) + * @author cbateman + * + */ +public class VeryTemporaryDefaultFaceletResolver extends + AbstractTagResolvingStrategy<TLDWrapper, String> implements IFaceletTagResolvingStrategy +{ + /** + * Tag resolver unique identifier + */ + public final static String ID = "org.eclipse.jst.jsf.facelet.core.VeryTemporaryDefaultFaceletResolver"; //$NON-NLS-1$ + private final DefaultTagTypeInfo _coreHtmlTypeInfo; + private final IProject _project; + private final FaceletDocumentFactory _factory; + private final ViewMetadataLoader _viewLoader; + + /** + * @param project + * @param factory + */ + public VeryTemporaryDefaultFaceletResolver(final IProject project, final FaceletDocumentFactory factory) + { + super(); + _factory = factory; + _project = project; + _coreHtmlTypeInfo = new DefaultTagTypeInfo(); + _viewLoader = new ViewMetadataLoader(project); + } + + @Override + public final String getId() + { + return ID; + } + + @Override + public ITagElement resolve(final TLDWrapper element) + { + final IProjectFacetVersion version = JSFAppConfigUtils + .getProjectFacet(_project); + final String versionAsString = version.getVersionString(); + final JSFVersion jsfVersion = JSFVersion.valueOfString(versionAsString); + + final String uri = element.getUri(); + final String name = element.getTagDefn().getName(); + final TagIdentifier tagId = TagIdentifierFactory.createJSPTagWrapper( + uri, name); + TypeInfo typeInfo = null; + if (IFaceletTagConstants.URI_JSF_FACELETS.equals(element.getUri())) + { + typeInfo = getTypeInfo(tagId, jsfVersion); + } + else + { + typeInfo = _coreHtmlTypeInfo.getTypeInfo(tagId, + jsfVersion); + } + return createFromTypeInfo(tagId, typeInfo); + } + + private ITagElement createFromTypeInfo(final TagIdentifier tagId, + final TypeInfo typeInfo) + { + final MetadataAttributeAdvisor advisor = + new MetadataAttributeAdvisor(tagId, _viewLoader); + if (typeInfo instanceof ComponentTypeInfo) + { + return new ComponentTag(tagId.getUri(), tagId.getTagName(), + (ComponentTypeInfo) typeInfo, null, _factory, advisor); + } + else if (typeInfo instanceof ConverterTypeInfo) + { + return new ConverterTag(tagId.getUri(), tagId.getTagName(), + (ConverterTypeInfo) typeInfo, null, _factory, advisor); + } + else if (typeInfo instanceof ValidatorTypeInfo) + { + return new ValidatorTag(tagId.getUri(), tagId.getTagName(), + (ValidatorTypeInfo) typeInfo, null, _factory, advisor); + } + else if (typeInfo instanceof TagHandlerType) + { + return new HandlerTag(tagId.getUri(), tagId.getTagName(), + (TagHandlerType) typeInfo, null, _factory, advisor); + } + else if (DefaultTagTypeInfo.isDefaultLib(tagId.getUri())) + { + return new NoArchetypeFaceletTag(tagId.getUri(), tagId.getTagName(), _factory, advisor); + } + + // not found + return null; + + } + + public final String getDisplayName() + { + return "Meta-data Driven Tag Resolver"; //$NON-NLS-1$ + } + + private static final ComponentTypeInfo COMPINFO_COMPONENT = new ComponentTypeInfo( + "facelets.ui.ComponentRef", //$NON-NLS-1$ + "com.sun.facelets.tag.ui.ComponentRef", //$NON-NLS-1$ + new String[] + { + "javax.faces.component.UIComponentBase", //$NON-NLS-1$ + "javax.faces.component.UIComponent", "java.lang.Object", }, //$NON-NLS-1$ //$NON-NLS-2$ + new String[] + { "javax.faces.component.StateHolder" }, //$NON-NLS-1$ + "facelets", //$NON-NLS-1$ + null); + + private static final ComponentTypeInfo COMPINFO_DEBUG = new ComponentTypeInfo( + "facelets.ui.Debug", //$NON-NLS-1$ + "com.sun.facelets.tag.ui.UIDebug", //$NON-NLS-1$ + new String[] + { + "javax.faces.component.UIComponentBase", //$NON-NLS-1$ + "javax.faces.component.UIComponent", "java.lang.Object", }, //$NON-NLS-1$ //$NON-NLS-2$ + new String[] + { "javax.faces.component.StateHolder" }, //$NON-NLS-1$ + "facelets", //$NON-NLS-1$ + null); + + private static final ComponentTypeInfo COMPINFO_REPEAT = new ComponentTypeInfo( + "facelets.ui.Repeat", //$NON-NLS-1$ + "com.sun.facelets.component.UIRepeat", //$NON-NLS-1$ + new String[] + { + "javax.faces.component.UIComponentBase", //$NON-NLS-1$ + "javax.faces.component.UIComponent", "java.lang.Object", }, //$NON-NLS-1$ //$NON-NLS-2$ + new String[] + { + "javax.faces.component.StateHolder", //$NON-NLS-1$ + "javax.faces.component.NamingContainer" }, //$NON-NLS-1$ + "facelets", //$NON-NLS-1$ + null); + + /** + * @param tagId + * @param jsfVersion + * @return a type info for the tag id in jsf version or null if none. + */ + private TypeInfo getTypeInfo(final TagIdentifier tagId, + final JSFVersion jsfVersion) + { + + switch (jsfVersion) + { + case V1_0: + case V1_1: + return JSF11_ELEMENTS.get(tagId); + + case V1_2: + return JSF12_ELEMENTS.get(tagId); + + default: + return null; + } + } + private static Map<TagIdentifier, TypeInfo> JSF11_ELEMENTS; + private static Map<TagIdentifier, TypeInfo> JSF12_ELEMENTS; + static + { + final Map<TagIdentifier, TypeInfo> elements = new HashMap<TagIdentifier, TypeInfo>(); + + elements.put(IFaceletTagConstants.TAG_IDENTIFIER_COMPONENT, + COMPINFO_COMPONENT); + + elements.put(IFaceletTagConstants.TAG_IDENTIFIER_DEBUG, + COMPINFO_DEBUG); + + elements.put(IFaceletTagConstants.TAG_IDENTIFIER_FRAGMENT, + COMPINFO_COMPONENT); + + elements.put(IFaceletTagConstants.TAG_IDENTIFIER_REPEAT, + COMPINFO_REPEAT); + + JSF11_ELEMENTS = Collections.unmodifiableMap(elements); + + JSF12_ELEMENTS = Collections + .unmodifiableMap(new HashMap<TagIdentifier, TypeInfo>(elements)); + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/messages.properties b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/messages.properties new file mode 100644 index 000000000..dd82d8168 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/messages.properties @@ -0,0 +1,3 @@ +FaceletRegistryManager_REGISTRY_FACTORY_DISPLAYNAME=Facelet Registry Factory +FaceletTagRegistry_TAG_REGISTRY_REFRESH_JOB_DESCRIPTION=Refreshing Facelet tag registry for +FaceletTagResolvingStrategy_FACELET_TAG_RESOLVER_DISPLAY_NAME=Facelet Introspecting Tag Resolver diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/AbstractFaceletTaglibLocator.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/AbstractFaceletTaglibLocator.java new file mode 100644 index 000000000..3b63d2ec0 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/AbstractFaceletTaglibLocator.java @@ -0,0 +1,84 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.util.Map; + +import org.eclipse.core.resources.IProject; +import org.eclipse.jst.jsf.common.internal.locator.AbstractLocator; +import org.eclipse.jst.jsf.common.internal.locator.ILocatorChangeListener; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.Listener.TaglibChangedEvent; + +/** + * Parent of all locators of facelet taglibs. + * + * @author cbateman + * + */ +public abstract class AbstractFaceletTaglibLocator + extends + AbstractLocator<Map<String, ? extends IFaceletTagRecord>, IProject, String> + implements IFaceletTaglibLocator +{ + /** + * @param id + * @param displayName + */ + public AbstractFaceletTaglibLocator(final String id, + final String displayName) + { + super(id, displayName); + // new MapMergingCompositionStrategy + // <IProject, Map<String, IFaceletTagRecord>, Map<String, + // IFaceletTagRecord>, + // ILocator<Map<String, IFaceletTagRecord>, IProject, String>> + // (new HashMap<String, IFaceletTagRecord>(), Collections.EMPTY_MAP) + } + + /** + * @return a list of all tag libraries known to this locator + */ + @Override + protected abstract Map<String, ? extends IFaceletTagRecord> doLocate( + IProject context); + + /** + * Listener argument must be of type Listener. + * + * @see org.eclipse.jst.jsf.common.internal.locator.AbstractLocator#addListener(org.eclipse.jst.jsf.common.internal.locator.ILocatorChangeListener) + */ + @Override + public void addListener(final ILocatorChangeListener listener) + { + if (!(listener instanceof Listener)) + { + throw new IllegalArgumentException(); + } + super.addListener(listener); + } + + /** + * @param listener + */ + public void addListener(final Listener listener) + { + super.addListener(listener); + } + + /** + * @param taglibChangedEvent + */ + protected void fireChangeEvent(final TaglibChangedEvent taglibChangedEvent) + { + super.fireChangeEvent(taglibChangedEvent); + } + +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/ContextParamSpecifiedFaceletTaglibLocator.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/ContextParamSpecifiedFaceletTaglibLocator.java new file mode 100644 index 000000000..5d13e4330 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/ContextParamSpecifiedFaceletTaglibLocator.java @@ -0,0 +1,430 @@ +/******************************************************************************* + * Copyright (c) 2005, 2007 Oracle Corporation. + * 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: + * Ian Trimble - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.io.IOException; +import java.io.InputStream; +import java.util.Collection; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.atomic.AtomicLong; + +import javax.xml.parsers.ParserConfigurationException; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IResourceChangeEvent; +import org.eclipse.core.resources.IResourceChangeListener; +import org.eclipse.core.resources.IResourceDelta; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.jst.jsf.common.internal.managedobject.AbstractManagedObject; +import org.eclipse.jst.jsf.common.internal.managedobject.ObjectManager.ManagedObjectException; +import org.eclipse.jst.jsf.common.internal.resource.IResourceLifecycleListener; +import org.eclipse.jst.jsf.common.internal.resource.ResourceLifecycleEvent; +import org.eclipse.jst.jsf.common.internal.resource.ResourceSingletonObjectManager; +import org.eclipse.jst.jsf.common.internal.resource.ResourceLifecycleEvent.EventType; +import org.eclipse.jst.jsf.facelet.core.internal.FaceletCorePlugin; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.Listener.TaglibChangedEvent; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.Listener.TaglibChangedEvent.CHANGE_TYPE; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.WebappConfiguration.WebappListener; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibDefn; +import org.xml.sax.SAXException; + +/** + * Attempts to locate Facelet taglib's specified as xml files in project + * relative paths specified in the Facelet.LIBRARIES servlet parameters. + * + * @author Based on class in org.eclipse.jst.jsf.coreby Ian Trimble - Oracle + * + * TODO:merge back with common code in JSFAppConfig framework + */ +/* package */class ContextParamSpecifiedFaceletTaglibLocator extends + AbstractFaceletTaglibLocator +{ + private static final String ID = ContextParamSpecifiedFaceletTaglibLocator.class.getCanonicalName(); + private static final String DISPLAYNAME = Messages.ContextParamSpecifiedFaceletTaglibLocator_0; + private final IProject _project; + private final Map<String, IFaceletTagRecord> _records; + private final TagRecordFactory _factory; + private final TaglibFileManager _fileManager; + + public ContextParamSpecifiedFaceletTaglibLocator(final IProject project, + final TagRecordFactory factory) + { + super(ID, DISPLAYNAME); + _project = project; + _records = new HashMap<String, IFaceletTagRecord>(); + _factory = factory; + _fileManager = new TaglibFileManager(project, + new LibraryChangeHandler()); + } + + /* + * (non-Javadoc) + * + * @seeorg.eclipse.jst.jsf.core.jsfappconfig.AbstractJSFAppConfigLocater# + * startLocating() + */ + @Override + public void start(final IProject project) + { + _fileManager.initFiles(); + super.start(project); + } + + /* + * (non-Javadoc) + * + * @seeorg.eclipse.jst.jsf.core.jsfappconfig.AbstractJSFAppConfigLocater# + * stopLocating() + */ + @Override + public void stop() + { + _fileManager.dispose(); + } + + + @Override + protected Map<String, ? extends IFaceletTagRecord> doLocate(IProject context) + { + return findInWebRoot(); + } + + private Map<String, ? extends IFaceletTagRecord> findInWebRoot() + { + final List<IFile> files = _fileManager.getFiles(); + + _records.clear(); + + for (final IFile file : files) + { + if (file.exists()) + { + TaglibFileTracker tracker = null; + try + { + tracker = _fileManager.getInstance(file); + } + catch (final ManagedObjectException e) + { + FaceletCorePlugin.log("Creating record", e); //$NON-NLS-1$ + } + + final IFaceletTagRecord record = createTagRecord(file); + if (record != null) + { + _records.put(record.getURI(), record); + if (tracker != null) + { + tracker.setUri(record.getURI()); + } + } + } + } + + return _records; + } + + private IFaceletTagRecord createTagRecord(final IFile file) + { + InputStream is = null; + try + { + is = file.getContents(); + FaceletTaglibDefn taglib = TagModelParser.loadFromInputStream(is, null); + if (taglib != null) + { + return _factory.createRecords(taglib); + } + } + catch (final CoreException e) + { + FaceletCorePlugin + .log( + "Loading web root taglibs for project: " + _project.getName(), e); //$NON-NLS-1$ + } + catch (final IOException e) + { + FaceletCorePlugin + .log( + "Loading web root taglibs for project: " + _project.getName(), e); //$NON-NLS-1$ + } + catch (final ParserConfigurationException e) + { + FaceletCorePlugin + .log( + "Loading web root taglibs for project: " + _project.getName(), e); //$NON-NLS-1$ + } + catch (final SAXException e) + { + FaceletCorePlugin + .log( + "Loading web root taglibs for project: " + _project.getName(), e); //$NON-NLS-1$ + } + finally + { + if (is != null) + { + try + { + is.close(); + } + catch (final IOException e) + { + FaceletCorePlugin.log("Closing taglib.xml", e); //$NON-NLS-1$ + } + } + } + return null; + } + + private static class TaglibFileManager extends + ResourceSingletonObjectManager<TaglibFileTracker, IFile> + { + private final LibraryChangeHandler _handler; + private final WebappConfiguration _webAppConfiguration; + private final IResourceChangeListener _newFileListener; + + public TaglibFileManager(final IProject project, + final LibraryChangeHandler handler) + { + _handler = handler; + _webAppConfiguration = new WebappConfiguration(project); + // TODO: fold into LifecycleListener + _newFileListener = new IResourceChangeListener() + { + public void resourceChanged(final IResourceChangeEvent event) + { + // if the event is post change && has the same parent + // project + if (event.getType() == IResourceChangeEvent.POST_CHANGE + && event.getDelta().findMember( + project.getFullPath()) != null) + { + for (final IFile file : _webAppConfiguration.getFiles()) + { + final IResourceDelta delta = event.getDelta() + .findMember(file.getFullPath()); + + if (delta != null) + { + if (delta.getKind() == IResourceDelta.ADDED) + { + _handler.added(file); + } + } + } + } + } + }; + + ResourcesPlugin.getWorkspace().addResourceChangeListener( + _newFileListener); + } + + public List<IFile> getFiles() + { + return _webAppConfiguration.getFiles(); + } + + public void initFiles() + { + _webAppConfiguration.start(); + _webAppConfiguration.addListener(new WebappListener() + { + @Override + public void webappChanged(WebappChangeEvent event) + { + for (final IFile file : event.getRemoved()) + { + TaglibFileTracker tracker; + try + { + tracker = getInstance(file); + _handler.removed(tracker._uri, file); + } + catch (ManagedObjectException e) + { + FaceletCorePlugin.log("While removing for webapp change", e); //$NON-NLS-1$ + } + } + + for (final IFile file : event.getAdded()) + { + _handler.added(file); + } + } + }); + } + + @Override + protected TaglibFileTracker createNewInstance(final IFile file) + { + return new TaglibFileTracker(file, this, _handler); + } + + public void addListener(final IResourceLifecycleListener listener) + { + super.addLifecycleEventListener(listener); + } + + public void removeListener(final IResourceLifecycleListener listener) + { + super.removeLifecycleEventListener(listener); + } + + public void dispose() + { + ResourcesPlugin.getWorkspace().removeResourceChangeListener( + _newFileListener); + + final Collection<IFile> managedResources = getManagedResources(); + + for (final IFile file : managedResources) + { + unmanageResource(file); + } + + _webAppConfiguration.dispose(); + } + } + + private static class TaglibFileTracker extends AbstractManagedObject + implements IResourceLifecycleListener + { + private final IFile _file; + private String _uri; + private final AtomicLong _lastModifiedStamp = new AtomicLong(); + private TaglibFileManager _manager; + private final LibraryChangeHandler _handler; + + public TaglibFileTracker(final IFile file, + final TaglibFileManager manager, + final LibraryChangeHandler handler) + { + _manager = manager; + _manager.addListener(this); + _file = file; + _lastModifiedStamp.set(file.getModificationStamp()); + _handler = handler; + } + + public final void setUri(final String uri) + { + _uri = uri; + } + + @Override + public void checkpoint() + { + // nothing currently persisted + + } + + @Override + public void destroy() + { + // nothing currently persisted + } + + @Override + public void dispose() + { + _manager.removeListener(this); + _manager = null; + } + + public EventResult acceptEvent(final ResourceLifecycleEvent event) + { + if (!_file.equals(event.getAffectedResource())) + { + return EventResult.getDefaultEventResult(); + } + + final EventType eventType = event.getEventType(); + + switch (eventType) + { + case RESOURCE_ADDED: + // added resources kick an add event. + _handler.added(_file); + break; + case RESOURCE_CHANGED: + // changed resources kick a change event + _handler.changed(_uri, _file); + break; + case RESOURCE_INACCESSIBLE: + // removed resources kick a remove event + _handler.removed(_uri, _file); + break; + } + + return EventResult.getDefaultEventResult(); + } + + } + + private class LibraryChangeHandler + { + public void added(final IFile file) + { + final IFaceletTagRecord tagRecord = createTagRecord(file); + TaglibFileTracker tracker = null; + try + { + tracker = _fileManager + .getInstance(file); + } + catch (final ManagedObjectException e) + { + FaceletCorePlugin.log("Adding new library", e); //$NON-NLS-1$ + } + + if (tagRecord != null) + { + + _records.put(tagRecord.getURI(), tagRecord); + if (tracker != null) + { + tracker.setUri(tagRecord.getURI()); + } + + fireChangeEvent(new TaglibChangedEvent( + ContextParamSpecifiedFaceletTaglibLocator.this, null, + tagRecord, CHANGE_TYPE.ADDED)); + } + } + + public void removed(final String uri, final IFile file) + { + final IFaceletTagRecord tagRecord = _records.remove(uri); + fireChangeEvent(new TaglibChangedEvent( + ContextParamSpecifiedFaceletTaglibLocator.this, tagRecord, + null, CHANGE_TYPE.REMOVED)); + } + + public void changed(final String uri, final IFile file) + { + final IFaceletTagRecord oldValue = _records.remove(uri); + final IFaceletTagRecord newValue = createTagRecord(file); + if (newValue != null) + { + _records.put(uri, newValue); + fireChangeEvent(new TaglibChangedEvent( + ContextParamSpecifiedFaceletTaglibLocator.this, + oldValue, newValue, CHANGE_TYPE.CHANGED)); + } + } + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/FaceletTagIndex.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/FaceletTagIndex.java new file mode 100644 index 000000000..fb1b457aa --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/FaceletTagIndex.java @@ -0,0 +1,46 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import org.eclipse.core.resources.IProject; +import org.eclipse.jst.jsf.common.internal.resource.ResourceSingletonObjectManager; + +/** + * @author cbateman + * + */ +public class FaceletTagIndex extends ResourceSingletonObjectManager<IProjectTaglibDescriptor, IProject> +{ + private final static FaceletTagIndex INSTANCE = new FaceletTagIndex(); + + /** + * @return the singleton instance + */ + public static FaceletTagIndex getInstance() + { + return INSTANCE; + } + + @Override + protected IProjectTaglibDescriptor createNewInstance(IProject project) + { + return new ProjectTaglibDescriptor(project); + } + + /** + * Force a project to refresh its tag index info + * @param project + */ + public void flush(final IProject project) + { + unmanageResource(project); + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/FaceletTagRecord.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/FaceletTagRecord.java new file mode 100644 index 000000000..26761c26d --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/FaceletTagRecord.java @@ -0,0 +1,55 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.util.Collection; +import java.util.concurrent.CopyOnWriteArrayList; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn; + +abstract class FaceletTagRecord implements IFaceletTagRecord +{ + private final CopyOnWriteArrayList<ITagRecordChangeListener> _listeners; + + public FaceletTagRecord() + { + _listeners = new CopyOnWriteArrayList<ITagRecordChangeListener>(); + } + + public final void addListener(final ITagRecordChangeListener listener) + { + _listeners.addIfAbsent(listener); + } + + public final void removeListener(final ITagRecordChangeListener listener) + { + _listeners.remove(listener); + } + + protected void fireEvent(final TagRecordChangeEvent event) + { + for (final ITagRecordChangeListener listener : _listeners) + { + listener.changed(event); + } + } + + /** + * + */ + private static final long serialVersionUID = -4606745577562951499L; + + public abstract String getURI(); + + public abstract TagDefn getTag(final String name); + + public abstract Collection<? extends TagDefn> getTags(); +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/IFaceletTagRecord.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/IFaceletTagRecord.java new file mode 100644 index 000000000..56f501736 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/IFaceletTagRecord.java @@ -0,0 +1,85 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.io.Serializable; +import java.util.Collection; +import java.util.EventObject; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn; + +/** + * @author cbateman + * + */ +public interface IFaceletTagRecord extends Serializable +{ + /** + * @return the uri of the tag library + */ + String getURI(); + + /** + * This may be implemented differently than getTags().size(), since getting + * all tags may be very expensive, while the overall number may be cheap. + * + * However, it should always be true that getTags().size() == getNumTags() + * + * @return the number of tags in this record. + */ + int getNumTags(); + + /** + * @return the tag definitions + */ + Collection<? extends TagDefn> getTags(); + + /** + * @param name + * @return the tag definition for name or null. + */ + TagDefn getTag(final String name); + + /** + * @param listener + */ + void addListener(final ITagRecordChangeListener listener); + + /** + * @param listener + */ + void removeListener(final ITagRecordChangeListener listener); + + /** + * Indicates that a tag record has changed + */ + static class TagRecordChangeEvent extends EventObject + { + /** + * + */ + private static final long serialVersionUID = 5655356157624922019L; + + TagRecordChangeEvent(IFaceletTagRecord source) + { + super(source); + } + } + + /** + * A listener for tag record change events. + * + */ + interface ITagRecordChangeListener + { + public void changed(final TagRecordChangeEvent event); + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/IFaceletTaglibLocator.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/IFaceletTaglibLocator.java new file mode 100644 index 000000000..23c8d3db2 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/IFaceletTaglibLocator.java @@ -0,0 +1,18 @@ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.util.Map; + +import org.eclipse.core.resources.IProject; +import org.eclipse.jst.jsf.common.internal.locator.ILocator; + +/** + * A locator that returns a name-keyed map of facelet tag records for a particular + * project. + * + * @author cbateman + * + */ +public interface IFaceletTaglibLocator extends ILocator<Map<String, ? extends IFaceletTagRecord>, IProject, String> +{ + // do nothing +}
\ No newline at end of file diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/IProjectTaglibDescriptor.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/IProjectTaglibDescriptor.java new file mode 100644 index 000000000..effe16c7f --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/IProjectTaglibDescriptor.java @@ -0,0 +1,45 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.util.Collection; + +import org.eclipse.jst.jsf.common.internal.managedobject.IManagedObject; + +/** + * A descriptor for all facelet taglibs in a project. + * + * @author cbateman + * + */ +public interface IProjectTaglibDescriptor extends IManagedObject +{ + /** + * @return get the tag library records + */ + public Collection<? extends IFaceletTagRecord> getTagLibraries(); + + /** + * @param uri + * @return get the tag library for uri + */ + public IFaceletTagRecord getTagLibrary(final String uri); + + /** + * @param listener + */ + public void addListener(final Listener listener); + + /** + * @param listener + */ + public void removeListener(final Listener listener); +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/JarFileFaceletTaglibLocator.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/JarFileFaceletTaglibLocator.java new file mode 100644 index 000000000..e33d71472 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/JarFileFaceletTaglibLocator.java @@ -0,0 +1,284 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.jar.JarEntry; +import java.util.jar.JarFile; +import java.util.regex.Pattern; + +import javax.xml.parsers.ParserConfigurationException; + +import org.eclipse.core.resources.IProject; +import org.eclipse.core.resources.IWorkspaceRoot; +import org.eclipse.core.resources.ResourcesPlugin; +import org.eclipse.core.runtime.IPath; +import org.eclipse.jdt.core.IClasspathEntry; +import org.eclipse.jdt.core.IJavaProject; +import org.eclipse.jdt.core.JavaCore; +import org.eclipse.jdt.core.JavaModelException; +import org.eclipse.jst.jsf.common.internal.strategy.SimpleStrategyComposite; +import org.eclipse.jst.jsf.facelet.core.internal.FaceletCorePlugin; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibDefn; +import org.xml.sax.SAXException; + +/** + * A locator that finds Facelet taglibs in jars on the classpath + * + * @author cbateman + * + */ +public class JarFileFaceletTaglibLocator extends AbstractFaceletTaglibLocator +{ + /** + * Default taglib finder that looks in meta-inf + */ + public static final TaglibJarEntryFinder _taglibMetaInfFinder = new TaglibJarEntryFinder( + Pattern.compile("META-INF/.*\\.taglib\\.xml")); //$NON-NLS-1$ + /** + * Default finder that looks in the glassfish package. + */ + public static final TaglibJarEntryFinder _taglibGlassfishFinder = new TaglibJarEntryFinder( + Pattern.compile("com/sun/faces/metadata/taglib/.*\\.taglib\\.xml")); //$NON-NLS-1$ + + private static final String DISPLAYNAME = Messages.JarFileFaceletTaglibLocator_0; + private static final String ID = JarFileFaceletTaglibLocator.class + .getCanonicalName(); + private final TagRecordFactory _factory; + private Map<String, IFaceletTagRecord> _records; + private final SimpleStrategyComposite<JarEntry, JarEntry, JarEntry, String, TaglibFinder<JarEntry, JarEntry>> _finder; + + /** + * @param factory + */ + public JarFileFaceletTaglibLocator(final TagRecordFactory factory) + { + super(ID, DISPLAYNAME); + _factory = factory; + _records = new HashMap<String, IFaceletTagRecord>(); + + List<TaglibFinder<JarEntry, JarEntry>> finders = new ArrayList<TaglibFinder<JarEntry, JarEntry>>(); + finders.add(_taglibMetaInfFinder); + finders.add(_taglibGlassfishFinder); + + _finder = new SimpleStrategyComposite<JarEntry, JarEntry, JarEntry, String, TaglibFinder<JarEntry, JarEntry>>( + finders); + + } + + @Override + public Map<String, ? extends IFaceletTagRecord> doLocate( + final IProject project) + { + try + { + return findInJars(project); + } catch (JavaModelException e) + { + FaceletCorePlugin + .log( + "Couldn't locate jar file taglibs: " + project.getProject(), e); //$NON-NLS-1$ + } + return Collections.EMPTY_MAP; + } + + private Map<String, ? extends IFaceletTagRecord> findInJars( + final IProject project) throws JavaModelException + { + final IJavaProject javaProject = JavaCore.create(project); + + final IClasspathEntry[] entries = javaProject + .getResolvedClasspath(true); + + final List<FaceletTaglibDefn> tagLibsFound = new ArrayList<FaceletTaglibDefn>(); + + for (final IClasspathEntry entry : entries) + { + + switch (entry.getEntryKind()) + { + // this entry describes a source root in its project + case IClasspathEntry.CPE_SOURCE: + + break; + // - this entry describes a folder or JAR containing + // binaries + case IClasspathEntry.CPE_LIBRARY: + { + tagLibsFound.addAll(processJar(entry)); + } + break; + // - this entry describes another project + case IClasspathEntry.CPE_PROJECT: + // { + // final IPath pathToProject = entry.getPath(); + // IWorkspace wkspace = ResourcesPlugin.getWorkspace(); + // IResource res = + // wkspace.getRoot().findMember(pathToProject); + // if (res instanceof IProject) + // { + // tagLibsFound.addAll(); + // } + // } + break; + // - this entry describes a project or library indirectly + // via a + // classpath variable in the first segment of the path * + case IClasspathEntry.CPE_VARIABLE: + break; + // - this entry describes set of entries referenced + // indirectly + // via a classpath container + case IClasspathEntry.CPE_CONTAINER: + break; + } + } + + for (final FaceletTaglibDefn tag : tagLibsFound) + { + IFaceletTagRecord record = _factory.createRecords(tag); + if (record != null) + { + _records.put(record.getURI(), record); + } + } + + return _records; + } + + /** + * TODO: Merge into JSFAppConfigUtils. + * + * @param entry + * @return + */ + private static JarFile getJarFileFromCPE(final IClasspathEntry entry) + throws IOException + { + if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) + { + IPath libraryPath = entry.getPath(); + if (libraryPath.getFileExtension() != null + && libraryPath.getFileExtension().length() > 0) + { + final IWorkspaceRoot workspaceRoot = ResourcesPlugin + .getWorkspace().getRoot(); + if (libraryPath.getDevice() == null + && workspaceRoot.getProject(libraryPath.segment(0)) + .exists()) + { + libraryPath = workspaceRoot.getFile(libraryPath) + .getLocation(); + } + final String libraryPathString = libraryPath.toString(); + return new JarFile(libraryPathString); + } + } + return null; + } + + /** + * @param entry + * @param defaultDtdStream + */ + private List<FaceletTaglibDefn> processJar(final IClasspathEntry entry) + { + JarFile jarFile = null; + final List<FaceletTaglibDefn> tagLibsFound = new ArrayList<FaceletTaglibDefn>(); + + try + { + jarFile = getJarFileFromCPE(entry); + + if (jarFile != null) + { + final Enumeration<JarEntry> jarEntries = jarFile.entries(); + while (jarEntries.hasMoreElements()) + { + JarEntry jarEntry = jarEntries.nextElement(); + + jarEntry = _finder.perform(jarEntry); + + if (jarEntry != null && jarEntry != _finder.getNoResult()) + { + // if ((name.startsWith("META-INF/") //$NON-NLS-1$ + // && name.endsWith(".taglib.xml")) //$NON-NLS-1$ + // || (name.startsWith("com/sun/faces/metadata/taglib/") //$NON-NLS-1$ //ludo GlassFish v3 + // && name.endsWith(".taglib.xml"))) //$NON-NLS-1$ + { + InputStream is = null; + try + { + is = jarFile.getInputStream(jarEntry); + + FaceletTaglibDefn tagLib = TagModelParser + .loadFromInputStream(is, null); + + if (tagLib != null) + { + tagLibsFound.add(tagLib); + } + } catch (final ParserConfigurationException e) + { + FaceletCorePlugin + .log( + "Error initializing facelet registry entry", //$NON-NLS-1$ + e); + } catch (final IOException ioe) + { + FaceletCorePlugin + .log( + "Error initializing facelet registry entry", //$NON-NLS-1$ + ioe); + } catch (final SAXException ioe) + { + FaceletCorePlugin + .log( + "Error initializing facelet registry entry", //$NON-NLS-1$ + ioe); + } finally + { + if (is != null) + { + // is.close(); + } + } + } + } + } + } + } catch (final IOException e) + { + FaceletCorePlugin.log( + "Error opening classpath jar file: " + entry, e); //$NON-NLS-1$ + } finally + { + if (jarFile != null) + { + try + { + jarFile.close(); + } catch (final IOException ioe) + { + FaceletCorePlugin.log("Error closing jar file", ioe); //$NON-NLS-1$ + } + } + } + return tagLibsFound; + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/LibraryClassBasedTagRecord.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/LibraryClassBasedTagRecord.java new file mode 100644 index 000000000..107828ca2 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/LibraryClassBasedTagRecord.java @@ -0,0 +1,546 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.atomic.AtomicBoolean; + +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Status; +import org.eclipse.jem.internal.proxy.core.IBeanProxy; +import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy; +import org.eclipse.jem.internal.proxy.core.IBooleanBeanProxy; +import org.eclipse.jem.internal.proxy.core.IFieldProxy; +import org.eclipse.jem.internal.proxy.core.IMethodProxy; +import org.eclipse.jem.internal.proxy.core.IStringBeanProxy; +import org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry; +import org.eclipse.jem.internal.proxy.core.ThrowableProxy; +import org.eclipse.jst.jsf.core.internal.JSFCorePlugin; +import org.eclipse.jst.jsf.core.internal.jem.BeanProxyUtil; +import org.eclipse.jst.jsf.core.internal.jem.BeanProxyUtil.BeanProxyWrapper; +import org.eclipse.jst.jsf.core.internal.jem.BeanProxyUtil.ProxyException; +import org.eclipse.jst.jsf.facelet.core.internal.FaceletCorePlugin; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibFactory; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn; + +/** + * @author cbateman + * + */ +/* package */class LibraryClassBasedTagRecord extends FaceletTagRecord +{ + private static final String METHOD_NAME_GET_VALUE = "getValue"; //$NON-NLS-1$ + private static final String METHOD_NAME_GET_KEY = "getKey"; //$NON-NLS-1$ + private static final String METHOD_NAME_HAS_NEXT = "hasNext"; //$NON-NLS-1$ + private static final String METHOD_NAME_NEXT = "next"; //$NON-NLS-1$ + private static final String METHOD_NAME_ITERATOR = "iterator"; //$NON-NLS-1$ + private static final String METHOD_NAME_ENTRY_SET = "entrySet"; //$NON-NLS-1$ + private static final String PROPERTY_NAME_FACTORIES = "factories"; //$NON-NLS-1$ + private static final String QUALIFIED_CLASS_NAME__COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY = "com.sun.facelets.tag.AbstractTagLibrary"; //$NON-NLS-1$ + private static final String QUALIFIED_CLASS_NAME_JAVA_UTIL_MAP = "java.util.Map"; //$NON-NLS-1$ + + private static final String COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_HANDLER_FACTORY = "com.sun.facelets.tag.AbstractTagLibrary$HandlerFactory"; //$NON-NLS-1$ + private static final String COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_USER_CONVERTER_HANDLER_FACTORY = "com.sun.facelets.tag.AbstractTagLibrary$UserConverterHandlerFactory"; //$NON-NLS-1$ + private static final String COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_CONVERTER_HANDLER_FACTORY = "com.sun.facelets.tag.AbstractTagLibrary$ConverterHandlerFactory"; //$NON-NLS-1$ + private static final String COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_USER_VALIDATOR_HANDLER_FACTORY = "com.sun.facelets.tag.AbstractTagLibrary$UserValidatorHandlerFactory"; //$NON-NLS-1$ + private static final String COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_VALIDATOR_HANDLER_FACTORY = "com.sun.facelets.tag.AbstractTagLibrary$ValidatorHandlerFactory"; //$NON-NLS-1$ + private static final String COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_USER_COMPONENT_HANDLER_FACTORY = "com.sun.facelets.tag.AbstractTagLibrary$UserComponentHandlerFactory"; //$NON-NLS-1$ + private static final String COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_COMPONENT_HANDLER_FACTORY = "com.sun.facelets.tag.AbstractTagLibrary$ComponentHandlerFactory"; //$NON-NLS-1$ + + private static final String FIELD_NAME_CONVERTER_ID = "converterId"; //$NON-NLS-1$ + private static final String FIELD_NAME_VALIDATOR_ID = "validatorId"; //$NON-NLS-1$ + private static final String FIELD_NAME_RENDER_TYPE = "renderType"; //$NON-NLS-1$ + private static final String FIELD_NAME_COMPONENT_TYPE = "componentType"; //$NON-NLS-1$ + + /** + * + */ + private static final long serialVersionUID = 4174629773250721041L; + private static final String STATIC_MEMBER_NAMESPACE = "Namespace"; //$NON-NLS-1$ + private static final String METHOD_NAME_GET_NAMESPACE = "getNamespace"; //$NON-NLS-1$ + + private final IProject _project; + private final FaceletLibraryClassTagLib _model; + private final ProxyFactoryRegistry _registry; + private final AtomicBoolean _isInitialized = new AtomicBoolean( + false); + + private String _uri; + private BeanProxyWrapper _classTypeWrapper; + private Map<String, TagDefn> _tags; + + /** + * @param registry + * @param model + * @param project + */ + public LibraryClassBasedTagRecord(final ProxyFactoryRegistry registry, + final FaceletLibraryClassTagLib model, final IProject project) + { + _registry = registry; + _model = model; + _project = project; + } + + public void initURI() throws CoreException + { + if (_isInitialized.get()) + { + throw new CoreException( + new Status( + IStatus.ERROR, + JSFCorePlugin.PLUGIN_ID, + "Cannot initURI once the library is initialized for: " + _model.getLibraryClass())); //$NON-NLS-1$ + } + + final IBeanTypeProxy libFactoryTypeProxy = _registry + .getBeanTypeProxyFactory().getBeanTypeProxy( + _model.getLibraryClass()); + + if (libFactoryTypeProxy == null) + { + throw new CoreException(new Status(IStatus.ERROR, + JSFCorePlugin.PLUGIN_ID, + "Couldn't find type proxy for " + _model.getLibraryClass())); //$NON-NLS-1$ + } + + // TODO: wrap in try per the Glassfish patch + _classTypeWrapper = new BeanProxyWrapper(_project, libFactoryTypeProxy); + + try + { + _classTypeWrapper.init(); + } + catch (final ProxyException e) + { + throw new CoreException(new Status(IStatus.ERROR, + JSFCorePlugin.PLUGIN_ID, + "Couldn't load class: " + _model.getLibraryClass(), e)); //$NON-NLS-1$ + } + + final String namespace = resolveNS(_classTypeWrapper); + System.out.println(namespace); + + if (namespace == null) + { + throw new CoreException(new Status(IStatus.ERROR, + JSFCorePlugin.PLUGIN_ID, + "Couldn't load uri: " + _model.getLibraryClass())); //$NON-NLS-1$ + + } + _uri = namespace; + } + + @Override + public synchronized TagDefn getTag(final String name) + { + initializeIfNecessary(); + return _tags.get(name); + } + + @Override + public synchronized Collection<? extends TagDefn> getTags() + { + initializeIfNecessary(); + return Collections.unmodifiableCollection(_tags.values()); + } + + private void initializeIfNecessary() + { + if (_isInitialized.compareAndSet(false, true)) + { + if (_tags == null) + { + _tags = resolveTags(); + } + } + } + + /* + * (non-Javadoc) + * + * @see + * org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.FaceletTagRecord + * #getURI() + */ + @Override + public String getURI() + { + return _uri; + } + + private Map<String, TagDefn> resolveTags() + { + final Map<String, TagDefn> tags = new HashMap<String, TagDefn>(); + + // if the tag factory is a child of AbstractTagFactory, then we + // can try to get our hands on its private parts ... + final IBeanTypeProxy mapTypeProxy = _registry.getBeanTypeProxyFactory() + .getBeanTypeProxy(QUALIFIED_CLASS_NAME_JAVA_UTIL_MAP); + final IBeanTypeProxy componentFactoryTypeProxy = _registry + .getBeanTypeProxyFactory() + .getBeanTypeProxy( + QUALIFIED_CLASS_NAME__COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY); + + if (mapTypeProxy != null && componentFactoryTypeProxy != null) + { + final IFieldProxy fieldProxy = componentFactoryTypeProxy + .getDeclaredFieldProxy(PROPERTY_NAME_FACTORIES); + + if (fieldProxy != null) + { + if (fieldProxy.getFieldType().isKindOf(mapTypeProxy)) + { + IBeanProxy factories = null; + + try + { + // need to turn off security checking on the private + // field + fieldProxy.setAccessible(true); + factories = fieldProxy.get(_classTypeWrapper + .getInstance()); + } + catch (final ThrowableProxy e) + { + FaceletCorePlugin.log( + "Error getting factories from bean instance", //$NON-NLS-1$ + e); + } + + if (factories != null) + { + final IMethodProxy entrySetMethod = fieldProxy + .getFieldType().getMethodProxy( + METHOD_NAME_ENTRY_SET); + if (entrySetMethod != null) + { + try + { + entrySetMethod.setAccessible(true); + final IBeanProxy entrySetProxy = entrySetMethod + .invoke(factories); + + if (entrySetProxy != null) + { + final IMethodProxy iteratorMethod = entrySetProxy + .getTypeProxy().getMethodProxy( + METHOD_NAME_ITERATOR); + iteratorMethod.setAccessible(true); + final IBeanProxy iteratorProxy = iteratorMethod + .invoke(entrySetProxy); + + if (iteratorProxy != null) + { + final IMethodProxy nextMethod = iteratorProxy + .getTypeProxy().getMethodProxy( + METHOD_NAME_NEXT); + nextMethod.setAccessible(true); + final IMethodProxy hasNextMethod = iteratorProxy + .getTypeProxy().getMethodProxy( + METHOD_NAME_HAS_NEXT); + hasNextMethod.setAccessible(true); + + while (((IBooleanBeanProxy) hasNextMethod + .invoke(iteratorProxy)) + .booleanValue()) + { + final IBeanProxy entryProxy = nextMethod + .invoke(iteratorProxy); + final IMethodProxy getKeyProxy = entryProxy + .getTypeProxy() + .getMethodProxy( + METHOD_NAME_GET_KEY); + final IMethodProxy getValueProxy = entryProxy + .getTypeProxy() + .getMethodProxy( + METHOD_NAME_GET_VALUE); + if (getKeyProxy != null + && getValueProxy != null) + { + getKeyProxy.setAccessible(true); + final IBeanProxy key = getKeyProxy + .invoke(entryProxy); + + if (key instanceof IStringBeanProxy) + { + final String name = ((IStringBeanProxy) key) + .stringValue(); + getValueProxy + .setAccessible(true); + final IBeanProxy value = getValueProxy + .invoke(entryProxy); + + if (value != null) + { + final TagDefn tagDefn = createTagDefn( + name, + value); + if (tagDefn != null) + { + tags.put(name, + tagDefn); + } + } + } + } + } + } + } + } + catch (final ThrowableProxy e) + { + FaceletCorePlugin.log( + "Error invoking entrySet", e); //$NON-NLS-1$ + } + } + } + + } + } + } + return tags; + } + + private TagDefn createTagDefn(final String name, + final IBeanProxy handlerValueProxy) + { + final IBeanTypeProxy handlerTypeProxy = handlerValueProxy.getTypeProxy(); + final FaceletTaglibFactory TAGDEFN_FACTORY = FaceletTaglibFactory.eINSTANCE; + + final IBeanTypeProxy componentHandlerFactory = _registry + .getBeanTypeProxyFactory() + .getBeanTypeProxy( + COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_COMPONENT_HANDLER_FACTORY); + final IBeanTypeProxy userComponentHandlerFactory = _registry + .getBeanTypeProxyFactory() + .getBeanTypeProxy( + COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_USER_COMPONENT_HANDLER_FACTORY); + final IBeanTypeProxy validatorHandlerFactory = _registry + .getBeanTypeProxyFactory() + .getBeanTypeProxy( + COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_VALIDATOR_HANDLER_FACTORY); + final IBeanTypeProxy userValidatorHandlerFactory = _registry + .getBeanTypeProxyFactory() + .getBeanTypeProxy( + COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_USER_VALIDATOR_HANDLER_FACTORY); + final IBeanTypeProxy converterHandlerFactory = _registry + .getBeanTypeProxyFactory() + .getBeanTypeProxy( + COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_CONVERTER_HANDLER_FACTORY); + final IBeanTypeProxy userConverterHandlerFactory = _registry + .getBeanTypeProxyFactory() + .getBeanTypeProxy( + COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_USER_CONVERTER_HANDLER_FACTORY); + final IBeanTypeProxy handlerFactory = _registry + .getBeanTypeProxyFactory() + .getBeanTypeProxy( + COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_HANDLER_FACTORY); + final IBeanTypeProxy userTagFactory = _registry + .getBeanTypeProxyFactory() + .getBeanTypeProxy( + COM_SUN_FACELETS_TAG_ABSTRACT_TAG_LIBRARY$_HANDLER_FACTORY); + + TagDefn tagDefn = null; + + if (handlerTypeProxy.isKindOf(componentHandlerFactory) + || handlerTypeProxy.isKindOf(userComponentHandlerFactory)) + { + final IFieldProxy componentTypeProxy = handlerTypeProxy + .getDeclaredFieldProxy(FIELD_NAME_COMPONENT_TYPE); + final IFieldProxy rendererTypeProxy = handlerTypeProxy + .getDeclaredFieldProxy(FIELD_NAME_RENDER_TYPE); + try + { + if (componentTypeProxy != null) + { + componentTypeProxy.setAccessible(true); + rendererTypeProxy.setAccessible(true); + final IBeanProxy componentType = componentTypeProxy + .get(handlerValueProxy); + // final IBeanProxy rendererType = rendererTypeProxy + // .get(handlerValueProxy); + + // render type is optional, but must have component type + if (componentType instanceof IStringBeanProxy) + { + final String componentTypeValue = getMeaningfulString(((IStringBeanProxy) componentType) + .stringValue()); + + if (componentTypeValue != null) + { + final ComponentTagDefn compTagDefn = TAGDEFN_FACTORY + .createComponentTagDefn(); + compTagDefn.setComponentType(componentTypeValue); + // if (rendererType instanceof IStringBeanProxy) + // { + // compTagDefn + // .setRendererType(getMeaningfulString((( + // IStringBeanProxy) rendererType) + // .stringValue())); + // } + tagDefn = compTagDefn; + } + } + } + } + catch (final ThrowableProxy e) + { + FaceletCorePlugin.log("Error get component info", e); //$NON-NLS-1$ + } + } + else if (handlerTypeProxy.isKindOf(validatorHandlerFactory) + || handlerTypeProxy.isKindOf(userValidatorHandlerFactory)) + { + final IFieldProxy validatorIdProxy = handlerTypeProxy + .getDeclaredFieldProxy(FIELD_NAME_VALIDATOR_ID); + + try + { + if (validatorIdProxy != null) + { + validatorIdProxy.setAccessible(true); + final IBeanProxy validatorId = validatorIdProxy + .get(handlerValueProxy); + + final ValidatorTagDefn valTagDefn = TAGDEFN_FACTORY + .createValidatorTagDefn(); + tagDefn = valTagDefn; + + if (validatorId instanceof IStringBeanProxy) + { + final String validatorIdValue = getMeaningfulString(((IStringBeanProxy) validatorId) + .stringValue()); + + if (validatorIdValue != null) + { + valTagDefn.setValidatorId(validatorIdValue); + } + } + } + } + catch (final ThrowableProxy e) + { + FaceletCorePlugin.log("Error getting validator info", e); //$NON-NLS-1$ + } + } + else if (handlerTypeProxy.isKindOf(converterHandlerFactory) + || handlerTypeProxy.isKindOf(userConverterHandlerFactory)) + { + final IFieldProxy converterIdProxy = handlerTypeProxy + .getDeclaredFieldProxy(FIELD_NAME_CONVERTER_ID); + + try + { + if (converterIdProxy != null) + { + converterIdProxy.setAccessible(true); + final IBeanProxy converterId = converterIdProxy + .get(handlerValueProxy); + + final ConverterTagDefn converterTagDefn = TAGDEFN_FACTORY + .createConverterTagDefn(); + tagDefn = converterTagDefn; + + if (converterId instanceof IStringBeanProxy) + { + final String converterIdValue = getMeaningfulString(((IStringBeanProxy) converterId) + .stringValue()); + + if (converterIdValue != null) + { + converterTagDefn.setConverterId(converterIdValue); + } + } + } + } + catch (final ThrowableProxy e) + { + FaceletCorePlugin.log("Error getting validator info", e); //$NON-NLS-1$ + } + } + else if (handlerTypeProxy.isKindOf(handlerFactory) + || handlerTypeProxy.isKindOf(userTagFactory)) + { + tagDefn = TAGDEFN_FACTORY.createHandlerTagDefn(); + } + + if (tagDefn != null) + { + tagDefn.setName(name); + } + return tagDefn; + } + + private String getMeaningfulString(final String value) + { + if (value == null) + { + return null; + } + + String retValue = value.trim(); + + if ("".equals(retValue)) //$NON-NLS-1$ + { + retValue = null; + } + return retValue; + } + + private String resolveNS(final BeanProxyWrapper beanProxy) + { + IBeanProxy resultProxy = null; + try + { + resultProxy = beanProxy.call(METHOD_NAME_GET_NAMESPACE); + + if (resultProxy instanceof IStringBeanProxy) + { + return ((IStringBeanProxy) resultProxy).stringValue(); + } + } + catch (final BeanProxyUtil.ProxyException e) + { + // fall through + } + + return resolveNSAggressively(beanProxy); + } + + private String resolveNSAggressively(final BeanProxyWrapper beanProxy) + { + try + { + return beanProxy.getStringFieldValue(STATIC_MEMBER_NAMESPACE); + } + catch (final ProxyException e) + { + // fall through + } + return null; + } + + public synchronized int getNumTags() + { + initializeIfNecessary(); + return _tags.size(); + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/Listener.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/Listener.java new file mode 100644 index 000000000..07de09aef --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/Listener.java @@ -0,0 +1,112 @@ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import org.eclipse.jst.jsf.common.internal.locator.ILocatorChangeListener; + +/** + * A listener for locator detected tag library changes + * @author cbateman + * + */ +public abstract class Listener implements ILocatorChangeListener +{ + /** + * Indicates that a tag library has changed + * @author cbateman + * + */ + public static class TaglibChangedEvent extends LocatorChangeEvent + { + /** + * TODO: what happens if one locator has a namespace collision with + * another one? + */ + public enum CHANGE_TYPE + { + /** + * Indicates that the library is new + */ + ADDED, + + /** + * Indicates that the library was removed. + */ + REMOVED, + + /** + * Indicates that the library is not new, but it's content + * has changed + */ + CHANGED + } + + private final TaglibChangedEvent.CHANGE_TYPE _changeType; + private final IFaceletTagRecord _oldValue; + private final IFaceletTagRecord _newValue; + + /** + * @param source + * @param oldValue + * @param newValue + * @param changeType + */ + public TaglibChangedEvent( + final AbstractFaceletTaglibLocator source, + final IFaceletTagRecord oldValue, + final IFaceletTagRecord newValue, + TaglibChangedEvent.CHANGE_TYPE changeType) + { + super(source); + _changeType = changeType; + _oldValue = oldValue; + _newValue = newValue; + } + + /** + * + */ + private static final long serialVersionUID = -4060018031568577836L; + + @Override + public AbstractFaceletTaglibLocator getSource() + { + return (AbstractFaceletTaglibLocator) super.getSource(); + } + + /** + * @return the type of the change + */ + public final TaglibChangedEvent.CHANGE_TYPE getChangeType() + { + return _changeType; + } + + /** + * @return the old value. This is null if the event is ADDED + */ + public final IFaceletTagRecord getOldValue() + { + return _oldValue; + } + + /** + * @return the new value. This is null if the event is REMOVED + */ + public final IFaceletTagRecord getNewValue() + { + return _newValue; + } + } + + + public final void changed(final LocatorChangeEvent event) + { + changed((TaglibChangedEvent)event); + } + + + /** + * @param event + * + */ + public abstract void changed(Listener.TaglibChangedEvent event); +}
\ No newline at end of file diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/Messages.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/Messages.java new file mode 100644 index 000000000..0ebb73d4a --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/Messages.java @@ -0,0 +1,31 @@ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import org.eclipse.osgi.util.NLS; + +/** + * Package NLS manager. + * @author cbateman + * + */ +public class Messages extends NLS +{ + private static final String BUNDLE_NAME = "org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.messages"; //$NON-NLS-1$ + /** + * see messages.properties. + */ + public static String ContextParamSpecifiedFaceletTaglibLocator_0; + /** + * see messages.properties/ + */ + public static String JarFileFaceletTaglibLocator_0; + static + { + // initialize resource bundle + NLS.initializeMessages(BUNDLE_NAME, Messages.class); + } + + private Messages() + { + // no external instantiation. + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/ProjectTaglibDescriptor.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/ProjectTaglibDescriptor.java new file mode 100644 index 000000000..3f87846f3 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/ProjectTaglibDescriptor.java @@ -0,0 +1,191 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.atomic.AtomicInteger; + +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.core.runtime.ISafeRunnable; +import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.core.runtime.SafeRunner; +import org.eclipse.jem.internal.proxy.core.IConfigurationContributor; +import org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry; +import org.eclipse.jem.internal.proxy.ide.IDERegistration; +import org.eclipse.jst.jsf.core.JSFVersion; +import org.eclipse.jst.jsf.facelet.core.internal.FaceletCorePlugin; +import org.eclipse.jst.jsf.facelet.core.internal.registry.ELProxyContributor; +import org.eclipse.jst.jsf.facelet.core.internal.registry.ServletBeanProxyContributor; + +class ProjectTaglibDescriptor implements IProjectTaglibDescriptor +{ + + private ProxyFactoryRegistry _registry; + private final AtomicInteger _isInitialized = new AtomicInteger( + 0); + private final IProject _project; + private final List<AbstractFaceletTaglibLocator> _locators; + private final MyChangeListener _libChangeListener; + private final Map<String, IFaceletTagRecord> _tagRecords; + + public ProjectTaglibDescriptor(final IProject project) + { + _project = project; + _locators = new ArrayList<AbstractFaceletTaglibLocator>(); + _tagRecords = new HashMap<String, IFaceletTagRecord>(); + + try + { + _registry = createProxyRegistry(_project); + } + catch (final CoreException e) + { + FaceletCorePlugin.log("While creatinng proxy", e); //$NON-NLS-1$ + } + + final TagRecordFactory factory = new TagRecordFactory(project, + _registry); + _locators.add(new JarFileFaceletTaglibLocator(factory)); + _locators.add(new ContextParamSpecifiedFaceletTaglibLocator(_project, + factory)); + + _libChangeListener = new MyChangeListener(); + } + + private static ProxyFactoryRegistry createProxyRegistry( + final IProject project) throws CoreException + { + final IConfigurationContributor[] contributor = new IConfigurationContributor[] + { new ServletBeanProxyContributor(JSFVersion.V1_1), + new ELProxyContributor(project) }; + + return IDERegistration.startAnImplementation(contributor, false, + project, project.getName(), FaceletCorePlugin.PLUGIN_ID, + new NullProgressMonitor()); + } + + private void initialize() + { + if (_isInitialized.addAndGet(1) == 1) + { + synchronized (this) + { + + for (final AbstractFaceletTaglibLocator locator : _locators) + { + SafeRunner.run(new ISafeRunnable() + { + public void handleException(final Throwable exception) + { + FaceletCorePlugin + .log( + "While locating facelet libraries on project: " + _project.getName(), new Exception(exception)); //$NON-NLS-1$ + } + + public void run() throws Exception + { + locator.addListener(_libChangeListener); + locator.start(_project); + _tagRecords.putAll(locator.locate(_project)); + } + }); + } + } + } + } + + public Collection<? extends IFaceletTagRecord> getTagLibraries() + { + initialize(); + return Collections.unmodifiableCollection(_tagRecords.values()); + } + + void maybeLog(final Exception e) + { + if (_isInitialized.get() <= 1) + { + FaceletCorePlugin.log("Failed initializing taglib descriptor", e); //$NON-NLS-1$ + } + } + + public IFaceletTagRecord getTagLibrary(final String uri) + { + initialize(); + return _tagRecords.get(uri); + } + + public void addListener(final Listener listener) + { + for (final AbstractFaceletTaglibLocator locator : _locators) + { + locator.addListener(listener); + } + } + + public void removeListener(final Listener listener) + { + for (final AbstractFaceletTaglibLocator locator : _locators) + { + locator.removeListener(listener); + } + } + + public void checkpoint() + { + // TODO Auto-generated method stub + } + + public void destroy() + { + // TODO Auto-generated method stub + } + + public void dispose() + { + if (_registry != null) + { + _registry.terminateRegistry(false); + + for (final AbstractFaceletTaglibLocator locator : _locators) + { + locator.stop(); + } + } + } + + private class MyChangeListener extends Listener + { + @Override + public void changed(final TaglibChangedEvent event) + { + switch (event.getChangeType()) + { + case ADDED: + _tagRecords.put(event.getNewValue().getURI(), event + .getNewValue()); + break; + case CHANGED: + _tagRecords.put(event.getNewValue().getURI(), event + .getNewValue()); + break; + case REMOVED: + _tagRecords.remove(event.getOldValue()); + break; + } + } + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/TagModelParser.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/TagModelParser.java new file mode 100644 index 000000000..efb1ed0a3 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/TagModelParser.java @@ -0,0 +1,461 @@ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.parsers.ParserConfigurationException; + +import org.eclipse.jst.jsf.facelet.core.internal.FaceletCorePlugin; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibFactory; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.HandlerTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.SourceTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn; +import org.w3c.dom.Document; +import org.w3c.dom.Node; +import org.w3c.dom.NodeList; +import org.xml.sax.InputSource; +import org.xml.sax.SAXException; +import org.xml.sax.helpers.DefaultHandler; + +/** + * A Facelet tag library document parser (dtd 1.0). + * + * @author cbateman + * + */ +public class TagModelParser +{ + private static final String FACELET_TAGLIB_DTD_PATH = "/dtd/facelet-taglib_1_0.dtd"; //$NON-NLS-1$ + + + private static final String ELEMENT_NAME_VALIDATOR_ID = "validator-id"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_CONVERTER_ID = "converter-id"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_RENDERER_TYPE = "renderer-type"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_COMPONENT_TYPE = "component-type"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_VALIDATOR = "validator"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_CONVERTER = "converter"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_COMPONENT = "component"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_HANDLER_CLASS = "handler-class"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_SOURCE = "source"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_TAG_NAME = "tag-name"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_TAG = "tag"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_NAMESPACE = "namespace"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_LIBRARY_CLASS = "library-class"; //$NON-NLS-1$ + private static final String ELEMENT_NAME_FACELET_TAGLIB = "facelet-taglib"; //$NON-NLS-1$ + private static final String URI_FACELET_TAGLIB_1_0_DTD = "facelet-taglib_1_0.dtd"; //$NON-NLS-1$ + private static final String PUBLIC_DTD_FACELET_TAGLIB_1_0_DTD = "-//Sun Microsystems, Inc.//DTD Facelet Taglib 1.0//EN"; //$NON-NLS-1$ + + /** + * @param is + * @param dtdSourcePath + * @return the taglib definition or null + * @throws IOException + * @throws ParserConfigurationException + * @throws SAXException + */ + public static FaceletTaglibDefn loadFromInputStream(final InputStream is, final String dtdSourcePath) throws IOException, ParserConfigurationException, SAXException + { + final byte[] buffer = getBufferForEntry(is); + final InputStream dtdSource = getDefaultDTDSource(dtdSourcePath != null ? dtdSourcePath : FACELET_TAGLIB_DTD_PATH); + final FaceletTaglibDefn taglib = loadFromBuffer(buffer, dtdSource); + return taglib; + + } + /** + * @param buffer + * @param defaultDtdStream + * @return the tag library definition (loaded EMF model) for the buffer + * @throws IOException + * @throws ParserConfigurationException + * @throws SAXException + */ + public static FaceletTaglibDefn loadFromBuffer(final byte[] buffer, + final InputStream defaultDtdStream) throws IOException, + ParserConfigurationException, SAXException + { + final InputSource inputSource = new InputSource( + new ByteArrayInputStream(buffer)); + + final Document doc = TagModelParser.getDefaultTaglibDocument( + inputSource, new InputSource(defaultDtdStream)); + final FaceletTaglibDefn tagLib = TagModelParser.processDocument(doc); + return tagLib; + } + + /** + * @param path + * @return the input stream for the default bundle Facelet dtd. + * @throws IOException + */ + protected static InputStream getDefaultDTDSource(final String path) throws IOException + { + final URL url = FaceletCorePlugin.getDefault().getBundle().getEntry(path); + + if (url != null) + { + return url.openStream(); + } + return null; + } + + /** + * @param is must be open. Caller is responsible for closing. + * @return load the stream into a byte buffer. + */ + protected static byte[] getBufferForEntry(final InputStream is) + { + final ByteArrayOutputStream stream = new ByteArrayOutputStream(); + final byte[] buffer = new byte[2048]; + + int bytesRead = 0; + + try + { + while (((bytesRead = is.read(buffer))) != -1) + { + stream.write(buffer, 0, bytesRead); + } + } + catch (final IOException e) + { + FaceletCorePlugin.log("Error loading buffer", e); //$NON-NLS-1$ + return null; + } + + return stream.toByteArray(); + } + + /** + * @param taglibFile + * @param defaultDTDSource + * @return the default taglib dom Document + * @throws IOException + * @throws ParserConfigurationException + * @throws SAXException + */ + public static Document getDefaultTaglibDocument( + final InputSource taglibFile, final InputSource defaultDTDSource) + throws IOException, ParserConfigurationException, SAXException + { + final DocumentBuilderFactory factory = DocumentBuilderFactory + .newInstance(); + factory.setValidating(false); + factory.setIgnoringComments(true); + + final DocumentBuilder builder = factory.newDocumentBuilder(); + + final DefaultHandler handler = new DefaultHandler() + { + @Override + public InputSource resolveEntity(final String publicId, + final String systemId) throws IOException, SAXException + { + if (PUBLIC_DTD_FACELET_TAGLIB_1_0_DTD.equals(publicId) + || (systemId != null && systemId + .endsWith(URI_FACELET_TAGLIB_1_0_DTD))) + + { + return defaultDTDSource; + } + return super.resolveEntity(publicId, systemId); + } + }; + + builder.setEntityResolver(handler); + return builder.parse(taglibFile); + } + + /** + * @param doc + * @return the facelet tag library or null + */ + public static FaceletTaglibDefn processDocument(final Document doc) + { + Node curNode = null; + + for (int i = 0; i < doc.getChildNodes().getLength(); i++) + { + curNode = doc.getChildNodes().item(i); + + if (curNode.getNodeType() == Node.ELEMENT_NODE + && ELEMENT_NAME_FACELET_TAGLIB + .equals(curNode.getNodeName())) + { + break; + } + } + + if (curNode == null) + { + throw new IllegalArgumentException( + "Couldn't find facelet-taglib node"); //$NON-NLS-1$ + } + + for (int i = 0; i < curNode.getChildNodes().getLength(); i++) + { + final Node node = curNode.getChildNodes().item(i); + + if (node.getNodeType() == Node.ELEMENT_NODE) + { + if (ELEMENT_NAME_LIBRARY_CLASS.equals(node.getNodeName())) + { + final FaceletLibraryClassTagLib faceletLibraryClassTagLib = FaceletTaglibFactory.eINSTANCE + .createFaceletLibraryClassTagLib(); + faceletLibraryClassTagLib.setLibraryClass(node + .getTextContent().trim()); + return faceletLibraryClassTagLib; + } + return processFaceletTaglibWithTags(curNode); + } + } + + return null; + } + + private static FaceletXMLDefnTaglib processFaceletTaglibWithTags( + final Node node) + { + String namespace = null; + final List<Node> tagNodes = new ArrayList<Node>(); + + for (int i = 0; i < node.getChildNodes().getLength(); i++) + { + final Node childNode = node.getChildNodes().item(i); + + if (childNode.getNodeType() == Node.ELEMENT_NODE) + { + if (ELEMENT_NAME_NAMESPACE.equals(childNode.getNodeName())) + { + namespace = childNode.getTextContent(); + } + else if (ELEMENT_NAME_TAG.equals(childNode.getNodeName())) + { + tagNodes.add(childNode); + } + } + } + + if (namespace != null) + { + final FaceletXMLDefnTaglib xmlDefnTaglib = FaceletTaglibFactory.eINSTANCE + .createFaceletXMLDefnTaglib(); + xmlDefnTaglib.setNamespace(namespace); + + for (final Node tagNode : tagNodes) + { + final TagDefn tag = createTagFromNode(namespace, tagNode); + + if (tag != null) + { + xmlDefnTaglib.getTags().add(tag); + } + } + + return xmlDefnTaglib; + } + return null; + } + + private static TagDefn createTagFromNode(final String namespace, + final Node tagNode) + { + final Map<String, Node> children = indexChildren(tagNode); + + Node node = children.get(ELEMENT_NAME_TAG_NAME); + + if (node != null) + { + final String name = safeGetTextContext(node); + + if (name == null) + { + return null; + } + + node = children.get(ELEMENT_NAME_HANDLER_CLASS); + + if (node != null) + { + final HandlerTagDefn handlerTag = FaceletTaglibFactory.eINSTANCE + .createHandlerTagDefn(); + handlerTag.setHandlerClass(safeGetTextContext(node)); + handlerTag.setName(name); + return handlerTag; + } + + node = children.get(ELEMENT_NAME_SOURCE); + + if (node != null) + { + final SourceTagDefn sourceTag = FaceletTaglibFactory.eINSTANCE + .createSourceTagDefn(); + sourceTag.setSource(safeGetTextContext(node)); + sourceTag.setName(name); + return sourceTag; + } + + node = children.get(ELEMENT_NAME_COMPONENT); + + if (node != null) + { + return createTagWithComponentType(namespace, name, node); + } + + node = children.get(ELEMENT_NAME_CONVERTER); + + if (node != null) + { + return createTagWithConverter(namespace, name, node); + } + + node = children.get(ELEMENT_NAME_VALIDATOR); + + if (node != null) + { + return createValidatorTag(namespace, name, node); + } + } + + return null; + } + + private static ComponentTagDefn createTagWithComponentType( + final String uri, final String tagName, final Node paramNode) + { + final Map<String, Node> componentChildren = indexChildren(paramNode); + Node node = componentChildren.get(ELEMENT_NAME_COMPONENT_TYPE); + + if (node != null) + { + final String componentType = safeGetTextContext(node); + String rendererType = null; + String handlerClass = null; + + node = componentChildren.get(ELEMENT_NAME_RENDERER_TYPE); + if (node != null) + { + rendererType = safeGetTextContext(node); + } + + node = componentChildren.get(ELEMENT_NAME_HANDLER_CLASS); + if (node != null) + { + handlerClass = safeGetTextContext(node); + } + + final ComponentTagDefn componentTag = FaceletTaglibFactory.eINSTANCE + .createComponentTagDefn(); + componentTag.setName(tagName); + componentTag.setComponentType(componentType); + componentTag.setHandlerClass(handlerClass); + componentTag.setRendererType(rendererType); + return componentTag; + } + return null; + } + + private static ConverterTagDefn createTagWithConverter(final String uri, + final String tagName, final Node paramNode) + { + final Map<String, Node> converterChildren = indexChildren(paramNode); + Node node = converterChildren.get(ELEMENT_NAME_CONVERTER_ID); + + if (node != null) + { + final String converterId = safeGetTextContext(node); + String handlerClass = null; + + node = converterChildren.get(ELEMENT_NAME_HANDLER_CLASS); + if (node != null) + { + handlerClass = safeGetTextContext(node); + } + + final ConverterTagDefn converterTag = FaceletTaglibFactory.eINSTANCE + .createConverterTagDefn(); + converterTag.setName(tagName); + converterTag.setConverterId(converterId); + converterTag.setHandlerClass(handlerClass); + return converterTag; + } + return null; + } + + private static ValidatorTagDefn createValidatorTag(final String uri, + final String tagName, final Node paramNode) + { + final Map<String, Node> converterChildren = indexChildren(paramNode); + Node node = converterChildren.get(ELEMENT_NAME_VALIDATOR_ID); + + if (node != null) + { + final String validatorId = safeGetTextContext(node); + String handlerClass = null; + + node = converterChildren.get(ELEMENT_NAME_HANDLER_CLASS); + if (node != null) + { + handlerClass = safeGetTextContext(node); + } + + final ValidatorTagDefn validatorTag = FaceletTaglibFactory.eINSTANCE + .createValidatorTagDefn(); + validatorTag.setName(tagName); + validatorTag.setHandlerClass(handlerClass); + validatorTag.setValidatorId(validatorId); + return validatorTag; + } + return null; + } + + private static Map<String, Node> indexChildren(final Node node) + { + final Map<String, Node> children = new HashMap<String, Node>(); + final NodeList nodeList = node.getChildNodes(); + + for (int i = 0; i < nodeList.getLength(); i++) + { + final Node childNode = nodeList.item(i); + + if (childNode.getNodeType() == Node.ELEMENT_NODE) + { + children.put(childNode.getNodeName(), childNode); + } + } + + return children; + } + + private static String safeGetTextContext(final Node node) + { + String textContent = node.getTextContent(); + if (textContent == null) + { + return null; + } + + textContent = textContent.trim(); + + if ("".equals(textContent)) //$NON-NLS-1$ + { + return null; + } + + return textContent; + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/TagRecordFactory.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/TagRecordFactory.java new file mode 100644 index 000000000..a096f6236 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/TagRecordFactory.java @@ -0,0 +1,81 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.jem.internal.proxy.core.ICallbackRegistry; +import org.eclipse.jem.internal.proxy.core.ProxyFactoryRegistry; +import org.eclipse.jst.jsf.facelet.core.internal.FaceletCorePlugin; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib; + +/*package*/class TagRecordFactory +{ + private final ProxyFactoryRegistry _registry; + private final IProject _project; + + public TagRecordFactory(final IProject project, + final ProxyFactoryRegistry registry) + { + _registry = registry; + _project = project; + } + + public IFaceletTagRecord createRecords(final FaceletTaglibDefn taglibDefn) + { + IFaceletTagRecord retValue = null; + + if (taglibDefn instanceof FaceletLibraryClassTagLib) + { + if (_registry != NULL_REGISTRY) + { + final LibraryClassBasedTagRecord record = new LibraryClassBasedTagRecord( + _registry, (FaceletLibraryClassTagLib) taglibDefn, _project); + try + { + record.initURI(); + retValue = record; + } + catch (CoreException e) + { + FaceletCorePlugin.log("While creating record: "+record, e); //$NON-NLS-1$ + } + } + } + else if (taglibDefn instanceof FaceletXMLDefnTaglib) + { + final XMLBasedTagRecord record = new XMLBasedTagRecord( + (FaceletXMLDefnTaglib) taglibDefn); + retValue = record; + } + return retValue; + } + + private final static NullProxyFactoryRegistry NULL_REGISTRY = new NullProxyFactoryRegistry(); + + private static class NullProxyFactoryRegistry extends ProxyFactoryRegistry + { + + @Override + public ICallbackRegistry getCallbackRegistry() + { + throw new UnsupportedOperationException("This is null proxy"); //$NON-NLS-1$ + } + + @Override + protected void registryTerminated(final boolean wait) + { + throw new UnsupportedOperationException("This is null proxy"); //$NON-NLS-1$ + } + } +}
\ No newline at end of file diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/TaglibFinder.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/TaglibFinder.java new file mode 100644 index 000000000..492e83a03 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/TaglibFinder.java @@ -0,0 +1,28 @@ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import org.eclipse.jst.jsf.common.internal.strategy.AbstractIdentifiableStrategy; + + +/** + * A finder strategy for Facelet tag libraries. + * @author cbateman + * + * @param <INPUT> + * @param <OUTPUT> + */ +public abstract class TaglibFinder<INPUT, OUTPUT> extends AbstractIdentifiableStrategy<INPUT, OUTPUT, String> +{ + /** + * @param id + * @param displayName + * @param noResultValue + */ + public TaglibFinder(String id, String displayName, + OUTPUT noResultValue) + { + super(id, displayName, noResultValue); + } + + @Override + public abstract OUTPUT perform(INPUT input) throws Exception; +}
\ No newline at end of file diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/TaglibJarEntryFinder.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/TaglibJarEntryFinder.java new file mode 100644 index 000000000..17bb024ba --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/TaglibJarEntryFinder.java @@ -0,0 +1,38 @@ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.util.jar.JarEntry; +import java.util.regex.Pattern; + + +/** + * @author cbateman + * + */ +public class TaglibJarEntryFinder extends TaglibFinder<JarEntry, JarEntry> +{ + /** + * Unique id of this strategy. + */ + public static final String ID = TaglibJarEntryFinder.class.getCanonicalName(); + private static final String DISPLAY_NAME = "Display Name"; //$NON-NLS-1$ + private final Pattern _pattern; + + /** + * @param pattern + */ + public TaglibJarEntryFinder(final Pattern pattern) + { + super(ID, DISPLAY_NAME, null); + _pattern = pattern; + } + + @Override + public JarEntry perform(JarEntry input) throws Exception + { + if (_pattern.matcher(input.getName()).matches()) + { + return input; + } + return getNoResult(); + } +}
\ No newline at end of file diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/WebappConfiguration.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/WebappConfiguration.java new file mode 100644 index 000000000..e65ba9a4d --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/WebappConfiguration.java @@ -0,0 +1,696 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.StringTokenizer; +import java.util.concurrent.CopyOnWriteArrayList; + +import org.eclipse.core.resources.IFile; +import org.eclipse.core.resources.IProject; +import org.eclipse.core.runtime.IStatus; +import org.eclipse.core.runtime.Path; +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.impl.AdapterImpl; +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.jst.j2ee.common.ParamValue; +import org.eclipse.jst.j2ee.internal.J2EEVersionConstants; +import org.eclipse.jst.j2ee.model.IModelProvider; +import org.eclipse.jst.j2ee.model.ModelProviderManager; +import org.eclipse.jst.j2ee.web.componentcore.util.WebArtifactEdit; +import org.eclipse.jst.j2ee.webapplication.ContextParam; +import org.eclipse.jst.j2ee.webapplication.WebApp; +import org.eclipse.jst.jsf.core.internal.JSFCorePlugin; +import org.eclipse.jst.jsf.core.jsfappconfig.JSFAppConfigUtils; +import org.eclipse.jst.jsf.facelet.core.internal.FaceletCorePlugin; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.WebappConfiguration.WebappListener.WebappChangeEvent; +import org.eclipse.wst.common.componentcore.resources.IVirtualFile; +import org.eclipse.wst.common.componentcore.resources.IVirtualFolder; + +/** + * Manages the web.xml elements of interest to Facelet tag libraries + * + * @author cbateman + * + */ +public class WebappConfiguration +{ + // TODO: move these to jsf core. + private static final String FACELET_10_LIBRARIES_CONTEXT_PARAM_NAME = "facelets.LIBRARIES"; //$NON-NLS-1$ + private static final String JSF20_FACELET_LIBRARIES_CONTEXT_PARAM_NAME = "javax.faces.FACELETS_LIBRARIES"; //$NON-NLS-1$ + private final IProject _project; + /** + * Cached instance of ContextParamAdapter. + */ + private final ContextParamAdapter _contextParamAdapter; + private List<IFile> _cachedFiles; + + /** + * @param project + */ + /*package*/ WebappConfiguration(final IProject project) + { + _project = project; + _contextParamAdapter = new ContextParamAdapter(); + } + + /** + * @param listener + */ + public void addListener(final WebappListener listener) + { + _contextParamAdapter.addListener(listener); + } + + /** + * @param listener + */ + public void removeListener(final WebappListener listener) + { + _contextParamAdapter.removeListener(listener); + } + + /** + * @return the list of IFile's + */ + public List<IFile> getFiles() + { + final IVirtualFolder folder = JSFAppConfigUtils + .getWebContentFolder(_project); + + if (folder == null) + { + return Collections.emptyList(); + } + + final List<String> filenames = getConfigFilesFromContextParam(_project); + final List<IFile> files = new ArrayList<IFile>(); + + for (final String filename : filenames) + { + final IVirtualFile vfile = folder.getFile(new Path(filename)); + if (vfile != null) + { + files.add(vfile.getUnderlyingFile()); + } + } + _cachedFiles = files; + return Collections.unmodifiableList(files); + } + + private Object getModelObject() + { + final IModelProvider provider = ModelProviderManager + .getModelProvider(_project); + return provider.getModelObject(); + } + + /** + * + */ + public void start() + { + final Object webAppObj = getModelObject(); + if (webAppObj != null) + { + if (webAppObj instanceof WebApp) + { + startLocatingJ2EEConfigs((WebApp) webAppObj); + } + else if (webAppObj instanceof org.eclipse.jst.javaee.web.WebApp) + { + startLocatingJEEConfigs((org.eclipse.jst.javaee.web.WebApp) webAppObj); + } + } + else + { + FaceletCorePlugin + .log( + "Could not get webApp for project: " + _project, new Exception()); //$NON-NLS-1$ + } + } + + /** + * + */ + public void dispose() + { + if (_contextParamAdapter != null) + { + final Object webAppObj = getModelObject(); + if (webAppObj != null) + { + if (webAppObj instanceof WebApp) + { + stopLocatingJ2EEConfigs((WebApp) webAppObj); + } + else if (webAppObj instanceof org.eclipse.jst.javaee.web.WebApp) + { + stopLocatingJEEConfigs((org.eclipse.jst.javaee.web.WebApp) webAppObj); + } + } + else + { + FaceletCorePlugin + .log( + "Failed stopping locator for project: " + _project.getName() //$NON-NLS-1$ + , new Exception()); + } + //_contextParamAdapter.dispose(); + } + } + + private void startLocatingJ2EEConfigs(final WebApp webApp) + { + webApp.eAdapters().add(_contextParamAdapter); + final EList contexts = webApp.getContexts(); + if (contexts != null) + { + final Iterator itContexts = contexts.iterator(); + while (itContexts.hasNext()) + { + final ContextParam contextParam = (ContextParam) itContexts + .next(); + contextParam.eAdapters().add(_contextParamAdapter); + } + } + final EList contextParams = webApp.getContextParams(); + if (contextParams != null) + { + final Iterator itContextParams = contextParams.iterator(); + while (itContextParams.hasNext()) + { + final ParamValue paramValue = (ParamValue) itContextParams + .next(); + paramValue.eAdapters().add(_contextParamAdapter); + } + } + } + + private void startLocatingJEEConfigs( + final org.eclipse.jst.javaee.web.WebApp webApp) + { + ((EObject) webApp).eAdapters().add(_contextParamAdapter); + // System.out.println(((EObject)webApp).eDeliver()); + final List params = webApp.getContextParams(); + if (params != null) + { + final Iterator itContexts = params.iterator(); + while (itContexts.hasNext()) + { + final EObject contextParam = (EObject) itContexts.next(); + contextParam.eAdapters().add(_contextParamAdapter); + } + } + } + + private void stopLocatingJ2EEConfigs(final WebApp webApp) + { + webApp.eAdapters().remove(_contextParamAdapter); + final EList contexts = webApp.getContexts(); + if (contexts != null) + { + final Iterator itContexts = contexts.iterator(); + while (itContexts.hasNext()) + { + final ContextParam contextParam = (ContextParam) itContexts + .next(); + contextParam.eAdapters().remove(_contextParamAdapter); + } + } + final EList contextParams = webApp.getContextParams(); + if (contextParams != null) + { + final Iterator itContextParams = contextParams.iterator(); + while (itContextParams.hasNext()) + { + final ParamValue paramValue = (ParamValue) itContextParams + .next(); + paramValue.eAdapters().remove(_contextParamAdapter); + } + } + } + + private void stopLocatingJEEConfigs( + final org.eclipse.jst.javaee.web.WebApp webApp) + { + ((EObject) webApp).eAdapters().remove(_contextParamAdapter); + final List contextParams = webApp.getContextParams(); + if (contextParams != null) + { + final Iterator itContextParams = contextParams.iterator(); + while (itContextParams.hasNext()) + { + final EObject paramValue = (EObject) itContextParams.next(); + paramValue.eAdapters().remove(_contextParamAdapter); + } + } + } + + /** + * Gets list of application configuration file names as listed in the JSF + * CONFIG_FILES context parameter ("javax.faces.CONFIG_FILES"). Will return + * an empty list if WebArtifactEdit is null, if WebApp is null, if context + * parameter does not exist, or if trimmed context parameter's value is an + * empty String. + * + * @param project + * IProject instance for which to get the context parameter's + * value. + * @return List of application configuration file names as listed in the JSF + * CONFIG_FILES context parameter ("javax.faces.CONFIG_FILES"); list + * may be empty. + */ + public static List<String> getConfigFilesFromContextParam( + final IProject project) + { + List<String> filesList = Collections.EMPTY_LIST; + if (JSFAppConfigUtils.isValidJSFProject(project)) + { + final IModelProvider provider = ModelProviderManager + .getModelProvider(project); + final Object webAppObj = provider.getModelObject(); + if (webAppObj != null) + { + if (webAppObj instanceof WebApp) + { + filesList = getConfigFilesForJ2EEApp(project); + } + else if (webAppObj instanceof org.eclipse.jst.javaee.web.WebApp) + { + filesList = getConfigFilesForJEEApp((org.eclipse.jst.javaee.web.WebApp) webAppObj); + } + } + + } + return filesList; + } + + private static List<String> getConfigFilesForJEEApp( + final org.eclipse.jst.javaee.web.WebApp webApp) + { + String filesString = null; + final List contextParams = webApp.getContextParams(); + final Iterator itContextParams = contextParams.iterator(); + while (itContextParams.hasNext()) + { + final org.eclipse.jst.javaee.core.ParamValue paramValue = (org.eclipse.jst.javaee.core.ParamValue) itContextParams + .next(); + if (paramValue.getParamName().equals( + FACELET_10_LIBRARIES_CONTEXT_PARAM_NAME)|| + paramValue.getParamName().equals( + JSF20_FACELET_LIBRARIES_CONTEXT_PARAM_NAME)) + { + filesString = paramValue.getParamValue(); + break; + } + } + return parseFilesString(filesString); + } + + private static List<String> getConfigFilesForJ2EEApp(final IProject project) + { + List filesList = new ArrayList(); + final WebArtifactEdit webArtifactEdit = WebArtifactEdit + .getWebArtifactEditForRead(project); + if (webArtifactEdit != null) + { + try + { + WebApp webApp = null; + try + { + webApp = webArtifactEdit.getWebApp(); + } + catch (final ClassCastException cce) + { + // occasionally thrown from WTP code in RC3 and possibly + // later + JSFCorePlugin.log(IStatus.ERROR, cce.getLocalizedMessage(), + cce); + return filesList; + } + if (webApp != null) + { + String filesString = null; + // need to branch here due to model version differences + // (BugZilla #119442) + if (webApp.getVersionID() == J2EEVersionConstants.WEB_2_3_ID) + { + final EList contexts = webApp.getContexts(); + final Iterator itContexts = contexts.iterator(); + while (itContexts.hasNext()) + { + final ContextParam contextParam = (ContextParam) itContexts + .next(); + if (contextParam.getParamName().equals( + FACELET_10_LIBRARIES_CONTEXT_PARAM_NAME)|| + contextParam.getParamName().equals( + JSF20_FACELET_LIBRARIES_CONTEXT_PARAM_NAME)) + // if (contextParam.getParamName().equals( + // FACELET_LIBRARIES_CONTEXT_PARAM_NAME)) + { + filesString = contextParam.getParamValue(); + break; + } + } + } + else + { + final EList contextParams = webApp.getContextParams(); + final Iterator itContextParams = contextParams + .iterator(); + while (itContextParams.hasNext()) + { + final ParamValue paramValue = (ParamValue) itContextParams + .next(); + if (paramValue.getName().equals( + FACELET_10_LIBRARIES_CONTEXT_PARAM_NAME)|| + paramValue.getName().equals( + JSF20_FACELET_LIBRARIES_CONTEXT_PARAM_NAME)) + // if (paramValue.getName().equals( + // FACELET_LIBRARIES_CONTEXT_PARAM_NAME)) + { + filesString = paramValue.getValue(); + break; + } + } + } + filesList = parseFilesString(filesString); + } + } + finally + { + webArtifactEdit.dispose(); + } + } + + return filesList; + } + + private static List parseFilesString(final String filesString) + { + final List filesList = new ArrayList(); + if (filesString != null && filesString.trim().length() > 0) + { + final StringTokenizer stFilesString = new StringTokenizer( + filesString, ";"); //$NON-NLS-1$ + while (stFilesString.hasMoreTokens()) + { + final String configFile = stFilesString.nextToken().trim(); + filesList.add(configFile); + } + } + return filesList; + } + + /** + * Adapter implementation used to monitor addition/removal of context-param + * nodes and change in name of existing nodes in order to respond to changes + * to the JSF CONFIG_FILES context-param. + * + * @author Ian Trimble - Oracle + */ + private class ContextParamAdapter extends AdapterImpl + { + private final CopyOnWriteArrayList<WebappListener> _listeners = new CopyOnWriteArrayList<WebappListener>(); + + public void addListener(final WebappListener listener) + { + _listeners.addIfAbsent(listener); + } + + public void removeListener(final WebappListener listener) + { + _listeners.remove(listener); + } + + private void fireEvent(final WebappChangeEvent event) + { + for (final WebappListener listener : _listeners) + { + listener.webappChanged(event); + } + } + + /* + * (non-Javadoc) + * + * @see + * org.eclipse.emf.common.notify.impl.AdapterImpl#notifyChanged(org. + * eclipse.emf.common.notify.Notification) + */ + @Override + public void notifyChanged(final Notification notification) + { + final Object objNotifier = notification.getNotifier(); + // System.out.println(objNotifier.toString()); + if (objNotifier instanceof WebApp + || objNotifier instanceof org.eclipse.jst.javaee.web.WebApp) + { + final int eventType = notification.getEventType(); + switch (eventType) + { + case Notification.ADD: + final Object objNewValue = notification.getNewValue(); + if (objNewValue instanceof ContextParam + || objNewValue instanceof org.eclipse.jst.javaee.core.ParamValue) + { + contextParamAdded((EObject) objNewValue); + } + else if (objNewValue instanceof ParamValue) + { + paramValueAdded((EObject) objNewValue); + } + break; + case Notification.REMOVE: + final Object objOldValue = notification.getOldValue(); + if (objOldValue instanceof ContextParam + || objOldValue instanceof org.eclipse.jst.javaee.core.ParamValue) + { + contextParamRemoved((EObject) objOldValue); + } + else if (objOldValue instanceof ParamValue) + { + paramValueRemoved((EObject) objOldValue); + } + break; + } + } + // else if (objNotifier instanceof ContextParam + // || objNotifier instanceof org.eclipse.jst.javaee.core.ParamValue) + // { + // if (notification.getEventType() != Notification.REMOVING_ADAPTER) + // { + // _listener + // .tagLibChanged(ContextParamSpecifiedFaceletTaglibLocator.this); + // } + // } + // else if (objNotifier instanceof ParamValue) + // { + // if (notification.getEventType() != Notification.REMOVING_ADAPTER) + // { + // _listener + // .tagLibChanged(ContextParamSpecifiedFaceletTaglibLocator.this); + // } + // } + } + + /** + * Called when a new ContextParam instance is added. + * + * @param contextParam + * ContextParam instance. + */ + protected void contextParamAdded(final EObject contextParam) + { + if (isConfigFilesContextParam(contextParam)) + { + checkAndFireFileChanges(); + } + contextParam.eAdapters().add(this); + } + + private void checkAndFireFileChanges() + { + final List<IFile> oldFiles = _cachedFiles; + final List<IFile> newFiles = getFiles(); + + final List<IFile> filesAdded = new ArrayList<IFile>(); + final List<IFile> filesRemoved = new ArrayList<IFile>(); + + for (final IFile oldFile : oldFiles) + { + if (!newFiles.contains(oldFile)) + { + filesRemoved.add(oldFile); + } + } + + for (final IFile newFile : newFiles) + { + if (!oldFiles.contains(newFile)) + { + filesAdded.add(newFile); + } + } + + if (filesAdded.size() > 0 || filesRemoved.size() > 0) + { + fireEvent(new WebappChangeEvent(filesRemoved, filesAdded)); + } + } + + /** + * Called when a new ParamValue instance is added. + * + * @param paramValue + * ParamValue instance. + */ + protected void paramValueAdded(final EObject paramValue) + { + if (isConfigFilesParamValue(paramValue)) + { + checkAndFireFileChanges(); + } + paramValue.eAdapters().add(this); + } + + /** + * Called when a ContextParam instance is removed. + * + * @param contextParam + * ContextParam instance. + */ + protected void contextParamRemoved(final EObject contextParam) + { + if (isConfigFilesContextParam(contextParam)) + { + checkAndFireFileChanges(); + } + contextParam.eAdapters().remove(this); + } + + /** + * Called when a ParamValue instance is removed. + * + * @param paramValue + * ParamValue instance. + */ + protected void paramValueRemoved(final EObject paramValue) + { + if (isConfigFilesParamValue(paramValue)) + { + checkAndFireFileChanges(); + } + paramValue.eAdapters().remove(this); + } + + /** + * Tests if the passed ContextParam instance is the JSF CONFIG_FILES + * context parameter. + * + * @param contextParam + * ContextParam instance. + * @return true if the passed ContextParam instance is the JSF + * CONFIG_FILES context parameter, else false + */ + protected boolean isConfigFilesContextParam(final EObject contextParam) + { + boolean isConfigFiles = false; + if (contextParam != null) + { + String name = null; + if (contextParam instanceof ContextParam) + { + name = ((ContextParam) contextParam).getParamName(); + } + else if (contextParam instanceof org.eclipse.jst.javaee.core.ParamValue) + { + name = ((org.eclipse.jst.javaee.core.ParamValue) contextParam) + .getParamName(); + } + + if (FACELET_10_LIBRARIES_CONTEXT_PARAM_NAME.equals(name)|| + JSF20_FACELET_LIBRARIES_CONTEXT_PARAM_NAME.equals(name)) + { + isConfigFiles = true; + } + } + return isConfigFiles; + } + + /** + * Tests if the passed ParamValue instance is the JSF CONFIG_FILES + * context parameter. + * + * @param paramVal + * as EObject ParamValue instance. + * @return true if the passed ParamValue instance is the JSF + * CONFIG_FILES context parameter, else false + */ + protected boolean isConfigFilesParamValue(final EObject paramVal) + { + boolean isConfigFiles = false; + if (paramVal != null) + { + String name = null; + if (paramVal instanceof ParamValue) + { + name = ((ParamValue) paramVal).getName(); + } + else if (paramVal instanceof org.eclipse.jst.javaee.core.ParamValue) + { + name = ((org.eclipse.jst.javaee.core.ParamValue) paramVal) + .getParamName(); + } + + if (FACELET_10_LIBRARIES_CONTEXT_PARAM_NAME.equals(name)|| + JSF20_FACELET_LIBRARIES_CONTEXT_PARAM_NAME.equals(name)) + { + isConfigFiles = true; + } + } + return isConfigFiles; + } + } + + abstract static class WebappListener + { + public static class WebappChangeEvent + { + private final List<IFile> _removed; + private final List<IFile> _added; + + WebappChangeEvent(final List<IFile> removed, final List<IFile> added) + { + _removed = Collections.unmodifiableList(removed); + _added = Collections.unmodifiableList(added); + } + + public final List<IFile> getRemoved() + { + return _removed; + } + + public final List<IFile> getAdded() + { + return _added; + } + } + + public abstract void webappChanged(final WebappChangeEvent event); + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/XMLBasedTagRecord.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/XMLBasedTagRecord.java new file mode 100644 index 000000000..bd17f51df --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/XMLBasedTagRecord.java @@ -0,0 +1,99 @@ +/******************************************************************************* + * Copyright (c) 2008 Oracle Corporation. + * 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: + * Cameron Bateman - initial API and implementation + *******************************************************************************/ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib; + +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn; + +/** + * A tag record based on an xml tag defined Facelet taglib.xml + * @author cbateman + * + */ +public class XMLBasedTagRecord extends FaceletTagRecord +{ + /** + * + */ + private static final long serialVersionUID = 1411551451386954263L; + private final FaceletXMLDefnTaglib _taglibDefn; + private Map<String, TagDefn> _tagIndexByName; + + /** + * @param taglibDefn + */ + public XMLBasedTagRecord(final FaceletXMLDefnTaglib taglibDefn) + { + _taglibDefn = taglibDefn; + } + + @Override + public String getURI() + { + return _taglibDefn.getNamespace(); + } + + + @Override + public TagDefn getTag(final String name) + { + return getAndIndexElementDeclaration(name); + } + + private synchronized TagDefn getAndIndexElementDeclaration(final String name) + { + TagDefn tagDefn = null; + + if (_tagIndexByName == null) + { + _tagIndexByName = new HashMap<String, TagDefn>(); + } + else + { + tagDefn = _tagIndexByName.get(name); + } + + if (tagDefn == null && _tagIndexByName.size() < _taglibDefn.getTags().size()) + { + tagDefn = findTag(name); + } + + return tagDefn; + } + + private TagDefn findTag(final String name) + { + for (final TagDefn tag : _taglibDefn.getTags()) + { + if (name.equals(tag.getName())) + { + return tag; + } + } + return null; + } + + @Override + public List<TagDefn> getTags() + { + return Collections.unmodifiableList(_taglibDefn.getTags()); + } + + public int getNumTags() + { + return _taglibDefn.getTags().size(); + } +} diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/ComponentTagDefn.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/ComponentTagDefn.java new file mode 100644 index 000000000..36f961f98 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/ComponentTagDefn.java @@ -0,0 +1,81 @@ +/** + * <copyright> + * </copyright> + * + * $Id: ComponentTagDefn.java,v 1.1 2010/03/08 18:49:40 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib; + + +/** + * <!-- begin-user-doc --> + * A representation of the model object '<em><b>Component Tag Defn</b></em>'. + * <!-- end-user-doc --> + * + * <p> + * The following features are supported: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn#getComponentType <em>Component Type</em>}</li> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn#getRendererType <em>Renderer Type</em>}</li> + * </ul> + * </p> + * + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getComponentTagDefn() + * @model + * @generated + */ +public interface ComponentTagDefn extends HandlerTagDefn +{ + /** + * Returns the value of the '<em><b>Component Type</b></em>' attribute. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Component Type</em>' attribute isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Component Type</em>' attribute. + * @see #setComponentType(String) + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getComponentTagDefn_ComponentType() + * @model + * @generated + */ + String getComponentType(); + + /** + * Sets the value of the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn#getComponentType <em>Component Type</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param value the new value of the '<em>Component Type</em>' attribute. + * @see #getComponentType() + * @generated + */ + void setComponentType(String value); + + /** + * Returns the value of the '<em><b>Renderer Type</b></em>' attribute. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Renderer Type</em>' attribute isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Renderer Type</em>' attribute. + * @see #setRendererType(String) + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getComponentTagDefn_RendererType() + * @model + * @generated + */ + String getRendererType(); + + /** + * Sets the value of the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn#getRendererType <em>Renderer Type</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param value the new value of the '<em>Renderer Type</em>' attribute. + * @see #getRendererType() + * @generated + */ + void setRendererType(String value); + +} // ComponentTagDefn diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/ConverterTagDefn.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/ConverterTagDefn.java new file mode 100644 index 000000000..ed13c8c22 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/ConverterTagDefn.java @@ -0,0 +1,54 @@ +/** + * <copyright> + * </copyright> + * + * $Id: ConverterTagDefn.java,v 1.1 2010/03/08 18:49:39 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib; + + +/** + * <!-- begin-user-doc --> + * A representation of the model object '<em><b>Converter Tag Defn</b></em>'. + * <!-- end-user-doc --> + * + * <p> + * The following features are supported: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn#getConverterId <em>Converter Id</em>}</li> + * </ul> + * </p> + * + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getConverterTagDefn() + * @model + * @generated + */ +public interface ConverterTagDefn extends HandlerTagDefn +{ + /** + * Returns the value of the '<em><b>Converter Id</b></em>' attribute. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Converter Id</em>' attribute isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Converter Id</em>' attribute. + * @see #setConverterId(String) + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getConverterTagDefn_ConverterId() + * @model + * @generated + */ + String getConverterId(); + + /** + * Sets the value of the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn#getConverterId <em>Converter Id</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param value the new value of the '<em>Converter Id</em>' attribute. + * @see #getConverterId() + * @generated + */ + void setConverterId(String value); + +} // ConverterTagDefn diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletLibraryClassTagLib.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletLibraryClassTagLib.java new file mode 100644 index 000000000..9e7c6fd3b --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletLibraryClassTagLib.java @@ -0,0 +1,54 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FaceletLibraryClassTagLib.java,v 1.1 2010/03/08 18:49:40 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib; + + +/** + * <!-- begin-user-doc --> + * A representation of the model object '<em><b>Facelet Library Class Tag Lib</b></em>'. + * <!-- end-user-doc --> + * + * <p> + * The following features are supported: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib#getLibraryClass <em>Library Class</em>}</li> + * </ul> + * </p> + * + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getFaceletLibraryClassTagLib() + * @model + * @generated + */ +public interface FaceletLibraryClassTagLib extends FaceletTaglibDefn +{ + /** + * Returns the value of the '<em><b>Library Class</b></em>' attribute. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Library Class</em>' attribute isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Library Class</em>' attribute. + * @see #setLibraryClass(String) + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getFaceletLibraryClassTagLib_LibraryClass() + * @model + * @generated + */ + String getLibraryClass(); + + /** + * Sets the value of the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib#getLibraryClass <em>Library Class</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param value the new value of the '<em>Library Class</em>' attribute. + * @see #getLibraryClass() + * @generated + */ + void setLibraryClass(String value); + +} // FaceletLibraryClassTagLib diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletTaglibDefn.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletTaglibDefn.java new file mode 100644 index 000000000..7eea852c8 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletTaglibDefn.java @@ -0,0 +1,24 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FaceletTaglibDefn.java,v 1.1 2010/03/08 18:49:40 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib; + +import org.eclipse.emf.ecore.EObject; + +/** + * <!-- begin-user-doc --> + * A representation of the model object '<em><b>Defn</b></em>'. + * <!-- end-user-doc --> + * + * + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getFaceletTaglibDefn() + * @model + * @generated + */ +public interface FaceletTaglibDefn extends EObject +{ + // nuthin' +} // FaceletTaglibDefn diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletTaglibFactory.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletTaglibFactory.java new file mode 100644 index 000000000..b5905304a --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletTaglibFactory.java @@ -0,0 +1,128 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FaceletTaglibFactory.java,v 1.1 2010/03/08 18:49:39 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib; + +import org.eclipse.emf.ecore.EFactory; + +/** + * <!-- begin-user-doc --> + * The <b>Factory</b> for the model. + * It provides a create method for each non-abstract class of the model. + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage + * @generated + */ +public interface FaceletTaglibFactory extends EFactory +{ + /** + * The singleton instance of the factory. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + FaceletTaglibFactory eINSTANCE = org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibFactoryImpl.init(); + + /** + * Returns a new object of class '<em>Facelet Library Class Tag Lib</em>'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return a new object of class '<em>Facelet Library Class Tag Lib</em>'. + * @generated + */ + FaceletLibraryClassTagLib createFaceletLibraryClassTagLib(); + + /** + * Returns a new object of class '<em>Facelet XML Defn Taglib</em>'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return a new object of class '<em>Facelet XML Defn Taglib</em>'. + * @generated + */ + FaceletXMLDefnTaglib createFaceletXMLDefnTaglib(); + + /** + * Returns a new object of class '<em>Defn</em>'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return a new object of class '<em>Defn</em>'. + * @generated + */ + FaceletTaglibDefn createFaceletTaglibDefn(); + + /** + * Returns a new object of class '<em>Component Tag Defn</em>'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return a new object of class '<em>Component Tag Defn</em>'. + * @generated + */ + ComponentTagDefn createComponentTagDefn(); + + /** + * Returns a new object of class '<em>Validator Tag Defn</em>'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return a new object of class '<em>Validator Tag Defn</em>'. + * @generated + */ + ValidatorTagDefn createValidatorTagDefn(); + + /** + * Returns a new object of class '<em>Converter Tag Defn</em>'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return a new object of class '<em>Converter Tag Defn</em>'. + * @generated + */ + ConverterTagDefn createConverterTagDefn(); + + /** + * Returns a new object of class '<em>Handler Tag Defn</em>'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return a new object of class '<em>Handler Tag Defn</em>'. + * @generated + */ + HandlerTagDefn createHandlerTagDefn(); + + /** + * Returns a new object of class '<em>Source Tag Defn</em>'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return a new object of class '<em>Source Tag Defn</em>'. + * @generated + */ + SourceTagDefn createSourceTagDefn(); + + /** + * Returns a new object of class '<em>Tag Defn</em>'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return a new object of class '<em>Tag Defn</em>'. + * @generated + */ + TagDefn createTagDefn(); + + /** + * Returns a new object of class '<em>Function Defn</em>'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return a new object of class '<em>Function Defn</em>'. + * @generated + */ + FunctionDefn createFunctionDefn(); + + /** + * Returns the package supported by this factory. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the package supported by this factory. + * @generated + */ + FaceletTaglibPackage getFaceletTaglibPackage(); + +} //FaceletTaglibFactory diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletTaglibPackage.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletTaglibPackage.java new file mode 100644 index 000000000..d4ce6f247 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletTaglibPackage.java @@ -0,0 +1,944 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FaceletTaglibPackage.java,v 1.1 2010/03/08 18:49:40 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib; + +import org.eclipse.emf.ecore.EAttribute; +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.EReference; + +/** + * <!-- begin-user-doc --> + * The <b>Package</b> for the model. + * It contains accessors for the meta objects to represent + * <ul> + * <li>each class,</li> + * <li>each feature of each class,</li> + * <li>each enum,</li> + * <li>and each data type</li> + * </ul> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibFactory + * @model kind="package" + * @generated + */ +public interface FaceletTaglibPackage extends EPackage +{ + /** + * The package name. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + String eNAME = "faceletTaglib"; //$NON-NLS-1$ + + /** + * The package namespace URI. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + String eNS_URI = "http://org.eclipse.jst.jsf.facelet.core/faceletTaglib.ecore"; //$NON-NLS-1$ + + /** + * The package namespace name. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + String eNS_PREFIX = "faceletTaglib"; //$NON-NLS-1$ + + /** + * The singleton instance of the package. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + FaceletTaglibPackage eINSTANCE = org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl.init(); + + /** + * The meta object id for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibDefnImpl <em>Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getFaceletTaglibDefn() + * @generated + */ + int FACELET_TAGLIB_DEFN = 2; + + /** + * The number of structural features of the '<em>Defn</em>' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int FACELET_TAGLIB_DEFN_FEATURE_COUNT = 0; + + /** + * The meta object id for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletLibraryClassTagLibImpl <em>Facelet Library Class Tag Lib</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletLibraryClassTagLibImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getFaceletLibraryClassTagLib() + * @generated + */ + int FACELET_LIBRARY_CLASS_TAG_LIB = 0; + + /** + * The feature id for the '<em><b>Library Class</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int FACELET_LIBRARY_CLASS_TAG_LIB__LIBRARY_CLASS = FACELET_TAGLIB_DEFN_FEATURE_COUNT + 0; + + /** + * The number of structural features of the '<em>Facelet Library Class Tag Lib</em>' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int FACELET_LIBRARY_CLASS_TAG_LIB_FEATURE_COUNT = FACELET_TAGLIB_DEFN_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletXMLDefnTaglibImpl <em>Facelet XML Defn Taglib</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletXMLDefnTaglibImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getFaceletXMLDefnTaglib() + * @generated + */ + int FACELET_XML_DEFN_TAGLIB = 1; + + /** + * The feature id for the '<em><b>Namespace</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int FACELET_XML_DEFN_TAGLIB__NAMESPACE = FACELET_TAGLIB_DEFN_FEATURE_COUNT + 0; + + /** + * The feature id for the '<em><b>Tags</b></em>' reference list. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int FACELET_XML_DEFN_TAGLIB__TAGS = FACELET_TAGLIB_DEFN_FEATURE_COUNT + 1; + + /** + * The feature id for the '<em><b>Functions</b></em>' reference list. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int FACELET_XML_DEFN_TAGLIB__FUNCTIONS = FACELET_TAGLIB_DEFN_FEATURE_COUNT + 2; + + /** + * The number of structural features of the '<em>Facelet XML Defn Taglib</em>' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int FACELET_XML_DEFN_TAGLIB_FEATURE_COUNT = FACELET_TAGLIB_DEFN_FEATURE_COUNT + 3; + + /** + * The meta object id for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.TagDefnImpl <em>Tag Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.TagDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getTagDefn() + * @generated + */ + int TAG_DEFN = 8; + + /** + * The feature id for the '<em><b>Name</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int TAG_DEFN__NAME = 0; + + /** + * The number of structural features of the '<em>Tag Defn</em>' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int TAG_DEFN_FEATURE_COUNT = 1; + + /** + * The meta object id for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.HandlerTagDefnImpl <em>Handler Tag Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.HandlerTagDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getHandlerTagDefn() + * @generated + */ + int HANDLER_TAG_DEFN = 6; + + /** + * The feature id for the '<em><b>Name</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int HANDLER_TAG_DEFN__NAME = TAG_DEFN__NAME; + + /** + * The feature id for the '<em><b>Handler Class</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int HANDLER_TAG_DEFN__HANDLER_CLASS = TAG_DEFN_FEATURE_COUNT + 0; + + /** + * The number of structural features of the '<em>Handler Tag Defn</em>' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int HANDLER_TAG_DEFN_FEATURE_COUNT = TAG_DEFN_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ComponentTagDefnImpl <em>Component Tag Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ComponentTagDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getComponentTagDefn() + * @generated + */ + int COMPONENT_TAG_DEFN = 3; + + /** + * The feature id for the '<em><b>Name</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int COMPONENT_TAG_DEFN__NAME = HANDLER_TAG_DEFN__NAME; + + /** + * The feature id for the '<em><b>Handler Class</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int COMPONENT_TAG_DEFN__HANDLER_CLASS = HANDLER_TAG_DEFN__HANDLER_CLASS; + + /** + * The feature id for the '<em><b>Component Type</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int COMPONENT_TAG_DEFN__COMPONENT_TYPE = HANDLER_TAG_DEFN_FEATURE_COUNT + 0; + + /** + * The feature id for the '<em><b>Renderer Type</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int COMPONENT_TAG_DEFN__RENDERER_TYPE = HANDLER_TAG_DEFN_FEATURE_COUNT + 1; + + /** + * The number of structural features of the '<em>Component Tag Defn</em>' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int COMPONENT_TAG_DEFN_FEATURE_COUNT = HANDLER_TAG_DEFN_FEATURE_COUNT + 2; + + /** + * The meta object id for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ValidatorTagDefnImpl <em>Validator Tag Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ValidatorTagDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getValidatorTagDefn() + * @generated + */ + int VALIDATOR_TAG_DEFN = 4; + + /** + * The feature id for the '<em><b>Name</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int VALIDATOR_TAG_DEFN__NAME = HANDLER_TAG_DEFN__NAME; + + /** + * The feature id for the '<em><b>Handler Class</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int VALIDATOR_TAG_DEFN__HANDLER_CLASS = HANDLER_TAG_DEFN__HANDLER_CLASS; + + /** + * The feature id for the '<em><b>Validator Id</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int VALIDATOR_TAG_DEFN__VALIDATOR_ID = HANDLER_TAG_DEFN_FEATURE_COUNT + 0; + + /** + * The number of structural features of the '<em>Validator Tag Defn</em>' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int VALIDATOR_TAG_DEFN_FEATURE_COUNT = HANDLER_TAG_DEFN_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ConverterTagDefnImpl <em>Converter Tag Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ConverterTagDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getConverterTagDefn() + * @generated + */ + int CONVERTER_TAG_DEFN = 5; + + /** + * The feature id for the '<em><b>Name</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int CONVERTER_TAG_DEFN__NAME = HANDLER_TAG_DEFN__NAME; + + /** + * The feature id for the '<em><b>Handler Class</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int CONVERTER_TAG_DEFN__HANDLER_CLASS = HANDLER_TAG_DEFN__HANDLER_CLASS; + + /** + * The feature id for the '<em><b>Converter Id</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int CONVERTER_TAG_DEFN__CONVERTER_ID = HANDLER_TAG_DEFN_FEATURE_COUNT + 0; + + /** + * The number of structural features of the '<em>Converter Tag Defn</em>' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int CONVERTER_TAG_DEFN_FEATURE_COUNT = HANDLER_TAG_DEFN_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.SourceTagDefnImpl <em>Source Tag Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.SourceTagDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getSourceTagDefn() + * @generated + */ + int SOURCE_TAG_DEFN = 7; + + /** + * The feature id for the '<em><b>Name</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int SOURCE_TAG_DEFN__NAME = TAG_DEFN__NAME; + + /** + * The feature id for the '<em><b>Source</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int SOURCE_TAG_DEFN__SOURCE = TAG_DEFN_FEATURE_COUNT + 0; + + /** + * The number of structural features of the '<em>Source Tag Defn</em>' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int SOURCE_TAG_DEFN_FEATURE_COUNT = TAG_DEFN_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FunctionDefnImpl <em>Function Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FunctionDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getFunctionDefn() + * @generated + */ + int FUNCTION_DEFN = 9; + + /** + * The feature id for the '<em><b>Function Name</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int FUNCTION_DEFN__FUNCTION_NAME = 0; + + /** + * The feature id for the '<em><b>Function Class</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int FUNCTION_DEFN__FUNCTION_CLASS = 1; + + /** + * The feature id for the '<em><b>Function Signature</b></em>' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int FUNCTION_DEFN__FUNCTION_SIGNATURE = 2; + + /** + * The number of structural features of the '<em>Function Defn</em>' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + * @ordered + */ + int FUNCTION_DEFN_FEATURE_COUNT = 3; + + + /** + * Returns the meta object for class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib <em>Facelet Library Class Tag Lib</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for class '<em>Facelet Library Class Tag Lib</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib + * @generated + */ + EClass getFaceletLibraryClassTagLib(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib#getLibraryClass <em>Library Class</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the attribute '<em>Library Class</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib#getLibraryClass() + * @see #getFaceletLibraryClassTagLib() + * @generated + */ + EAttribute getFaceletLibraryClassTagLib_LibraryClass(); + + /** + * Returns the meta object for class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib <em>Facelet XML Defn Taglib</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for class '<em>Facelet XML Defn Taglib</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib + * @generated + */ + EClass getFaceletXMLDefnTaglib(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib#getNamespace <em>Namespace</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the attribute '<em>Namespace</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib#getNamespace() + * @see #getFaceletXMLDefnTaglib() + * @generated + */ + EAttribute getFaceletXMLDefnTaglib_Namespace(); + + /** + * Returns the meta object for the reference list '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib#getTags <em>Tags</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the reference list '<em>Tags</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib#getTags() + * @see #getFaceletXMLDefnTaglib() + * @generated + */ + EReference getFaceletXMLDefnTaglib_Tags(); + + /** + * Returns the meta object for the reference list '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib#getFunctions <em>Functions</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the reference list '<em>Functions</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib#getFunctions() + * @see #getFaceletXMLDefnTaglib() + * @generated + */ + EReference getFaceletXMLDefnTaglib_Functions(); + + /** + * Returns the meta object for class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibDefn <em>Defn</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for class '<em>Defn</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibDefn + * @generated + */ + EClass getFaceletTaglibDefn(); + + /** + * Returns the meta object for class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn <em>Component Tag Defn</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for class '<em>Component Tag Defn</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn + * @generated + */ + EClass getComponentTagDefn(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn#getComponentType <em>Component Type</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the attribute '<em>Component Type</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn#getComponentType() + * @see #getComponentTagDefn() + * @generated + */ + EAttribute getComponentTagDefn_ComponentType(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn#getRendererType <em>Renderer Type</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the attribute '<em>Renderer Type</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn#getRendererType() + * @see #getComponentTagDefn() + * @generated + */ + EAttribute getComponentTagDefn_RendererType(); + + /** + * Returns the meta object for class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn <em>Validator Tag Defn</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for class '<em>Validator Tag Defn</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn + * @generated + */ + EClass getValidatorTagDefn(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn#getValidatorId <em>Validator Id</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the attribute '<em>Validator Id</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn#getValidatorId() + * @see #getValidatorTagDefn() + * @generated + */ + EAttribute getValidatorTagDefn_ValidatorId(); + + /** + * Returns the meta object for class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn <em>Converter Tag Defn</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for class '<em>Converter Tag Defn</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn + * @generated + */ + EClass getConverterTagDefn(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn#getConverterId <em>Converter Id</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the attribute '<em>Converter Id</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn#getConverterId() + * @see #getConverterTagDefn() + * @generated + */ + EAttribute getConverterTagDefn_ConverterId(); + + /** + * Returns the meta object for class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.HandlerTagDefn <em>Handler Tag Defn</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for class '<em>Handler Tag Defn</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.HandlerTagDefn + * @generated + */ + EClass getHandlerTagDefn(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.HandlerTagDefn#getHandlerClass <em>Handler Class</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the attribute '<em>Handler Class</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.HandlerTagDefn#getHandlerClass() + * @see #getHandlerTagDefn() + * @generated + */ + EAttribute getHandlerTagDefn_HandlerClass(); + + /** + * Returns the meta object for class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.SourceTagDefn <em>Source Tag Defn</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for class '<em>Source Tag Defn</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.SourceTagDefn + * @generated + */ + EClass getSourceTagDefn(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.SourceTagDefn#getSource <em>Source</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the attribute '<em>Source</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.SourceTagDefn#getSource() + * @see #getSourceTagDefn() + * @generated + */ + EAttribute getSourceTagDefn_Source(); + + /** + * Returns the meta object for class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn <em>Tag Defn</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for class '<em>Tag Defn</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn + * @generated + */ + EClass getTagDefn(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn#getName <em>Name</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the attribute '<em>Name</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn#getName() + * @see #getTagDefn() + * @generated + */ + EAttribute getTagDefn_Name(); + + /** + * Returns the meta object for class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn <em>Function Defn</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for class '<em>Function Defn</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn + * @generated + */ + EClass getFunctionDefn(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn#getFunctionName <em>Function Name</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the attribute '<em>Function Name</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn#getFunctionName() + * @see #getFunctionDefn() + * @generated + */ + EAttribute getFunctionDefn_FunctionName(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn#getFunctionClass <em>Function Class</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the attribute '<em>Function Class</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn#getFunctionClass() + * @see #getFunctionDefn() + * @generated + */ + EAttribute getFunctionDefn_FunctionClass(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn#getFunctionSignature <em>Function Signature</em>}'. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the meta object for the attribute '<em>Function Signature</em>'. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn#getFunctionSignature() + * @see #getFunctionDefn() + * @generated + */ + EAttribute getFunctionDefn_FunctionSignature(); + + /** + * Returns the factory that creates the instances of the model. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @return the factory that creates the instances of the model. + * @generated + */ + FaceletTaglibFactory getFaceletTaglibFactory(); + + /** + * <!-- begin-user-doc --> + * Defines literals for the meta objects that represent + * <ul> + * <li>each class,</li> + * <li>each feature of each class,</li> + * <li>each enum,</li> + * <li>and each data type</li> + * </ul> + * <!-- end-user-doc --> + * @generated + */ + @SuppressWarnings("hiding") + interface Literals + { + /** + * The meta object literal for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletLibraryClassTagLibImpl <em>Facelet Library Class Tag Lib</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletLibraryClassTagLibImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getFaceletLibraryClassTagLib() + * @generated + */ + EClass FACELET_LIBRARY_CLASS_TAG_LIB = eINSTANCE.getFaceletLibraryClassTagLib(); + + /** + * The meta object literal for the '<em><b>Library Class</b></em>' attribute feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EAttribute FACELET_LIBRARY_CLASS_TAG_LIB__LIBRARY_CLASS = eINSTANCE.getFaceletLibraryClassTagLib_LibraryClass(); + + /** + * The meta object literal for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletXMLDefnTaglibImpl <em>Facelet XML Defn Taglib</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletXMLDefnTaglibImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getFaceletXMLDefnTaglib() + * @generated + */ + EClass FACELET_XML_DEFN_TAGLIB = eINSTANCE.getFaceletXMLDefnTaglib(); + + /** + * The meta object literal for the '<em><b>Namespace</b></em>' attribute feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EAttribute FACELET_XML_DEFN_TAGLIB__NAMESPACE = eINSTANCE.getFaceletXMLDefnTaglib_Namespace(); + + /** + * The meta object literal for the '<em><b>Tags</b></em>' reference list feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EReference FACELET_XML_DEFN_TAGLIB__TAGS = eINSTANCE.getFaceletXMLDefnTaglib_Tags(); + + /** + * The meta object literal for the '<em><b>Functions</b></em>' reference list feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EReference FACELET_XML_DEFN_TAGLIB__FUNCTIONS = eINSTANCE.getFaceletXMLDefnTaglib_Functions(); + + /** + * The meta object literal for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibDefnImpl <em>Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getFaceletTaglibDefn() + * @generated + */ + EClass FACELET_TAGLIB_DEFN = eINSTANCE.getFaceletTaglibDefn(); + + /** + * The meta object literal for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ComponentTagDefnImpl <em>Component Tag Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ComponentTagDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getComponentTagDefn() + * @generated + */ + EClass COMPONENT_TAG_DEFN = eINSTANCE.getComponentTagDefn(); + + /** + * The meta object literal for the '<em><b>Component Type</b></em>' attribute feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EAttribute COMPONENT_TAG_DEFN__COMPONENT_TYPE = eINSTANCE.getComponentTagDefn_ComponentType(); + + /** + * The meta object literal for the '<em><b>Renderer Type</b></em>' attribute feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EAttribute COMPONENT_TAG_DEFN__RENDERER_TYPE = eINSTANCE.getComponentTagDefn_RendererType(); + + /** + * The meta object literal for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ValidatorTagDefnImpl <em>Validator Tag Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ValidatorTagDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getValidatorTagDefn() + * @generated + */ + EClass VALIDATOR_TAG_DEFN = eINSTANCE.getValidatorTagDefn(); + + /** + * The meta object literal for the '<em><b>Validator Id</b></em>' attribute feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EAttribute VALIDATOR_TAG_DEFN__VALIDATOR_ID = eINSTANCE.getValidatorTagDefn_ValidatorId(); + + /** + * The meta object literal for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ConverterTagDefnImpl <em>Converter Tag Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ConverterTagDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getConverterTagDefn() + * @generated + */ + EClass CONVERTER_TAG_DEFN = eINSTANCE.getConverterTagDefn(); + + /** + * The meta object literal for the '<em><b>Converter Id</b></em>' attribute feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EAttribute CONVERTER_TAG_DEFN__CONVERTER_ID = eINSTANCE.getConverterTagDefn_ConverterId(); + + /** + * The meta object literal for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.HandlerTagDefnImpl <em>Handler Tag Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.HandlerTagDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getHandlerTagDefn() + * @generated + */ + EClass HANDLER_TAG_DEFN = eINSTANCE.getHandlerTagDefn(); + + /** + * The meta object literal for the '<em><b>Handler Class</b></em>' attribute feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EAttribute HANDLER_TAG_DEFN__HANDLER_CLASS = eINSTANCE.getHandlerTagDefn_HandlerClass(); + + /** + * The meta object literal for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.SourceTagDefnImpl <em>Source Tag Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.SourceTagDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getSourceTagDefn() + * @generated + */ + EClass SOURCE_TAG_DEFN = eINSTANCE.getSourceTagDefn(); + + /** + * The meta object literal for the '<em><b>Source</b></em>' attribute feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EAttribute SOURCE_TAG_DEFN__SOURCE = eINSTANCE.getSourceTagDefn_Source(); + + /** + * The meta object literal for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.TagDefnImpl <em>Tag Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.TagDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getTagDefn() + * @generated + */ + EClass TAG_DEFN = eINSTANCE.getTagDefn(); + + /** + * The meta object literal for the '<em><b>Name</b></em>' attribute feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EAttribute TAG_DEFN__NAME = eINSTANCE.getTagDefn_Name(); + + /** + * The meta object literal for the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FunctionDefnImpl <em>Function Defn</em>}' class. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FunctionDefnImpl + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletTaglibPackageImpl#getFunctionDefn() + * @generated + */ + EClass FUNCTION_DEFN = eINSTANCE.getFunctionDefn(); + + /** + * The meta object literal for the '<em><b>Function Name</b></em>' attribute feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EAttribute FUNCTION_DEFN__FUNCTION_NAME = eINSTANCE.getFunctionDefn_FunctionName(); + + /** + * The meta object literal for the '<em><b>Function Class</b></em>' attribute feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EAttribute FUNCTION_DEFN__FUNCTION_CLASS = eINSTANCE.getFunctionDefn_FunctionClass(); + + /** + * The meta object literal for the '<em><b>Function Signature</b></em>' attribute feature. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + EAttribute FUNCTION_DEFN__FUNCTION_SIGNATURE = eINSTANCE.getFunctionDefn_FunctionSignature(); + + } + +} //FaceletTaglibPackage diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletXMLDefnTaglib.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletXMLDefnTaglib.java new file mode 100644 index 000000000..98b45a41a --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FaceletXMLDefnTaglib.java @@ -0,0 +1,89 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FaceletXMLDefnTaglib.java,v 1.1 2010/03/08 18:49:40 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib; + +import org.eclipse.emf.common.util.EList; + +/** + * <!-- begin-user-doc --> + * A representation of the model object '<em><b>Facelet XML Defn Taglib</b></em>'. + * <!-- end-user-doc --> + * + * <p> + * The following features are supported: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib#getNamespace <em>Namespace</em>}</li> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib#getTags <em>Tags</em>}</li> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib#getFunctions <em>Functions</em>}</li> + * </ul> + * </p> + * + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getFaceletXMLDefnTaglib() + * @model + * @generated + */ +public interface FaceletXMLDefnTaglib extends FaceletTaglibDefn +{ + /** + * Returns the value of the '<em><b>Namespace</b></em>' attribute. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Namespace</em>' attribute isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Namespace</em>' attribute. + * @see #setNamespace(String) + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getFaceletXMLDefnTaglib_Namespace() + * @model + * @generated + */ + String getNamespace(); + + /** + * Sets the value of the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib#getNamespace <em>Namespace</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param value the new value of the '<em>Namespace</em>' attribute. + * @see #getNamespace() + * @generated + */ + void setNamespace(String value); + + /** + * Returns the value of the '<em><b>Tags</b></em>' reference list. + * The list contents are of type {@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn}. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Tags</em>' reference list isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Tags</em>' reference list. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getFaceletXMLDefnTaglib_Tags() + * @model + * @generated + */ + EList<TagDefn> getTags(); + + /** + * Returns the value of the '<em><b>Functions</b></em>' reference list. + * The list contents are of type {@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn}. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Functions</em>' reference list isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Functions</em>' reference list. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getFaceletXMLDefnTaglib_Functions() + * @model + * @generated + */ + EList<FunctionDefn> getFunctions(); + +} // FaceletXMLDefnTaglib diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FunctionDefn.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FunctionDefn.java new file mode 100644 index 000000000..463612023 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/FunctionDefn.java @@ -0,0 +1,109 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FunctionDefn.java,v 1.1 2010/03/08 18:49:40 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib; + +import org.eclipse.emf.ecore.EObject; + +/** + * <!-- begin-user-doc --> + * A representation of the model object '<em><b>Function Defn</b></em>'. + * <!-- end-user-doc --> + * + * <p> + * The following features are supported: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn#getFunctionName <em>Function Name</em>}</li> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn#getFunctionClass <em>Function Class</em>}</li> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn#getFunctionSignature <em>Function Signature</em>}</li> + * </ul> + * </p> + * + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getFunctionDefn() + * @model + * @generated + */ +public interface FunctionDefn extends EObject +{ + /** + * Returns the value of the '<em><b>Function Name</b></em>' attribute. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Function Name</em>' attribute isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Function Name</em>' attribute. + * @see #setFunctionName(String) + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getFunctionDefn_FunctionName() + * @model + * @generated + */ + String getFunctionName(); + + /** + * Sets the value of the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn#getFunctionName <em>Function Name</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param value the new value of the '<em>Function Name</em>' attribute. + * @see #getFunctionName() + * @generated + */ + void setFunctionName(String value); + + /** + * Returns the value of the '<em><b>Function Class</b></em>' attribute. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Function Class</em>' attribute isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Function Class</em>' attribute. + * @see #setFunctionClass(String) + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getFunctionDefn_FunctionClass() + * @model + * @generated + */ + String getFunctionClass(); + + /** + * Sets the value of the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn#getFunctionClass <em>Function Class</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param value the new value of the '<em>Function Class</em>' attribute. + * @see #getFunctionClass() + * @generated + */ + void setFunctionClass(String value); + + /** + * Returns the value of the '<em><b>Function Signature</b></em>' attribute. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Function Signature</em>' attribute isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Function Signature</em>' attribute. + * @see #setFunctionSignature(String) + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getFunctionDefn_FunctionSignature() + * @model + * @generated + */ + String getFunctionSignature(); + + /** + * Sets the value of the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn#getFunctionSignature <em>Function Signature</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param value the new value of the '<em>Function Signature</em>' attribute. + * @see #getFunctionSignature() + * @generated + */ + void setFunctionSignature(String value); + +} // FunctionDefn diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/HandlerTagDefn.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/HandlerTagDefn.java new file mode 100644 index 000000000..d191bccc7 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/HandlerTagDefn.java @@ -0,0 +1,54 @@ +/** + * <copyright> + * </copyright> + * + * $Id: HandlerTagDefn.java,v 1.1 2010/03/08 18:49:40 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib; + + +/** + * <!-- begin-user-doc --> + * A representation of the model object '<em><b>Handler Tag Defn</b></em>'. + * <!-- end-user-doc --> + * + * <p> + * The following features are supported: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.HandlerTagDefn#getHandlerClass <em>Handler Class</em>}</li> + * </ul> + * </p> + * + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getHandlerTagDefn() + * @model + * @generated + */ +public interface HandlerTagDefn extends TagDefn +{ + /** + * Returns the value of the '<em><b>Handler Class</b></em>' attribute. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Handler Class</em>' attribute isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Handler Class</em>' attribute. + * @see #setHandlerClass(String) + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getHandlerTagDefn_HandlerClass() + * @model + * @generated + */ + String getHandlerClass(); + + /** + * Sets the value of the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.HandlerTagDefn#getHandlerClass <em>Handler Class</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param value the new value of the '<em>Handler Class</em>' attribute. + * @see #getHandlerClass() + * @generated + */ + void setHandlerClass(String value); + +} // HandlerTagDefn diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/SourceTagDefn.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/SourceTagDefn.java new file mode 100644 index 000000000..8add55e6c --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/SourceTagDefn.java @@ -0,0 +1,54 @@ +/** + * <copyright> + * </copyright> + * + * $Id: SourceTagDefn.java,v 1.1 2010/03/08 18:49:40 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib; + + +/** + * <!-- begin-user-doc --> + * A representation of the model object '<em><b>Source Tag Defn</b></em>'. + * <!-- end-user-doc --> + * + * <p> + * The following features are supported: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.SourceTagDefn#getSource <em>Source</em>}</li> + * </ul> + * </p> + * + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getSourceTagDefn() + * @model + * @generated + */ +public interface SourceTagDefn extends TagDefn +{ + /** + * Returns the value of the '<em><b>Source</b></em>' attribute. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Source</em>' attribute isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Source</em>' attribute. + * @see #setSource(String) + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getSourceTagDefn_Source() + * @model + * @generated + */ + String getSource(); + + /** + * Sets the value of the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.SourceTagDefn#getSource <em>Source</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param value the new value of the '<em>Source</em>' attribute. + * @see #getSource() + * @generated + */ + void setSource(String value); + +} // SourceTagDefn diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/TagDefn.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/TagDefn.java new file mode 100644 index 000000000..ead8988f0 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/TagDefn.java @@ -0,0 +1,55 @@ +/** + * <copyright> + * </copyright> + * + * $Id: TagDefn.java,v 1.1 2010/03/08 18:49:40 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib; + +import org.eclipse.emf.ecore.EObject; + +/** + * <!-- begin-user-doc --> + * A representation of the model object '<em><b>Tag Defn</b></em>'. + * <!-- end-user-doc --> + * + * <p> + * The following features are supported: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn#getName <em>Name</em>}</li> + * </ul> + * </p> + * + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getTagDefn() + * @model + * @generated + */ +public interface TagDefn extends EObject +{ + /** + * Returns the value of the '<em><b>Name</b></em>' attribute. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Name</em>' attribute isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Name</em>' attribute. + * @see #setName(String) + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getTagDefn_Name() + * @model + * @generated + */ + String getName(); + + /** + * Sets the value of the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn#getName <em>Name</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param value the new value of the '<em>Name</em>' attribute. + * @see #getName() + * @generated + */ + void setName(String value); + +} // TagDefn diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/ValidatorTagDefn.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/ValidatorTagDefn.java new file mode 100644 index 000000000..16688103e --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/ValidatorTagDefn.java @@ -0,0 +1,54 @@ +/** + * <copyright> + * </copyright> + * + * $Id: ValidatorTagDefn.java,v 1.1 2010/03/08 18:49:40 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib; + + +/** + * <!-- begin-user-doc --> + * A representation of the model object '<em><b>Validator Tag Defn</b></em>'. + * <!-- end-user-doc --> + * + * <p> + * The following features are supported: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn#getValidatorId <em>Validator Id</em>}</li> + * </ul> + * </p> + * + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getValidatorTagDefn() + * @model + * @generated + */ +public interface ValidatorTagDefn extends HandlerTagDefn +{ + /** + * Returns the value of the '<em><b>Validator Id</b></em>' attribute. + * <!-- begin-user-doc --> + * <p> + * If the meaning of the '<em>Validator Id</em>' attribute isn't clear, + * there really should be more of a description here... + * </p> + * <!-- end-user-doc --> + * @return the value of the '<em>Validator Id</em>' attribute. + * @see #setValidatorId(String) + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#getValidatorTagDefn_ValidatorId() + * @model + * @generated + */ + String getValidatorId(); + + /** + * Sets the value of the '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn#getValidatorId <em>Validator Id</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param value the new value of the '<em>Validator Id</em>' attribute. + * @see #getValidatorId() + * @generated + */ + void setValidatorId(String value); + +} // ValidatorTagDefn diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/ComponentTagDefnImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/ComponentTagDefnImpl.java new file mode 100644 index 000000000..3efb5195a --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/ComponentTagDefnImpl.java @@ -0,0 +1,236 @@ +/** + * <copyright> + * </copyright> + * + * $Id: ComponentTagDefnImpl.java,v 1.1 2010/03/08 18:49:42 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage; + +/** + * <!-- begin-user-doc --> + * An implementation of the model object '<em><b>Component Tag Defn</b></em>'. + * <!-- end-user-doc --> + * <p> + * The following features are implemented: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ComponentTagDefnImpl#getComponentType <em>Component Type</em>}</li> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ComponentTagDefnImpl#getRendererType <em>Renderer Type</em>}</li> + * </ul> + * </p> + * + * @generated + */ +public class ComponentTagDefnImpl extends HandlerTagDefnImpl implements ComponentTagDefn +{ + /** + * The default value of the '{@link #getComponentType() <em>Component Type</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getComponentType() + * @generated + * @ordered + */ + protected static final String COMPONENT_TYPE_EDEFAULT = null; + + /** + * The cached value of the '{@link #getComponentType() <em>Component Type</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getComponentType() + * @generated + * @ordered + */ + protected String componentType = COMPONENT_TYPE_EDEFAULT; + + /** + * The default value of the '{@link #getRendererType() <em>Renderer Type</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getRendererType() + * @generated + * @ordered + */ + protected static final String RENDERER_TYPE_EDEFAULT = null; + + /** + * The cached value of the '{@link #getRendererType() <em>Renderer Type</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getRendererType() + * @generated + * @ordered + */ + protected String rendererType = RENDERER_TYPE_EDEFAULT; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected ComponentTagDefnImpl() + { + super(); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + protected EClass eStaticClass() + { + return FaceletTaglibPackage.Literals.COMPONENT_TAG_DEFN; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public String getComponentType() + { + return componentType; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void setComponentType(String newComponentType) + { + String oldComponentType = componentType; + componentType = newComponentType; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FaceletTaglibPackage.COMPONENT_TAG_DEFN__COMPONENT_TYPE, oldComponentType, componentType)); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public String getRendererType() + { + return rendererType; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void setRendererType(String newRendererType) + { + String oldRendererType = rendererType; + rendererType = newRendererType; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FaceletTaglibPackage.COMPONENT_TAG_DEFN__RENDERER_TYPE, oldRendererType, rendererType)); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case FaceletTaglibPackage.COMPONENT_TAG_DEFN__COMPONENT_TYPE: + return getComponentType(); + case FaceletTaglibPackage.COMPONENT_TAG_DEFN__RENDERER_TYPE: + return getRendererType(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case FaceletTaglibPackage.COMPONENT_TAG_DEFN__COMPONENT_TYPE: + setComponentType((String)newValue); + return; + case FaceletTaglibPackage.COMPONENT_TAG_DEFN__RENDERER_TYPE: + setRendererType((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.COMPONENT_TAG_DEFN__COMPONENT_TYPE: + setComponentType(COMPONENT_TYPE_EDEFAULT); + return; + case FaceletTaglibPackage.COMPONENT_TAG_DEFN__RENDERER_TYPE: + setRendererType(RENDERER_TYPE_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.COMPONENT_TAG_DEFN__COMPONENT_TYPE: + return COMPONENT_TYPE_EDEFAULT == null ? componentType != null : !COMPONENT_TYPE_EDEFAULT.equals(componentType); + case FaceletTaglibPackage.COMPONENT_TAG_DEFN__RENDERER_TYPE: + return RENDERER_TYPE_EDEFAULT == null ? rendererType != null : !RENDERER_TYPE_EDEFAULT.equals(rendererType); + } + return super.eIsSet(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuffer result = new StringBuffer(super.toString()); + result.append(" (componentType: "); //$NON-NLS-1$ + result.append(componentType); + result.append(", rendererType: "); //$NON-NLS-1$ + result.append(rendererType); + result.append(')'); + return result.toString(); + } + +} //ComponentTagDefnImpl diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/ConverterTagDefnImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/ConverterTagDefnImpl.java new file mode 100644 index 000000000..d5b83610d --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/ConverterTagDefnImpl.java @@ -0,0 +1,180 @@ +/** + * <copyright> + * </copyright> + * + * $Id: ConverterTagDefnImpl.java,v 1.1 2010/03/08 18:49:43 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage; + +/** + * <!-- begin-user-doc --> + * An implementation of the model object '<em><b>Converter Tag Defn</b></em>'. + * <!-- end-user-doc --> + * <p> + * The following features are implemented: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ConverterTagDefnImpl#getConverterId <em>Converter Id</em>}</li> + * </ul> + * </p> + * + * @generated + */ +public class ConverterTagDefnImpl extends HandlerTagDefnImpl implements ConverterTagDefn +{ + /** + * The default value of the '{@link #getConverterId() <em>Converter Id</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getConverterId() + * @generated + * @ordered + */ + protected static final String CONVERTER_ID_EDEFAULT = null; + + /** + * The cached value of the '{@link #getConverterId() <em>Converter Id</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getConverterId() + * @generated + * @ordered + */ + protected String converterId = CONVERTER_ID_EDEFAULT; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected ConverterTagDefnImpl() + { + super(); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + protected EClass eStaticClass() + { + return FaceletTaglibPackage.Literals.CONVERTER_TAG_DEFN; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public String getConverterId() + { + return converterId; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void setConverterId(String newConverterId) + { + String oldConverterId = converterId; + converterId = newConverterId; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FaceletTaglibPackage.CONVERTER_TAG_DEFN__CONVERTER_ID, oldConverterId, converterId)); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case FaceletTaglibPackage.CONVERTER_TAG_DEFN__CONVERTER_ID: + return getConverterId(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case FaceletTaglibPackage.CONVERTER_TAG_DEFN__CONVERTER_ID: + setConverterId((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.CONVERTER_TAG_DEFN__CONVERTER_ID: + setConverterId(CONVERTER_ID_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.CONVERTER_TAG_DEFN__CONVERTER_ID: + return CONVERTER_ID_EDEFAULT == null ? converterId != null : !CONVERTER_ID_EDEFAULT.equals(converterId); + } + return super.eIsSet(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuffer result = new StringBuffer(super.toString()); + result.append(" (converterId: "); //$NON-NLS-1$ + result.append(converterId); + result.append(')'); + return result.toString(); + } + +} //ConverterTagDefnImpl diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletLibraryClassTagLibImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletLibraryClassTagLibImpl.java new file mode 100644 index 000000000..2a77c8812 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletLibraryClassTagLibImpl.java @@ -0,0 +1,180 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FaceletLibraryClassTagLibImpl.java,v 1.1 2010/03/08 18:49:43 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage; + +/** + * <!-- begin-user-doc --> + * An implementation of the model object '<em><b>Facelet Library Class Tag Lib</b></em>'. + * <!-- end-user-doc --> + * <p> + * The following features are implemented: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletLibraryClassTagLibImpl#getLibraryClass <em>Library Class</em>}</li> + * </ul> + * </p> + * + * @generated + */ +public class FaceletLibraryClassTagLibImpl extends FaceletTaglibDefnImpl implements FaceletLibraryClassTagLib +{ + /** + * The default value of the '{@link #getLibraryClass() <em>Library Class</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getLibraryClass() + * @generated + * @ordered + */ + protected static final String LIBRARY_CLASS_EDEFAULT = null; + + /** + * The cached value of the '{@link #getLibraryClass() <em>Library Class</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getLibraryClass() + * @generated + * @ordered + */ + protected String libraryClass = LIBRARY_CLASS_EDEFAULT; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected FaceletLibraryClassTagLibImpl() + { + super(); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + protected EClass eStaticClass() + { + return FaceletTaglibPackage.Literals.FACELET_LIBRARY_CLASS_TAG_LIB; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public String getLibraryClass() + { + return libraryClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void setLibraryClass(String newLibraryClass) + { + String oldLibraryClass = libraryClass; + libraryClass = newLibraryClass; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FaceletTaglibPackage.FACELET_LIBRARY_CLASS_TAG_LIB__LIBRARY_CLASS, oldLibraryClass, libraryClass)); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case FaceletTaglibPackage.FACELET_LIBRARY_CLASS_TAG_LIB__LIBRARY_CLASS: + return getLibraryClass(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case FaceletTaglibPackage.FACELET_LIBRARY_CLASS_TAG_LIB__LIBRARY_CLASS: + setLibraryClass((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.FACELET_LIBRARY_CLASS_TAG_LIB__LIBRARY_CLASS: + setLibraryClass(LIBRARY_CLASS_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.FACELET_LIBRARY_CLASS_TAG_LIB__LIBRARY_CLASS: + return LIBRARY_CLASS_EDEFAULT == null ? libraryClass != null : !LIBRARY_CLASS_EDEFAULT.equals(libraryClass); + } + return super.eIsSet(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuffer result = new StringBuffer(super.toString()); + result.append(" (libraryClass: "); //$NON-NLS-1$ + result.append(libraryClass); + result.append(')'); + return result.toString(); + } + +} //FaceletLibraryClassTagLibImpl diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletTaglibDefnImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletTaglibDefnImpl.java new file mode 100644 index 000000000..9135631be --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletTaglibDefnImpl.java @@ -0,0 +1,48 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FaceletTaglibDefnImpl.java,v 1.1 2010/03/08 18:49:42 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.EObjectImpl; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage; + +/** + * <!-- begin-user-doc --> + * An implementation of the model object '<em><b>Defn</b></em>'. + * <!-- end-user-doc --> + * <p> + * </p> + * + * @generated + */ +public class FaceletTaglibDefnImpl extends EObjectImpl implements FaceletTaglibDefn +{ + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected FaceletTaglibDefnImpl() + { + super(); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + protected EClass eStaticClass() + { + return FaceletTaglibPackage.Literals.FACELET_TAGLIB_DEFN; + } + +} //FaceletTaglibDefnImpl diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletTaglibFactoryImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletTaglibFactoryImpl.java new file mode 100644 index 000000000..518db1946 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletTaglibFactoryImpl.java @@ -0,0 +1,220 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FaceletTaglibFactoryImpl.java,v 1.1 2010/03/08 18:49:43 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; + +import org.eclipse.emf.ecore.impl.EFactoryImpl; + +import org.eclipse.emf.ecore.plugin.EcorePlugin; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.*; + +/** + * <!-- begin-user-doc --> + * An implementation of the model <b>Factory</b>. + * <!-- end-user-doc --> + * @generated + */ +public class FaceletTaglibFactoryImpl extends EFactoryImpl implements FaceletTaglibFactory +{ + /** + * Creates the default factory implementation. + * <!-- begin-user-doc --> + * @return the factory + * <!-- end-user-doc --> + * @generated + */ + public static FaceletTaglibFactory init() + { + try + { + FaceletTaglibFactory theFaceletTaglibFactory = (FaceletTaglibFactory)EPackage.Registry.INSTANCE.getEFactory("http://org.eclipse.jst.jsf.facelet.core/faceletTaglib.ecore"); //$NON-NLS-1$ + if (theFaceletTaglibFactory != null) + { + return theFaceletTaglibFactory; + } + } + catch (Exception exception) + { + EcorePlugin.INSTANCE.log(exception); + } + return new FaceletTaglibFactoryImpl(); + } + + /** + * Creates an instance of the factory. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public FaceletTaglibFactoryImpl() + { + super(); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public EObject create(EClass eClass) + { + switch (eClass.getClassifierID()) + { + case FaceletTaglibPackage.FACELET_LIBRARY_CLASS_TAG_LIB: return createFaceletLibraryClassTagLib(); + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB: return createFaceletXMLDefnTaglib(); + case FaceletTaglibPackage.FACELET_TAGLIB_DEFN: return createFaceletTaglibDefn(); + case FaceletTaglibPackage.COMPONENT_TAG_DEFN: return createComponentTagDefn(); + case FaceletTaglibPackage.VALIDATOR_TAG_DEFN: return createValidatorTagDefn(); + case FaceletTaglibPackage.CONVERTER_TAG_DEFN: return createConverterTagDefn(); + case FaceletTaglibPackage.HANDLER_TAG_DEFN: return createHandlerTagDefn(); + case FaceletTaglibPackage.SOURCE_TAG_DEFN: return createSourceTagDefn(); + case FaceletTaglibPackage.TAG_DEFN: return createTagDefn(); + case FaceletTaglibPackage.FUNCTION_DEFN: return createFunctionDefn(); + default: + throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); //$NON-NLS-1$ //$NON-NLS-2$ + } + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public FaceletLibraryClassTagLib createFaceletLibraryClassTagLib() + { + FaceletLibraryClassTagLibImpl faceletLibraryClassTagLib = new FaceletLibraryClassTagLibImpl(); + return faceletLibraryClassTagLib; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public FaceletXMLDefnTaglib createFaceletXMLDefnTaglib() + { + FaceletXMLDefnTaglibImpl faceletXMLDefnTaglib = new FaceletXMLDefnTaglibImpl(); + return faceletXMLDefnTaglib; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public FaceletTaglibDefn createFaceletTaglibDefn() + { + FaceletTaglibDefnImpl faceletTaglibDefn = new FaceletTaglibDefnImpl(); + return faceletTaglibDefn; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public ComponentTagDefn createComponentTagDefn() + { + ComponentTagDefnImpl componentTagDefn = new ComponentTagDefnImpl(); + return componentTagDefn; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public ValidatorTagDefn createValidatorTagDefn() + { + ValidatorTagDefnImpl validatorTagDefn = new ValidatorTagDefnImpl(); + return validatorTagDefn; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public ConverterTagDefn createConverterTagDefn() + { + ConverterTagDefnImpl converterTagDefn = new ConverterTagDefnImpl(); + return converterTagDefn; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public HandlerTagDefn createHandlerTagDefn() + { + HandlerTagDefnImpl handlerTagDefn = new HandlerTagDefnImpl(); + return handlerTagDefn; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public SourceTagDefn createSourceTagDefn() + { + SourceTagDefnImpl sourceTagDefn = new SourceTagDefnImpl(); + return sourceTagDefn; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public TagDefn createTagDefn() + { + TagDefnImpl tagDefn = new TagDefnImpl(); + return tagDefn; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public FunctionDefn createFunctionDefn() + { + FunctionDefnImpl functionDefn = new FunctionDefnImpl(); + return functionDefn; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public FaceletTaglibPackage getFaceletTaglibPackage() + { + return (FaceletTaglibPackage)getEPackage(); + } + + /** + * <!-- begin-user-doc --> + * @return the package + * <!-- end-user-doc --> + * @deprecated + * @generated + */ + @Deprecated + public static FaceletTaglibPackage getPackage() + { + return FaceletTaglibPackage.eINSTANCE; + } + +} //FaceletTaglibFactoryImpl diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletTaglibPackageImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletTaglibPackageImpl.java new file mode 100644 index 000000000..933b975ae --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletTaglibPackageImpl.java @@ -0,0 +1,559 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FaceletTaglibPackageImpl.java,v 1.1 2010/03/08 18:49:43 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl; + +import org.eclipse.emf.ecore.EAttribute; +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.EReference; + +import org.eclipse.emf.ecore.impl.EPackageImpl; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibFactory; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.HandlerTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.SourceTagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn; + +/** + * <!-- begin-user-doc --> + * An implementation of the model <b>Package</b>. + * <!-- end-user-doc --> + * @generated + */ +public class FaceletTaglibPackageImpl extends EPackageImpl implements FaceletTaglibPackage +{ + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private EClass faceletLibraryClassTagLibEClass = null; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private EClass faceletXMLDefnTaglibEClass = null; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private EClass faceletTaglibDefnEClass = null; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private EClass componentTagDefnEClass = null; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private EClass validatorTagDefnEClass = null; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private EClass converterTagDefnEClass = null; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private EClass handlerTagDefnEClass = null; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private EClass sourceTagDefnEClass = null; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private EClass tagDefnEClass = null; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private EClass functionDefnEClass = null; + + /** + * Creates an instance of the model <b>Package</b>, registered with + * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package + * package URI value. + * <p>Note: the correct way to create the package is via the static + * factory method {@link #init init()}, which also performs + * initialization of the package, or returns the registered package, + * if one already exists. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see org.eclipse.emf.ecore.EPackage.Registry + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage#eNS_URI + * @see #init() + * @generated + */ + private FaceletTaglibPackageImpl() + { + super(eNS_URI, FaceletTaglibFactory.eINSTANCE); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private static boolean isInited = false; + + /** + * Creates, registers, and initializes the <b>Package</b> for this + * model, and for any others upon which it depends. Simple + * dependencies are satisfied by calling this method on all + * dependent packages before doing anything else. This method drives + * initialization for interdependent packages directly, in parallel + * with this package, itself. + * <p>Of this package and its interdependencies, all packages which + * have not yet been registered by their URI values are first created + * and registered. The packages are then initialized in two steps: + * meta-model objects for all of the packages are created before any + * are initialized, since one package's meta-model objects may refer to + * those of another. + * <p>Invocation of this method will not affect any packages that have + * already been initialized. + * <!-- begin-user-doc --> + * @return the package + * <!-- end-user-doc --> + * @see #eNS_URI + * @see #createPackageContents() + * @see #initializePackageContents() + * @generated + */ + public static FaceletTaglibPackage init() + { + if (isInited) return (FaceletTaglibPackage)EPackage.Registry.INSTANCE.getEPackage(FaceletTaglibPackage.eNS_URI); + + // Obtain or create and register package + FaceletTaglibPackageImpl theFaceletTaglibPackage = (FaceletTaglibPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(eNS_URI) instanceof FaceletTaglibPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(eNS_URI) : new FaceletTaglibPackageImpl()); + + isInited = true; + + // Create package meta-data objects + theFaceletTaglibPackage.createPackageContents(); + + // Initialize created meta-data + theFaceletTaglibPackage.initializePackageContents(); + + // Mark meta-data to indicate it can't be changed + theFaceletTaglibPackage.freeze(); + + return theFaceletTaglibPackage; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EClass getFaceletLibraryClassTagLib() + { + return faceletLibraryClassTagLibEClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EAttribute getFaceletLibraryClassTagLib_LibraryClass() + { + return (EAttribute)faceletLibraryClassTagLibEClass.getEStructuralFeatures().get(0); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EClass getFaceletXMLDefnTaglib() + { + return faceletXMLDefnTaglibEClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EAttribute getFaceletXMLDefnTaglib_Namespace() + { + return (EAttribute)faceletXMLDefnTaglibEClass.getEStructuralFeatures().get(0); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EReference getFaceletXMLDefnTaglib_Tags() + { + return (EReference)faceletXMLDefnTaglibEClass.getEStructuralFeatures().get(1); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EReference getFaceletXMLDefnTaglib_Functions() + { + return (EReference)faceletXMLDefnTaglibEClass.getEStructuralFeatures().get(2); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EClass getFaceletTaglibDefn() + { + return faceletTaglibDefnEClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EClass getComponentTagDefn() + { + return componentTagDefnEClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EAttribute getComponentTagDefn_ComponentType() + { + return (EAttribute)componentTagDefnEClass.getEStructuralFeatures().get(0); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EAttribute getComponentTagDefn_RendererType() + { + return (EAttribute)componentTagDefnEClass.getEStructuralFeatures().get(1); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EClass getValidatorTagDefn() + { + return validatorTagDefnEClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EAttribute getValidatorTagDefn_ValidatorId() + { + return (EAttribute)validatorTagDefnEClass.getEStructuralFeatures().get(0); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EClass getConverterTagDefn() + { + return converterTagDefnEClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EAttribute getConverterTagDefn_ConverterId() + { + return (EAttribute)converterTagDefnEClass.getEStructuralFeatures().get(0); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EClass getHandlerTagDefn() + { + return handlerTagDefnEClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EAttribute getHandlerTagDefn_HandlerClass() + { + return (EAttribute)handlerTagDefnEClass.getEStructuralFeatures().get(0); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EClass getSourceTagDefn() + { + return sourceTagDefnEClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EAttribute getSourceTagDefn_Source() + { + return (EAttribute)sourceTagDefnEClass.getEStructuralFeatures().get(0); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EClass getTagDefn() + { + return tagDefnEClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EAttribute getTagDefn_Name() + { + return (EAttribute)tagDefnEClass.getEStructuralFeatures().get(0); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EClass getFunctionDefn() + { + return functionDefnEClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EAttribute getFunctionDefn_FunctionName() + { + return (EAttribute)functionDefnEClass.getEStructuralFeatures().get(0); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EAttribute getFunctionDefn_FunctionClass() + { + return (EAttribute)functionDefnEClass.getEStructuralFeatures().get(1); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EAttribute getFunctionDefn_FunctionSignature() + { + return (EAttribute)functionDefnEClass.getEStructuralFeatures().get(2); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public FaceletTaglibFactory getFaceletTaglibFactory() + { + return (FaceletTaglibFactory)getEFactoryInstance(); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private boolean isCreated = false; + + /** + * Creates the meta-model objects for the package. This method is + * guarded to have no affect on any invocation but its first. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void createPackageContents() + { + if (isCreated) return; + isCreated = true; + + // Create classes and their features + faceletLibraryClassTagLibEClass = createEClass(FACELET_LIBRARY_CLASS_TAG_LIB); + createEAttribute(faceletLibraryClassTagLibEClass, FACELET_LIBRARY_CLASS_TAG_LIB__LIBRARY_CLASS); + + faceletXMLDefnTaglibEClass = createEClass(FACELET_XML_DEFN_TAGLIB); + createEAttribute(faceletXMLDefnTaglibEClass, FACELET_XML_DEFN_TAGLIB__NAMESPACE); + createEReference(faceletXMLDefnTaglibEClass, FACELET_XML_DEFN_TAGLIB__TAGS); + createEReference(faceletXMLDefnTaglibEClass, FACELET_XML_DEFN_TAGLIB__FUNCTIONS); + + faceletTaglibDefnEClass = createEClass(FACELET_TAGLIB_DEFN); + + componentTagDefnEClass = createEClass(COMPONENT_TAG_DEFN); + createEAttribute(componentTagDefnEClass, COMPONENT_TAG_DEFN__COMPONENT_TYPE); + createEAttribute(componentTagDefnEClass, COMPONENT_TAG_DEFN__RENDERER_TYPE); + + validatorTagDefnEClass = createEClass(VALIDATOR_TAG_DEFN); + createEAttribute(validatorTagDefnEClass, VALIDATOR_TAG_DEFN__VALIDATOR_ID); + + converterTagDefnEClass = createEClass(CONVERTER_TAG_DEFN); + createEAttribute(converterTagDefnEClass, CONVERTER_TAG_DEFN__CONVERTER_ID); + + handlerTagDefnEClass = createEClass(HANDLER_TAG_DEFN); + createEAttribute(handlerTagDefnEClass, HANDLER_TAG_DEFN__HANDLER_CLASS); + + sourceTagDefnEClass = createEClass(SOURCE_TAG_DEFN); + createEAttribute(sourceTagDefnEClass, SOURCE_TAG_DEFN__SOURCE); + + tagDefnEClass = createEClass(TAG_DEFN); + createEAttribute(tagDefnEClass, TAG_DEFN__NAME); + + functionDefnEClass = createEClass(FUNCTION_DEFN); + createEAttribute(functionDefnEClass, FUNCTION_DEFN__FUNCTION_NAME); + createEAttribute(functionDefnEClass, FUNCTION_DEFN__FUNCTION_CLASS); + createEAttribute(functionDefnEClass, FUNCTION_DEFN__FUNCTION_SIGNATURE); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + private boolean isInitialized = false; + + /** + * Complete the initialization of the package and its meta-model. This + * method is guarded to have no affect on any invocation but its first. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void initializePackageContents() + { + if (isInitialized) return; + isInitialized = true; + + // Initialize package + setName(eNAME); + setNsPrefix(eNS_PREFIX); + setNsURI(eNS_URI); + + // Create type parameters + + // Set bounds for type parameters + + // Add supertypes to classes + faceletLibraryClassTagLibEClass.getESuperTypes().add(this.getFaceletTaglibDefn()); + faceletXMLDefnTaglibEClass.getESuperTypes().add(this.getFaceletTaglibDefn()); + componentTagDefnEClass.getESuperTypes().add(this.getHandlerTagDefn()); + validatorTagDefnEClass.getESuperTypes().add(this.getHandlerTagDefn()); + converterTagDefnEClass.getESuperTypes().add(this.getHandlerTagDefn()); + handlerTagDefnEClass.getESuperTypes().add(this.getTagDefn()); + sourceTagDefnEClass.getESuperTypes().add(this.getTagDefn()); + + // Initialize classes and features; add operations and parameters + initEClass(faceletLibraryClassTagLibEClass, FaceletLibraryClassTagLib.class, "FaceletLibraryClassTagLib", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$ + initEAttribute(getFaceletLibraryClassTagLib_LibraryClass(), ecorePackage.getEString(), "libraryClass", null, 0, 1, FaceletLibraryClassTagLib.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + + initEClass(faceletXMLDefnTaglibEClass, FaceletXMLDefnTaglib.class, "FaceletXMLDefnTaglib", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$ + initEAttribute(getFaceletXMLDefnTaglib_Namespace(), ecorePackage.getEString(), "namespace", null, 0, 1, FaceletXMLDefnTaglib.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + initEReference(getFaceletXMLDefnTaglib_Tags(), this.getTagDefn(), null, "tags", null, 0, -1, FaceletXMLDefnTaglib.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + initEReference(getFaceletXMLDefnTaglib_Functions(), this.getFunctionDefn(), null, "functions", null, 0, -1, FaceletXMLDefnTaglib.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + + initEClass(faceletTaglibDefnEClass, FaceletTaglibDefn.class, "FaceletTaglibDefn", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$ + + initEClass(componentTagDefnEClass, ComponentTagDefn.class, "ComponentTagDefn", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$ + initEAttribute(getComponentTagDefn_ComponentType(), ecorePackage.getEString(), "componentType", null, 0, 1, ComponentTagDefn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + initEAttribute(getComponentTagDefn_RendererType(), ecorePackage.getEString(), "rendererType", null, 0, 1, ComponentTagDefn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + + initEClass(validatorTagDefnEClass, ValidatorTagDefn.class, "ValidatorTagDefn", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$ + initEAttribute(getValidatorTagDefn_ValidatorId(), ecorePackage.getEString(), "validatorId", null, 0, 1, ValidatorTagDefn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + + initEClass(converterTagDefnEClass, ConverterTagDefn.class, "ConverterTagDefn", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$ + initEAttribute(getConverterTagDefn_ConverterId(), ecorePackage.getEString(), "converterId", null, 0, 1, ConverterTagDefn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + + initEClass(handlerTagDefnEClass, HandlerTagDefn.class, "HandlerTagDefn", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$ + initEAttribute(getHandlerTagDefn_HandlerClass(), ecorePackage.getEString(), "handlerClass", null, 0, 1, HandlerTagDefn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + + initEClass(sourceTagDefnEClass, SourceTagDefn.class, "SourceTagDefn", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$ + initEAttribute(getSourceTagDefn_Source(), ecorePackage.getEString(), "source", null, 0, 1, SourceTagDefn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + + initEClass(tagDefnEClass, TagDefn.class, "TagDefn", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$ + initEAttribute(getTagDefn_Name(), ecorePackage.getEString(), "name", null, 0, 1, TagDefn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + + initEClass(functionDefnEClass, FunctionDefn.class, "FunctionDefn", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$ + initEAttribute(getFunctionDefn_FunctionName(), ecorePackage.getEString(), "functionName", null, 0, 1, FunctionDefn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + initEAttribute(getFunctionDefn_FunctionClass(), ecorePackage.getEString(), "functionClass", null, 0, 1, FunctionDefn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + initEAttribute(getFunctionDefn_FunctionSignature(), ecorePackage.getEString(), "functionSignature", null, 0, 1, FunctionDefn.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$ + + // Create resource + createResource(eNS_URI); + } + +} //FaceletTaglibPackageImpl diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletXMLDefnTaglibImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletXMLDefnTaglibImpl.java new file mode 100644 index 000000000..7be7d6467 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FaceletXMLDefnTaglibImpl.java @@ -0,0 +1,261 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FaceletXMLDefnTaglibImpl.java,v 1.1 2010/03/08 18:49:42 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.emf.ecore.util.EObjectResolvingEList; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn; + +/** + * <!-- begin-user-doc --> + * An implementation of the model object '<em><b>Facelet XML Defn Taglib</b></em>'. + * <!-- end-user-doc --> + * <p> + * The following features are implemented: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletXMLDefnTaglibImpl#getNamespace <em>Namespace</em>}</li> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletXMLDefnTaglibImpl#getTags <em>Tags</em>}</li> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FaceletXMLDefnTaglibImpl#getFunctions <em>Functions</em>}</li> + * </ul> + * </p> + * + * @generated + */ +public class FaceletXMLDefnTaglibImpl extends FaceletTaglibDefnImpl implements FaceletXMLDefnTaglib +{ + /** + * The default value of the '{@link #getNamespace() <em>Namespace</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getNamespace() + * @generated + * @ordered + */ + protected static final String NAMESPACE_EDEFAULT = null; + + /** + * The cached value of the '{@link #getNamespace() <em>Namespace</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getNamespace() + * @generated + * @ordered + */ + protected String namespace = NAMESPACE_EDEFAULT; + + /** + * The cached value of the '{@link #getTags() <em>Tags</em>}' reference list. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getTags() + * @generated + * @ordered + */ + protected EList<TagDefn> tags; + + /** + * The cached value of the '{@link #getFunctions() <em>Functions</em>}' reference list. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getFunctions() + * @generated + * @ordered + */ + protected EList<FunctionDefn> functions; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected FaceletXMLDefnTaglibImpl() + { + super(); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + protected EClass eStaticClass() + { + return FaceletTaglibPackage.Literals.FACELET_XML_DEFN_TAGLIB; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public String getNamespace() + { + return namespace; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void setNamespace(String newNamespace) + { + String oldNamespace = namespace; + namespace = newNamespace; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__NAMESPACE, oldNamespace, namespace)); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EList<TagDefn> getTags() + { + if (tags == null) + { + tags = new EObjectResolvingEList<TagDefn>(TagDefn.class, this, FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__TAGS); + } + return tags; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public EList<FunctionDefn> getFunctions() + { + if (functions == null) + { + functions = new EObjectResolvingEList<FunctionDefn>(FunctionDefn.class, this, FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__FUNCTIONS); + } + return functions; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__NAMESPACE: + return getNamespace(); + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__TAGS: + return getTags(); + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__FUNCTIONS: + return getFunctions(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__NAMESPACE: + setNamespace((String)newValue); + return; + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__TAGS: + getTags().clear(); + getTags().addAll((Collection<? extends TagDefn>)newValue); + return; + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__FUNCTIONS: + getFunctions().clear(); + getFunctions().addAll((Collection<? extends FunctionDefn>)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__NAMESPACE: + setNamespace(NAMESPACE_EDEFAULT); + return; + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__TAGS: + getTags().clear(); + return; + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__FUNCTIONS: + getFunctions().clear(); + return; + } + super.eUnset(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__NAMESPACE: + return NAMESPACE_EDEFAULT == null ? namespace != null : !NAMESPACE_EDEFAULT.equals(namespace); + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__TAGS: + return tags != null && !tags.isEmpty(); + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB__FUNCTIONS: + return functions != null && !functions.isEmpty(); + } + return super.eIsSet(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuffer result = new StringBuffer(super.toString()); + result.append(" (namespace: "); //$NON-NLS-1$ + result.append(namespace); + result.append(')'); + return result.toString(); + } + +} //FaceletXMLDefnTaglibImpl diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FunctionDefnImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FunctionDefnImpl.java new file mode 100644 index 000000000..1c623f263 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/FunctionDefnImpl.java @@ -0,0 +1,293 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FunctionDefnImpl.java,v 1.1 2010/03/08 18:49:43 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.EObjectImpl; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn; + +/** + * <!-- begin-user-doc --> + * An implementation of the model object '<em><b>Function Defn</b></em>'. + * <!-- end-user-doc --> + * <p> + * The following features are implemented: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FunctionDefnImpl#getFunctionName <em>Function Name</em>}</li> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FunctionDefnImpl#getFunctionClass <em>Function Class</em>}</li> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.FunctionDefnImpl#getFunctionSignature <em>Function Signature</em>}</li> + * </ul> + * </p> + * + * @generated + */ +public class FunctionDefnImpl extends EObjectImpl implements FunctionDefn +{ + /** + * The default value of the '{@link #getFunctionName() <em>Function Name</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getFunctionName() + * @generated + * @ordered + */ + protected static final String FUNCTION_NAME_EDEFAULT = null; + + /** + * The cached value of the '{@link #getFunctionName() <em>Function Name</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getFunctionName() + * @generated + * @ordered + */ + protected String functionName = FUNCTION_NAME_EDEFAULT; + + /** + * The default value of the '{@link #getFunctionClass() <em>Function Class</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getFunctionClass() + * @generated + * @ordered + */ + protected static final String FUNCTION_CLASS_EDEFAULT = null; + + /** + * The cached value of the '{@link #getFunctionClass() <em>Function Class</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getFunctionClass() + * @generated + * @ordered + */ + protected String functionClass = FUNCTION_CLASS_EDEFAULT; + + /** + * The default value of the '{@link #getFunctionSignature() <em>Function Signature</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getFunctionSignature() + * @generated + * @ordered + */ + protected static final String FUNCTION_SIGNATURE_EDEFAULT = null; + + /** + * The cached value of the '{@link #getFunctionSignature() <em>Function Signature</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getFunctionSignature() + * @generated + * @ordered + */ + protected String functionSignature = FUNCTION_SIGNATURE_EDEFAULT; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected FunctionDefnImpl() + { + super(); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + protected EClass eStaticClass() + { + return FaceletTaglibPackage.Literals.FUNCTION_DEFN; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public String getFunctionName() + { + return functionName; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void setFunctionName(String newFunctionName) + { + String oldFunctionName = functionName; + functionName = newFunctionName; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_NAME, oldFunctionName, functionName)); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public String getFunctionClass() + { + return functionClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void setFunctionClass(String newFunctionClass) + { + String oldFunctionClass = functionClass; + functionClass = newFunctionClass; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_CLASS, oldFunctionClass, functionClass)); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public String getFunctionSignature() + { + return functionSignature; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void setFunctionSignature(String newFunctionSignature) + { + String oldFunctionSignature = functionSignature; + functionSignature = newFunctionSignature; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_SIGNATURE, oldFunctionSignature, functionSignature)); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_NAME: + return getFunctionName(); + case FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_CLASS: + return getFunctionClass(); + case FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_SIGNATURE: + return getFunctionSignature(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_NAME: + setFunctionName((String)newValue); + return; + case FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_CLASS: + setFunctionClass((String)newValue); + return; + case FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_SIGNATURE: + setFunctionSignature((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_NAME: + setFunctionName(FUNCTION_NAME_EDEFAULT); + return; + case FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_CLASS: + setFunctionClass(FUNCTION_CLASS_EDEFAULT); + return; + case FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_SIGNATURE: + setFunctionSignature(FUNCTION_SIGNATURE_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_NAME: + return FUNCTION_NAME_EDEFAULT == null ? functionName != null : !FUNCTION_NAME_EDEFAULT.equals(functionName); + case FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_CLASS: + return FUNCTION_CLASS_EDEFAULT == null ? functionClass != null : !FUNCTION_CLASS_EDEFAULT.equals(functionClass); + case FaceletTaglibPackage.FUNCTION_DEFN__FUNCTION_SIGNATURE: + return FUNCTION_SIGNATURE_EDEFAULT == null ? functionSignature != null : !FUNCTION_SIGNATURE_EDEFAULT.equals(functionSignature); + } + return super.eIsSet(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuffer result = new StringBuffer(super.toString()); + result.append(" (functionName: "); //$NON-NLS-1$ + result.append(functionName); + result.append(", functionClass: "); //$NON-NLS-1$ + result.append(functionClass); + result.append(", functionSignature: "); //$NON-NLS-1$ + result.append(functionSignature); + result.append(')'); + return result.toString(); + } + +} //FunctionDefnImpl diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/HandlerTagDefnImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/HandlerTagDefnImpl.java new file mode 100644 index 000000000..7d3e2850e --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/HandlerTagDefnImpl.java @@ -0,0 +1,180 @@ +/** + * <copyright> + * </copyright> + * + * $Id: HandlerTagDefnImpl.java,v 1.1 2010/03/08 18:49:43 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.HandlerTagDefn; + +/** + * <!-- begin-user-doc --> + * An implementation of the model object '<em><b>Handler Tag Defn</b></em>'. + * <!-- end-user-doc --> + * <p> + * The following features are implemented: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.HandlerTagDefnImpl#getHandlerClass <em>Handler Class</em>}</li> + * </ul> + * </p> + * + * @generated + */ +public class HandlerTagDefnImpl extends TagDefnImpl implements HandlerTagDefn +{ + /** + * The default value of the '{@link #getHandlerClass() <em>Handler Class</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getHandlerClass() + * @generated + * @ordered + */ + protected static final String HANDLER_CLASS_EDEFAULT = null; + + /** + * The cached value of the '{@link #getHandlerClass() <em>Handler Class</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getHandlerClass() + * @generated + * @ordered + */ + protected String handlerClass = HANDLER_CLASS_EDEFAULT; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected HandlerTagDefnImpl() + { + super(); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + protected EClass eStaticClass() + { + return FaceletTaglibPackage.Literals.HANDLER_TAG_DEFN; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public String getHandlerClass() + { + return handlerClass; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void setHandlerClass(String newHandlerClass) + { + String oldHandlerClass = handlerClass; + handlerClass = newHandlerClass; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FaceletTaglibPackage.HANDLER_TAG_DEFN__HANDLER_CLASS, oldHandlerClass, handlerClass)); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case FaceletTaglibPackage.HANDLER_TAG_DEFN__HANDLER_CLASS: + return getHandlerClass(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case FaceletTaglibPackage.HANDLER_TAG_DEFN__HANDLER_CLASS: + setHandlerClass((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.HANDLER_TAG_DEFN__HANDLER_CLASS: + setHandlerClass(HANDLER_CLASS_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.HANDLER_TAG_DEFN__HANDLER_CLASS: + return HANDLER_CLASS_EDEFAULT == null ? handlerClass != null : !HANDLER_CLASS_EDEFAULT.equals(handlerClass); + } + return super.eIsSet(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuffer result = new StringBuffer(super.toString()); + result.append(" (handlerClass: "); //$NON-NLS-1$ + result.append(handlerClass); + result.append(')'); + return result.toString(); + } + +} //HandlerTagDefnImpl diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/SourceTagDefnImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/SourceTagDefnImpl.java new file mode 100644 index 000000000..f3482ee60 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/SourceTagDefnImpl.java @@ -0,0 +1,180 @@ +/** + * <copyright> + * </copyright> + * + * $Id: SourceTagDefnImpl.java,v 1.1 2010/03/08 18:49:43 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.SourceTagDefn; + +/** + * <!-- begin-user-doc --> + * An implementation of the model object '<em><b>Source Tag Defn</b></em>'. + * <!-- end-user-doc --> + * <p> + * The following features are implemented: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.SourceTagDefnImpl#getSource <em>Source</em>}</li> + * </ul> + * </p> + * + * @generated + */ +public class SourceTagDefnImpl extends TagDefnImpl implements SourceTagDefn +{ + /** + * The default value of the '{@link #getSource() <em>Source</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getSource() + * @generated + * @ordered + */ + protected static final String SOURCE_EDEFAULT = null; + + /** + * The cached value of the '{@link #getSource() <em>Source</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getSource() + * @generated + * @ordered + */ + protected String source = SOURCE_EDEFAULT; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected SourceTagDefnImpl() + { + super(); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + protected EClass eStaticClass() + { + return FaceletTaglibPackage.Literals.SOURCE_TAG_DEFN; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public String getSource() + { + return source; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void setSource(String newSource) + { + String oldSource = source; + source = newSource; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FaceletTaglibPackage.SOURCE_TAG_DEFN__SOURCE, oldSource, source)); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case FaceletTaglibPackage.SOURCE_TAG_DEFN__SOURCE: + return getSource(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case FaceletTaglibPackage.SOURCE_TAG_DEFN__SOURCE: + setSource((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.SOURCE_TAG_DEFN__SOURCE: + setSource(SOURCE_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.SOURCE_TAG_DEFN__SOURCE: + return SOURCE_EDEFAULT == null ? source != null : !SOURCE_EDEFAULT.equals(source); + } + return super.eIsSet(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuffer result = new StringBuffer(super.toString()); + result.append(" (source: "); //$NON-NLS-1$ + result.append(source); + result.append(')'); + return result.toString(); + } + +} //SourceTagDefnImpl diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/TagDefnImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/TagDefnImpl.java new file mode 100644 index 000000000..f9a8a2b3f --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/TagDefnImpl.java @@ -0,0 +1,181 @@ +/** + * <copyright> + * </copyright> + * + * $Id: TagDefnImpl.java,v 1.1 2010/03/08 18:49:43 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.EObjectImpl; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn; + +/** + * <!-- begin-user-doc --> + * An implementation of the model object '<em><b>Tag Defn</b></em>'. + * <!-- end-user-doc --> + * <p> + * The following features are implemented: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.TagDefnImpl#getName <em>Name</em>}</li> + * </ul> + * </p> + * + * @generated + */ +public class TagDefnImpl extends EObjectImpl implements TagDefn +{ + /** + * The default value of the '{@link #getName() <em>Name</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getName() + * @generated + * @ordered + */ + protected static final String NAME_EDEFAULT = null; + + /** + * The cached value of the '{@link #getName() <em>Name</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getName() + * @generated + * @ordered + */ + protected String name = NAME_EDEFAULT; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected TagDefnImpl() + { + super(); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + protected EClass eStaticClass() + { + return FaceletTaglibPackage.Literals.TAG_DEFN; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public String getName() + { + return name; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void setName(String newName) + { + String oldName = name; + name = newName; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FaceletTaglibPackage.TAG_DEFN__NAME, oldName, name)); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case FaceletTaglibPackage.TAG_DEFN__NAME: + return getName(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case FaceletTaglibPackage.TAG_DEFN__NAME: + setName((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.TAG_DEFN__NAME: + setName(NAME_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.TAG_DEFN__NAME: + return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); + } + return super.eIsSet(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuffer result = new StringBuffer(super.toString()); + result.append(" (name: "); //$NON-NLS-1$ + result.append(name); + result.append(')'); + return result.toString(); + } + +} //TagDefnImpl diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/ValidatorTagDefnImpl.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/ValidatorTagDefnImpl.java new file mode 100644 index 000000000..b02e703e9 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/impl/ValidatorTagDefnImpl.java @@ -0,0 +1,180 @@ +/** + * <copyright> + * </copyright> + * + * $Id: ValidatorTagDefnImpl.java,v 1.1 2010/03/08 18:49:43 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage; +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn; + +/** + * <!-- begin-user-doc --> + * An implementation of the model object '<em><b>Validator Tag Defn</b></em>'. + * <!-- end-user-doc --> + * <p> + * The following features are implemented: + * <ul> + * <li>{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.impl.ValidatorTagDefnImpl#getValidatorId <em>Validator Id</em>}</li> + * </ul> + * </p> + * + * @generated + */ +public class ValidatorTagDefnImpl extends HandlerTagDefnImpl implements ValidatorTagDefn +{ + /** + * The default value of the '{@link #getValidatorId() <em>Validator Id</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getValidatorId() + * @generated + * @ordered + */ + protected static final String VALIDATOR_ID_EDEFAULT = null; + + /** + * The cached value of the '{@link #getValidatorId() <em>Validator Id</em>}' attribute. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @see #getValidatorId() + * @generated + * @ordered + */ + protected String validatorId = VALIDATOR_ID_EDEFAULT; + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected ValidatorTagDefnImpl() + { + super(); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + protected EClass eStaticClass() + { + return FaceletTaglibPackage.Literals.VALIDATOR_TAG_DEFN; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public String getValidatorId() + { + return validatorId; + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public void setValidatorId(String newValidatorId) + { + String oldValidatorId = validatorId; + validatorId = newValidatorId; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, FaceletTaglibPackage.VALIDATOR_TAG_DEFN__VALIDATOR_ID, oldValidatorId, validatorId)); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case FaceletTaglibPackage.VALIDATOR_TAG_DEFN__VALIDATOR_ID: + return getValidatorId(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case FaceletTaglibPackage.VALIDATOR_TAG_DEFN__VALIDATOR_ID: + setValidatorId((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.VALIDATOR_TAG_DEFN__VALIDATOR_ID: + setValidatorId(VALIDATOR_ID_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case FaceletTaglibPackage.VALIDATOR_TAG_DEFN__VALIDATOR_ID: + return VALIDATOR_ID_EDEFAULT == null ? validatorId != null : !VALIDATOR_ID_EDEFAULT.equals(validatorId); + } + return super.eIsSet(featureID); + } + + /** + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuffer result = new StringBuffer(super.toString()); + result.append(" (validatorId: "); //$NON-NLS-1$ + result.append(validatorId); + result.append(')'); + return result.toString(); + } + +} //ValidatorTagDefnImpl diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/util/FaceletTaglibAdapterFactory.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/util/FaceletTaglibAdapterFactory.java new file mode 100644 index 000000000..5b4656c56 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/util/FaceletTaglibAdapterFactory.java @@ -0,0 +1,316 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FaceletTaglibAdapterFactory.java,v 1.1 2010/03/08 18:49:43 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.util; + +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notifier; + +import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl; + +import org.eclipse.emf.ecore.EObject; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.*; + +/** + * <!-- begin-user-doc --> + * The <b>Adapter Factory</b> for the model. + * It provides an adapter <code>createXXX</code> method for each class of the model. + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage + * @generated + */ +public class FaceletTaglibAdapterFactory extends AdapterFactoryImpl +{ + /** + * The cached model package. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected static FaceletTaglibPackage modelPackage; + + /** + * Creates an instance of the adapter factory. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public FaceletTaglibAdapterFactory() + { + if (modelPackage == null) + { + modelPackage = FaceletTaglibPackage.eINSTANCE; + } + } + + /** + * Returns whether this factory is applicable for the type of the object. + * <!-- begin-user-doc --> + * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model. + * <!-- end-user-doc --> + * @return whether this factory is applicable for the type of the object. + * @generated + */ + @Override + public boolean isFactoryForType(Object object) + { + if (object == modelPackage) + { + return true; + } + if (object instanceof EObject) + { + return ((EObject)object).eClass().getEPackage() == modelPackage; + } + return false; + } + + /** + * The switch that delegates to the <code>createXXX</code> methods. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected FaceletTaglibSwitch<Adapter> modelSwitch = + new FaceletTaglibSwitch<Adapter>() + { + @Override + public Adapter caseFaceletLibraryClassTagLib(FaceletLibraryClassTagLib object) + { + return createFaceletLibraryClassTagLibAdapter(); + } + @Override + public Adapter caseFaceletXMLDefnTaglib(FaceletXMLDefnTaglib object) + { + return createFaceletXMLDefnTaglibAdapter(); + } + @Override + public Adapter caseFaceletTaglibDefn(FaceletTaglibDefn object) + { + return createFaceletTaglibDefnAdapter(); + } + @Override + public Adapter caseComponentTagDefn(ComponentTagDefn object) + { + return createComponentTagDefnAdapter(); + } + @Override + public Adapter caseValidatorTagDefn(ValidatorTagDefn object) + { + return createValidatorTagDefnAdapter(); + } + @Override + public Adapter caseConverterTagDefn(ConverterTagDefn object) + { + return createConverterTagDefnAdapter(); + } + @Override + public Adapter caseHandlerTagDefn(HandlerTagDefn object) + { + return createHandlerTagDefnAdapter(); + } + @Override + public Adapter caseSourceTagDefn(SourceTagDefn object) + { + return createSourceTagDefnAdapter(); + } + @Override + public Adapter caseTagDefn(TagDefn object) + { + return createTagDefnAdapter(); + } + @Override + public Adapter caseFunctionDefn(FunctionDefn object) + { + return createFunctionDefnAdapter(); + } + @Override + public Adapter defaultCase(EObject object) + { + return createEObjectAdapter(); + } + }; + + /** + * Creates an adapter for the <code>target</code>. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @param target the object to adapt. + * @return the adapter for the <code>target</code>. + * @generated + */ + @Override + public Adapter createAdapter(Notifier target) + { + return modelSwitch.doSwitch((EObject)target); + } + + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib <em>Facelet Library Class Tag Lib</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * <!-- end-user-doc --> + * @return the new adapter. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletLibraryClassTagLib + * @generated + */ + public Adapter createFaceletLibraryClassTagLibAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib <em>Facelet XML Defn Taglib</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * <!-- end-user-doc --> + * @return the new adapter. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletXMLDefnTaglib + * @generated + */ + public Adapter createFaceletXMLDefnTaglibAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibDefn <em>Defn</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * <!-- end-user-doc --> + * @return the new adapter. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibDefn + * @generated + */ + public Adapter createFaceletTaglibDefnAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn <em>Component Tag Defn</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * <!-- end-user-doc --> + * @return the new adapter. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ComponentTagDefn + * @generated + */ + public Adapter createComponentTagDefnAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn <em>Validator Tag Defn</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * <!-- end-user-doc --> + * @return the new adapter. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ValidatorTagDefn + * @generated + */ + public Adapter createValidatorTagDefnAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn <em>Converter Tag Defn</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * <!-- end-user-doc --> + * @return the new adapter. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.ConverterTagDefn + * @generated + */ + public Adapter createConverterTagDefnAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.HandlerTagDefn <em>Handler Tag Defn</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * <!-- end-user-doc --> + * @return the new adapter. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.HandlerTagDefn + * @generated + */ + public Adapter createHandlerTagDefnAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.SourceTagDefn <em>Source Tag Defn</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * <!-- end-user-doc --> + * @return the new adapter. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.SourceTagDefn + * @generated + */ + public Adapter createSourceTagDefnAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn <em>Tag Defn</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * <!-- end-user-doc --> + * @return the new adapter. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.TagDefn + * @generated + */ + public Adapter createTagDefnAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn <em>Function Defn</em>}'. + * <!-- begin-user-doc --> + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * <!-- end-user-doc --> + * @return the new adapter. + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FunctionDefn + * @generated + */ + public Adapter createFunctionDefnAdapter() + { + return null; + } + + /** + * Creates a new adapter for the default case. + * <!-- begin-user-doc --> + * This default implementation returns null. + * <!-- end-user-doc --> + * @return the new adapter. + * @generated + */ + public Adapter createEObjectAdapter() + { + return null; + } + +} //FaceletTaglibAdapterFactory diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/util/FaceletTaglibSwitch.java b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/util/FaceletTaglibSwitch.java new file mode 100644 index 000000000..ebbf56042 --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/faceletTaglib/util/FaceletTaglibSwitch.java @@ -0,0 +1,362 @@ +/** + * <copyright> + * </copyright> + * + * $Id: FaceletTaglibSwitch.java,v 1.1 2010/03/08 18:49:43 cbateman Exp $ + */ +package org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.util; + +import java.util.List; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EObject; + +import org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.*; + +/** + * <!-- begin-user-doc --> + * The <b>Switch</b> for the model's inheritance hierarchy. + * It supports the call {@link #doSwitch(EObject) doSwitch(object)} + * to invoke the <code>caseXXX</code> method for each class of the model, + * starting with the actual class of the object + * and proceeding up the inheritance hierarchy + * until a non-null result is returned, + * which is the result of the switch. + * @param <T> + * <!-- end-user-doc --> + * @see org.eclipse.jst.jsf.facelet.core.internal.registry.taglib.faceletTaglib.FaceletTaglibPackage + * @generated + */ +public class FaceletTaglibSwitch<T> +{ + /** + * The cached model package + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + protected static FaceletTaglibPackage modelPackage; + + /** + * Creates an instance of the switch. + * <!-- begin-user-doc --> + * <!-- end-user-doc --> + * @generated + */ + public FaceletTaglibSwitch() + { + if (modelPackage == null) + { + modelPackage = FaceletTaglibPackage.eINSTANCE; + } + } + + /** + * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result. + * <!-- begin-user-doc --> + * @param theEObject + * <!-- end-user-doc --> + * @return the first non-null result returned by a <code>caseXXX</code> call. + * @generated + */ + public T doSwitch(EObject theEObject) + { + return doSwitch(theEObject.eClass(), theEObject); + } + + /** + * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result. + * <!-- begin-user-doc --> + * @param theEClass + * @param theEObject + * <!-- end-user-doc --> + * @return the first non-null result returned by a <code>caseXXX</code> call. + * @generated + */ + protected T doSwitch(EClass theEClass, EObject theEObject) + { + if (theEClass.eContainer() == modelPackage) + { + return doSwitch(theEClass.getClassifierID(), theEObject); + } + List<EClass> eSuperTypes = theEClass.getESuperTypes(); + return + eSuperTypes.isEmpty() ? + defaultCase(theEObject) : + doSwitch(eSuperTypes.get(0), theEObject); + } + + /** + * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result. + * <!-- begin-user-doc --> + * @param classifierID + * @param theEObject + * <!-- end-user-doc --> + * @return the first non-null result returned by a <code>caseXXX</code> call. + * @generated + */ + protected T doSwitch(int classifierID, EObject theEObject) + { + switch (classifierID) + { + case FaceletTaglibPackage.FACELET_LIBRARY_CLASS_TAG_LIB: + { + FaceletLibraryClassTagLib faceletLibraryClassTagLib = (FaceletLibraryClassTagLib)theEObject; + T result = caseFaceletLibraryClassTagLib(faceletLibraryClassTagLib); + if (result == null) result = caseFaceletTaglibDefn(faceletLibraryClassTagLib); + if (result == null) result = defaultCase(theEObject); + return result; + } + case FaceletTaglibPackage.FACELET_XML_DEFN_TAGLIB: + { + FaceletXMLDefnTaglib faceletXMLDefnTaglib = (FaceletXMLDefnTaglib)theEObject; + T result = caseFaceletXMLDefnTaglib(faceletXMLDefnTaglib); + if (result == null) result = caseFaceletTaglibDefn(faceletXMLDefnTaglib); + if (result == null) result = defaultCase(theEObject); + return result; + } + case FaceletTaglibPackage.FACELET_TAGLIB_DEFN: + { + FaceletTaglibDefn faceletTaglibDefn = (FaceletTaglibDefn)theEObject; + T result = caseFaceletTaglibDefn(faceletTaglibDefn); + if (result == null) result = defaultCase(theEObject); + return result; + } + case FaceletTaglibPackage.COMPONENT_TAG_DEFN: + { + ComponentTagDefn componentTagDefn = (ComponentTagDefn)theEObject; + T result = caseComponentTagDefn(componentTagDefn); + if (result == null) result = caseHandlerTagDefn(componentTagDefn); + if (result == null) result = caseTagDefn(componentTagDefn); + if (result == null) result = defaultCase(theEObject); + return result; + } + case FaceletTaglibPackage.VALIDATOR_TAG_DEFN: + { + ValidatorTagDefn validatorTagDefn = (ValidatorTagDefn)theEObject; + T result = caseValidatorTagDefn(validatorTagDefn); + if (result == null) result = caseHandlerTagDefn(validatorTagDefn); + if (result == null) result = caseTagDefn(validatorTagDefn); + if (result == null) result = defaultCase(theEObject); + return result; + } + case FaceletTaglibPackage.CONVERTER_TAG_DEFN: + { + ConverterTagDefn converterTagDefn = (ConverterTagDefn)theEObject; + T result = caseConverterTagDefn(converterTagDefn); + if (result == null) result = caseHandlerTagDefn(converterTagDefn); + if (result == null) result = caseTagDefn(converterTagDefn); + if (result == null) result = defaultCase(theEObject); + return result; + } + case FaceletTaglibPackage.HANDLER_TAG_DEFN: + { + HandlerTagDefn handlerTagDefn = (HandlerTagDefn)theEObject; + T result = caseHandlerTagDefn(handlerTagDefn); + if (result == null) result = caseTagDefn(handlerTagDefn); + if (result == null) result = defaultCase(theEObject); + return result; + } + case FaceletTaglibPackage.SOURCE_TAG_DEFN: + { + SourceTagDefn sourceTagDefn = (SourceTagDefn)theEObject; + T result = caseSourceTagDefn(sourceTagDefn); + if (result == null) result = caseTagDefn(sourceTagDefn); + if (result == null) result = defaultCase(theEObject); + return result; + } + case FaceletTaglibPackage.TAG_DEFN: + { + TagDefn tagDefn = (TagDefn)theEObject; + T result = caseTagDefn(tagDefn); + if (result == null) result = defaultCase(theEObject); + return result; + } + case FaceletTaglibPackage.FUNCTION_DEFN: + { + FunctionDefn functionDefn = (FunctionDefn)theEObject; + T result = caseFunctionDefn(functionDefn); + if (result == null) result = defaultCase(theEObject); + return result; + } + default: return defaultCase(theEObject); + } + } + + /** + * Returns the result of interpreting the object as an instance of '<em>Facelet Library Class Tag Lib</em>'. + * <!-- begin-user-doc --> + * This implementation returns null; + * returning a non-null result will terminate the switch. + * <!-- end-user-doc --> + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of '<em>Facelet Library Class Tag Lib</em>'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseFaceletLibraryClassTagLib(FaceletLibraryClassTagLib object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of '<em>Facelet XML Defn Taglib</em>'. + * <!-- begin-user-doc --> + * This implementation returns null; + * returning a non-null result will terminate the switch. + * <!-- end-user-doc --> + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of '<em>Facelet XML Defn Taglib</em>'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseFaceletXMLDefnTaglib(FaceletXMLDefnTaglib object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of '<em>Defn</em>'. + * <!-- begin-user-doc --> + * This implementation returns null; + * returning a non-null result will terminate the switch. + * <!-- end-user-doc --> + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of '<em>Defn</em>'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseFaceletTaglibDefn(FaceletTaglibDefn object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of '<em>Component Tag Defn</em>'. + * <!-- begin-user-doc --> + * This implementation returns null; + * returning a non-null result will terminate the switch. + * <!-- end-user-doc --> + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of '<em>Component Tag Defn</em>'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseComponentTagDefn(ComponentTagDefn object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of '<em>Validator Tag Defn</em>'. + * <!-- begin-user-doc --> + * This implementation returns null; + * returning a non-null result will terminate the switch. + * <!-- end-user-doc --> + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of '<em>Validator Tag Defn</em>'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseValidatorTagDefn(ValidatorTagDefn object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of '<em>Converter Tag Defn</em>'. + * <!-- begin-user-doc --> + * This implementation returns null; + * returning a non-null result will terminate the switch. + * <!-- end-user-doc --> + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of '<em>Converter Tag Defn</em>'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseConverterTagDefn(ConverterTagDefn object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of '<em>Handler Tag Defn</em>'. + * <!-- begin-user-doc --> + * This implementation returns null; + * returning a non-null result will terminate the switch. + * <!-- end-user-doc --> + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of '<em>Handler Tag Defn</em>'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseHandlerTagDefn(HandlerTagDefn object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of '<em>Source Tag Defn</em>'. + * <!-- begin-user-doc --> + * This implementation returns null; + * returning a non-null result will terminate the switch. + * <!-- end-user-doc --> + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of '<em>Source Tag Defn</em>'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseSourceTagDefn(SourceTagDefn object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of '<em>Tag Defn</em>'. + * <!-- begin-user-doc --> + * This implementation returns null; + * returning a non-null result will terminate the switch. + * <!-- end-user-doc --> + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of '<em>Tag Defn</em>'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseTagDefn(TagDefn object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of '<em>Function Defn</em>'. + * <!-- begin-user-doc --> + * This implementation returns null; + * returning a non-null result will terminate the switch. + * <!-- end-user-doc --> + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of '<em>Function Defn</em>'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseFunctionDefn(FunctionDefn object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of '<em>EObject</em>'. + * <!-- begin-user-doc --> + * This implementation returns null; + * returning a non-null result will terminate the switch, but this is the last case anyway. + * <!-- end-user-doc --> + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of '<em>EObject</em>'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) + * @generated + */ + public T defaultCase(EObject object) + { + return null; + } + +} //FaceletTaglibSwitch diff --git a/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/messages.properties b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/messages.properties new file mode 100644 index 000000000..635e1abcd --- /dev/null +++ b/jsf/plugins/org.eclipse.jst.jsf.facelet.core/src/org/eclipse/jst/jsf/facelet/core/internal/registry/taglib/messages.properties @@ -0,0 +1,2 @@ +ContextParamSpecifiedFaceletTaglibLocator_0=Facelet Taglib Locator for Context Params +JarFileFaceletTaglibLocator_0=Facelet Taglib Locator for Jar Files |