Attachment #82505 for bug #206808

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/**
 * <copyright>
 *
 * Copyright (c) 2006, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.Collection;
import java.util.Iterator;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;


	}

	public boolean performFinish() {
		final Collection<ProjectDescriptor> projectDescriptors = getProjectDescriptors();
		
		try {
			getContainer().run(true, false, new IRunnableWithProgress() {

							throws CoreException, InvocationTargetException, InterruptedException {
							m.beginTask("Unzipping Projects", projectDescriptors.size());
							
							for (ProjectDescriptor next : projectDescriptors) {
								unzipProject(next, m);
								m.worked(1);
							}
						}

	 * @return The collection of project descriptors that should be
	 *  unzipped into the workspace.
	 */
	protected abstract Collection<ProjectDescriptor> getProjectDescriptors();
	
	private void unzipProject(ProjectDescriptor descriptor, IProgressMonitor monitor) {
		String bundleName = descriptor.getBundleName();




/**
 * <copyright>
 *
 * Copyright (c) 2006, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

public class GeneralExampleWizard
	extends AbstractExampleWizard {
	
	@Override
	protected Collection<ProjectDescriptor> getProjectDescriptors() {
		// We need the general example to be unzipped along with the
		// EMF library example model, edit and editor examples
		List<ProjectDescriptor> projects = new ArrayList<ProjectDescriptor>(4);
		projects.add(new ProjectDescriptor("org.eclipse.emf.validation.examples", "zips/library.zip", "org.eclipse.emf.examples.library"));  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
		projects.add(new ProjectDescriptor("org.eclipse.emf.validation.examples", "zips/libraryEdit.zip", "org.eclipse.emf.examples.library.edit")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		projects.add(new ProjectDescriptor("org.eclipse.emf.validation.examples", "zips/libraryEditor.zip", "org.eclipse.emf.examples.library.editor"));  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$

		return projects;
	}
	
	@Override
	protected void log(Exception e) {
		if (e instanceof CoreException) {
			ValidationExamplesPlugin.getDefault().getLog().log(((CoreException)e).getStatus());




/**
 * <copyright>
 *
 * Copyright (c) 2006, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

public class AdapterExampleWizard
	extends AbstractExampleWizard {
	
	@Override
	protected Collection<ProjectDescriptor> getProjectDescriptors() {
		// We need the adapter example to be unzipped along with the
		// EMF library example model, edit and editor examples
		List<ProjectDescriptor> projects = new ArrayList<ProjectDescriptor>(4);
		projects.add(new ProjectDescriptor("org.eclipse.emf.validation.examples", "zips/library.zip", "org.eclipse.emf.examples.library"));  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
		projects.add(new ProjectDescriptor("org.eclipse.emf.validation.examples", "zips/libraryEdit.zip", "org.eclipse.emf.examples.library.edit")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		projects.add(new ProjectDescriptor("org.eclipse.emf.validation.examples", "zips/libraryEditor.zip", "org.eclipse.emf.examples.library.editor"));  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$

		return projects;
	}
	
	@Override
	protected void log(Exception e) {
		if (e instanceof CoreException) {
			ValidationExamplesPlugin.getDefault().getLog().log(((CoreException)e).getStatus());




/**
 * <copyright>
 *
 * Copyright (c) 2006, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

public class OCLExampleWizard
	extends AbstractExampleWizard {
	
	@Override
	protected Collection<ProjectDescriptor> getProjectDescriptors() {
		// We need the OCL example to be unzipped along with the
		// EMF library example model, edit and editor examples
		List<ProjectDescriptor> projects = new ArrayList<ProjectDescriptor>(4);
		projects.add(new ProjectDescriptor("org.eclipse.emf.validation.examples", "zips/library.zip", "org.eclipse.emf.examples.library"));  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
		projects.add(new ProjectDescriptor("org.eclipse.emf.validation.examples", "zips/libraryEdit.zip", "org.eclipse.emf.examples.library.edit")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		projects.add(new ProjectDescriptor("org.eclipse.emf.validation.examples", "zips/libraryEditor.zip", "org.eclipse.emf.examples.library.editor"));  //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$

		return projects;
	}
	
	@Override
	protected void log(Exception e) {
		if (e instanceof CoreException) {
			ValidationExamplesPlugin.getDefault().getLog().log(((CoreException)e).getStatus());

Lines 25-30 Link Here

(-)build.properties (-2 / +2 lines)
25	zips/*.zip,\	25	zips/*.zip,\
26	icons/	26	icons/
27	src.includes = about.html	27	src.includes = about.html
28	javacSource = 1.4	28	javacSource = 1.5
29	javacTarget = 1.4	29	javacTarget = 1.5
30		30

Lines 1-7 Link Here

(-).classpath (-1 / +1 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<classpath>	2	<classpath>
3	<classpathentry kind="src" path="src"/>	3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/>	4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>	5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
6	<classpathentry kind="output" path="bin"/>	6	<classpathentry kind="output" path="bin"/>
7	</classpath>	7	</classpath>

Lines 1-8 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-5 / +5 lines)
1	#Wed Dec 20 11:45:30 EST 2006	1	#Mon Nov 05 21:48:43 EST 2007
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled	3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.4	4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
5	org.eclipse.jdt.core.compiler.compliance=1.4	5	org.eclipse.jdt.core.compiler.compliance=1.5
6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error	6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning	7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
8	org.eclipse.jdt.core.compiler.source=1.4	8	org.eclipse.jdt.core.compiler.source=1.5

Lines 2-8 Link Here

(-)META-INF/MANIFEST.MF (-2 / +2 lines)
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: %Plugin.name	3	Bundle-Name: %Plugin.name
4	Bundle-SymbolicName: org.eclipse.emf.validation.examples;singleton:=true	4	Bundle-SymbolicName: org.eclipse.emf.validation.examples;singleton:=true
5	Bundle-Version: 1.1.100.qualifier	5	Bundle-Version: 1.2.0.qualifier
6	Bundle-Activator: org.eclipse.emf.validation.examples.internal.ValidationExamplesPlugin	6	Bundle-Activator: org.eclipse.emf.validation.examples.internal.ValidationExamplesPlugin
7	Bundle-Vendor: %Plugin.providerName	7	Bundle-Vendor: %Plugin.providerName
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
Lines 13-16 Link Here
13	org.eclipse.core.resources;bundle-version="[3.2.0,4.0.0)",	13	org.eclipse.core.resources;bundle-version="[3.2.0,4.0.0)",
14	org.eclipse.ui.ide;bundle-version="[3.2.0,4.0.0)"	14	org.eclipse.ui.ide;bundle-version="[3.2.0,4.0.0)"
15	Eclipse-LazyStart: true	15	Eclipse-LazyStart: true
16	Bundle-RequiredExecutionEnvironment: J2SE-1.4	16	Bundle-RequiredExecutionEnvironment: J2SE-1.5




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	public EValidatorAdapter() {
		super();
		
		batchValidator = ModelValidationService.getInstance().newValidator(
			(IBatchValidator) ModelValidationService.getInstance().newValidator(
				EvaluationMode.BATCH);
		batchValidator.setIncludeLiveConstraints(true);
		batchValidator.setReportSuccesses(false);
	}

	@Override
	public boolean validate(EObject eObject, DiagnosticChain diagnostics,
			Map<Object, Object> context) {
		return validate(eObject.eClass(), eObject, diagnostics, context);
	}

	/**
	 * Implements validation by delegation to the EMF validation framework.
	 */
	@Override
	public boolean validate(EClass eClass, EObject eObject,
			DiagnosticChain diagnostics, Map<Object, Object> context) {
		// first, do whatever the basic EcoreValidator does
		super.validate(eClass, eObject, diagnostics, context);
		

	 * validation framework; they are validated indirectly via the
	 * {@link EObject}s that hold their values.
	 */
	@Override
	public boolean validate(EDataType eDataType, Object value,
			DiagnosticChain diagnostics, Map<Object, Object> context) {
		return super.validate(eDataType, value, diagnostics, context);
	}
	

	 * @param context the context (may be <code>null</code>)
	 * @param status the element's validation status
	 */
	private void processed(EObject eObject, Map<Object, Object> context, IStatus status) {
		if (context != null) {
			context.put(eObject, status);
		}

	 *     the <code>eObject</code> or one of its containers has already been
	 *     validated;  <code>false</code>, otherwise
	 */
	private boolean hasProcessed(EObject eObject, Map<Object, Object> context) {
		boolean result = false;
		
		if (context != null) {

		if (status.isMultiStatus()) {
			IStatus[] children = status.getChildren();
			
			for (IStatus element : children) {
				appendDiagnostics(element, diagnostics);
			}
		} else if (status instanceof IConstraintStatus) {
			diagnostics.add(new BasicDiagnostic(

Lines 41-47 Link Here

(-)src/org/eclipse/emf/validation/examples/adapter/constraints/ExampleConstraint.java (-1 / +2 lines)
41	/**	41	/**
42	* I fail on every object that I see.	42	* I fail on every object that I see.
43	*/	43	*/
		44	@Override
44	public IStatus validate(IValidationContext ctx) {	45	public IStatus validate(IValidationContext ctx) {
45	return ctx.createFailureStatus(new Object[] {ctx.getTarget()});	46	return ctx.createFailureStatus(ctx.getTarget());
46	}	47	}
47	}	48	}

Lines 19-23 Link Here

(-)build.properties (-2 / +2 lines)
19	.,\	19	.,\
20	about.html	20	about.html
21	src.includes = about.html	21	src.includes = about.html
22	javacSource = 1.4	22	javacSource = 1.5
23	javacTarget = 1.4	23	javacTarget = 1.5

Lines 1-7 Link Here

(-).classpath (-1 / +1 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<classpath>	2	<classpath>
3	<classpathentry kind="src" path="src"/>	3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/>	4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>	5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
6	<classpathentry kind="output" path="bin"/>	6	<classpathentry kind="output" path="bin"/>
7	</classpath>	7	</classpath>

Lines 2-8 Link Here

(-)META-INF/MANIFEST.MF (-4 / +4 lines)
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: %Plugin.name	3	Bundle-Name: %Plugin.name
4	Bundle-SymbolicName: org.eclipse.emf.validation.examples.adapter; singleton:=true	4	Bundle-SymbolicName: org.eclipse.emf.validation.examples.adapter; singleton:=true
5	Bundle-Version: 1.0.100.qualifier	5	Bundle-Version: 1.2.0.qualifier
6	Bundle-Activator: org.eclipse.emf.validation.examples.adapter.ValidationExamplePlugin	6	Bundle-Activator: org.eclipse.emf.validation.examples.adapter.ValidationExamplePlugin
7	Bundle-Vendor: %Plugin.providerName	7	Bundle-Vendor: %Plugin.providerName
8	Bundle-Localization: plugin	8	Bundle-Localization: plugin
Lines 12-18 Link Here
12	Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",	12	Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
13	org.eclipse.core.expressions;bundle-version="[3.2.0,4.0.0)",	13	org.eclipse.core.expressions;bundle-version="[3.2.0,4.0.0)",
14	org.eclipse.ui;bundle-version="[3.2.0,4.0.0)",	14	org.eclipse.ui;bundle-version="[3.2.0,4.0.0)",
15	org.eclipse.emf.examples.library;bundle-version="[2.2.0,3.0.0)",	15	org.eclipse.emf.examples.library;bundle-version="[2.3.0,3.0.0)",
16	org.eclipse.emf.validation;bundle-version="[1.0.0,2.0.0)"	16	org.eclipse.emf.validation;bundle-version="[1.2.0,2.0.0)"
17	Eclipse-LazyStart: true	17	Eclipse-LazyStart: true
18	Bundle-RequiredExecutionEnvironment: J2SE-1.4	18	Bundle-RequiredExecutionEnvironment: J2SE-1.5

Lines 1-8 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-5 / +5 lines)
1	#Wed Dec 20 11:46:27 EST 2006	1	#Tue Oct 30 22:14:54 EDT 2007
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled	3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.4	4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
5	org.eclipse.jdt.core.compiler.compliance=1.4	5	org.eclipse.jdt.core.compiler.compliance=1.5
6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error	6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning	7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
8	org.eclipse.jdt.core.compiler.source=1.4	8	org.eclipse.jdt.core.compiler.source=1.5




<feature
      id="org.eclipse.emf.validation.examples"
      label="%featureName"
      version="1.2.0.qualifier"
      provider-name="%providerName"
      image="modeling32.png">


      <import plugin="org.eclipse.core.runtime" version="3.2.0" match="compatible"/>
      <import plugin="org.eclipse.core.resources" version="3.2.0" match="compatible"/>
      <import plugin="org.eclipse.ui.ide" version="3.2.0" match="compatible"/>
      <import plugin="org.eclipse.emf.validation" version="1.0.0" match="compatible"/>
      <import plugin="org.eclipse.emf.examples.library" version="2.2.0" match="compatible"/>
      <import plugin="org.eclipse.emf.examples.library.edit" version="2.2.0" match="compatible"/>
      <import plugin="org.eclipse.emf.examples.library.editor" version="2.2.0" match="compatible"/>
      <import plugin="org.eclipse.ui.console" version="3.1.100" match="compatible"/>
      <import plugin="org.eclipse.emf.validation.ui" version="1.0.0" match="compatible"/>
      <import plugin="org.eclipse.core.expressions" version="3.2.0" match="compatible"/>
      <import plugin="org.eclipse.emf.validation" version="1.2.0" match="compatible"/>
      <import plugin="org.eclipse.emf.examples.library" version="2.3.0" match="compatible"/>
      <import plugin="org.eclipse.emf.examples.library.edit" version="2.3.0" match="compatible"/>
      <import plugin="org.eclipse.emf.examples.library.editor" version="2.3.0" match="compatible"/>
      <import plugin="org.eclipse.emf.validation.ui" version="1.2.0" match="compatible"/>
      <import plugin="org.eclipse.emf.validation.ocl" version="1.1.0" match="compatible"/>
      <import plugin="org.eclipse.ocl.ecore" version="1.1.0" match="compatible"/>
   </requires>

   <plugin




Bundle-ManifestVersion: 2
Bundle-Name: %Plugin.name
Bundle-SymbolicName: org.eclipse.emf.validation.ocl; singleton:=true
Bundle-Version: 1.2.0.qualifier
Bundle-Vendor: %Plugin.providerName
Bundle-Localization: plugin
Export-Package: org.eclipse.emf.validation.internal.ocl;x-internal:=true,
 org.eclipse.emf.validation.ocl
Require-Bundle: org.eclipse.emf.validation;bundle-version="[1.2.0,2.0.0)",
 org.eclipse.emf.ocl;bundle-version="[1.0.0,2.0.0)";visibility:=reexport,
 org.eclipse.ocl;bundle-version="[1.1.0,2.0.0)";visibility:=reexport,
 org.eclipse.ocl.ecore;bundle-version="[1.1.0,2.0.0)",




	 * @deprecated Override the {@link #createOCLEnvironmentFactory()} method,
     * instead.
	 */
	@Deprecated
	protected org.eclipse.emf.ocl.parser.EnvironmentFactory createEnvironmentFactory() {
        return org.eclipse.emf.ocl.parser.EnvironmentFactory.ECORE_INSTANCE;
    }



     * 
     * @deprecated Use the {@link #getConstraintCondition(EObject)} method, instead.
	 */
	@Deprecated
	public org.eclipse.emf.ocl.query.Query getCondition(EClass eClass) {
		org.eclipse.emf.ocl.query.Query result = null;
		

			//   variable and result locus, as OCL has no way to provide
			//   additional extractions.  Also, there is no way for the OCL
			//   to access the context object
			return ctx.createFailureStatus(target);
		}
	}
    




import org.eclipse.emf.validation.internal.EMFModelValidationDebugOptions;
import org.eclipse.emf.validation.internal.util.Trace;
import org.eclipse.emf.validation.model.EvaluationMode;
import org.eclipse.emf.validation.model.IModelConstraint;
import org.eclipse.emf.validation.service.EventTypeService;
import org.eclipse.emf.validation.service.ILiveValidator;
import org.eclipse.emf.validation.service.INotificationGenerator;

 *
 * @author Christian W. Damus (cdamus)
 */
public class LiveValidator extends AbstractValidator<Notification> implements ILiveValidator {
	private FilteredCollection.Filter<Notification> notificationFilter;

	/**
	 * Initializes me with the operation <code>executor</code> that I use to

	 * @param executor used by me to execute operations (must not be
	 *      <code>null</code>)
	 */
	public LiveValidator(IProviderOperationExecutor<Collection<IModelConstraint>> executor) {
		super(EvaluationMode.LIVE, executor);
	}

	/* (non-Javadoc)
	 * Implements the inherited method.
	 */
	@Override
	protected Collection<IStatus> doValidate(Collection<? extends Notification> objects,
		Set<IClientContext> clientContexts) {

	/* (non-Javadoc)
	 * Implements the inherited method.
	 */
	protected Collection doValidate(Collection objects, Set clientContexts) {
		// Generate notifications for contributed emf event types
		Collection<Notification> notifications = generateNotifications(objects);
			
		// Merge similar notifications together to avoid repeated constraint
		// evaluations on the same kind of change to the same feature
		List<Notification> events = mergeNotifications(notifications);
		Iterator<Notification> iter = events.iterator();
		
		List<IStatus> result = new java.util.ArrayList<IStatus>(32); // anticipate moderate number
		
		GetLiveConstraintsOperation operation =
			new GetLiveConstraintsOperation();
		operation.setAllEvents(new java.util.ArrayList<Notification>(objects));
		AbstractValidationContext ctx = operation.getContext();
		ctx.setReportSuccesses(isReportSuccesses());
		
		while (iter.hasNext()) {
			final Notification event = iter.next();
			
			Object notifier = event.getNotifier();


					// set the validation context's client contexts so that we
					//    selected the most appropriate constraints to evaluate
					
					Collection<IClientContext> contexts =
						ClientContextManager.getInstance().getClientContextsFor(
							(EObject) notifier);
					
					ctx.setClientContexts(contexts);

			AbstractValidationContext ctx,
			Notification event,
			GetLiveConstraintsOperation operation,
			List<IStatus> results) {
		if (Trace.shouldTraceEntering(EMFModelValidationDebugOptions.PROVIDERS)) {
			Trace.entering(getClass(), "validate", //$NON-NLS-1$
					new Object[] {event});

	 * @param notifications the input notifications
	 * @return the merged (possibly fewer) notifications
	 */
	private List<Notification> mergeNotifications(Collection<Notification> notifications) {
		// use a linked map to preserve list ordering
		Map<Notification, Notification> result =
			new java.util.LinkedHashMap<Notification, Notification>(notifications.size());
		
		for (Notification next : notifications) {
			Notification next = (Notification) iter.next();
			
			// only triggger constraints on EObjects that are still
			//  connected to a particular resource. We will filter the
			//  notification appropriately.

			}
		}
		
		return new java.util.ArrayList<Notification>(result.keySet());
	}
	
	private Collection<Notification> generateNotifications(
			Collection<? extends Notification> notifications) {
		
		Collection<INotificationGenerator> generators =
			EventTypeService.getInstance().getNotificationGenerators();
		Collection<Notification> newNotifications = new ArrayList<Notification>();
		
		// Add generated notifications for each generator
		for (INotificationGenerator next : generators) {
			newNotifications.addAll(next.generateNotifications(notifications));
			newNotifications.addAll(generator.generateNotifications(notifications));
		}
		
		// Add existing notifications

		return getNotificationFilter().accept(notification);
	}
	
	public void setNotificationFilter(FilteredCollection.Filter<Notification> filter) {
		notificationFilter = filter;
	}
	

	 * <code>AttachedToResourceNotificationFilter</code>.
     * </p>
	 */
	public FilteredCollection.Filter<Notification> getNotificationFilter() {
		if (notificationFilter == null) {
			notificationFilter = new AttachedToResourceNotificationFilter();
		}

			// take a copy to ensure that they are modifiable.  Also, this
			// avoids destroying the original notification's collection
			if (oldValue instanceof Collection) {
				oldValue = new java.util.ArrayList<Object>((Collection<?>) oldValue);
			}
			if (newValue instanceof Collection) {
				newValue = new java.util.ArrayList<Object>((Collection<?>) newValue);
			}
		}
		
		/* (non-Javadoc)
		 * Redefines the inherited method to return the stored event type.
		 */
		@Override
		public int getEventType() {
			return eventType;
		}

		 * Redefines the inherited method to return the stored new feature
		 * value.
		 */
		@Override
		public Object getNewValue() {
			return newValue;
		}

		 * Redefines the inherited method to return the stored old feature
		 * value.
		 */
		@Override
		public Object getOldValue() {
			return oldValue;
		}

		 * the same, as well as the "Remove" and "Remove Many", for the purposes
		 * of this comparison.
		 */
		@Override
		public boolean equals(Object o) {
			boolean result = false;
			

		 * To be consistent with the {@link #equals(Object)} method, my hash
		 * code is computed from my notifier, event type, and feature.
		 */
		@Override
		public int hashCode() {
			int localEventType = getEventType();
			

		 * Redefines the inherited method to implement a merge for singleton and
		 * list features.
		 */
		@Override
		@SuppressWarnings("unchecked")
		public boolean merge(Notification other) {
			boolean result = false;
			
			Collection<Object> newCollection;
			Object otherValue;
			
			if (this.equals(other)) {

				case Notification.RESOLVE:
					
					if (newValue instanceof Collection) {
						newCollection = (Collection<Object>) newValue;
					} else {
						newCollection = new java.util.ArrayList<Object>();
						newCollection.add(newValue);
					}
					
					otherValue = other.getNewValue();
					
					if (otherValue instanceof Collection) {
						newCollection.addAll((Collection<?>) otherValue);
					} else {
						newCollection.add(otherValue);
					}

				case Notification.ADD_MANY:
					
					if (newValue instanceof Collection) {
						newCollection = (Collection<Object>) newValue;
					} else {
						newCollection = new java.util.ArrayList<Object>();
						newCollection.add(newValue);
					}
					
					otherValue = other.getNewValue();
					
					if (otherValue instanceof Collection) {
						newCollection.addAll((Collection<?>) otherValue);
					} else {
						newCollection.add(otherValue);
					}

				case Notification.REMOVE_MANY:
					
					if (oldValue instanceof Collection) {
						newCollection = (Collection<Object>) oldValue;
					} else {
						newCollection = new java.util.ArrayList<Object>();
						newCollection.add(oldValue);
					}
					
					otherValue = other.getOldValue();
					
					if (otherValue instanceof Collection) {
						newCollection.addAll((Collection<?>) otherValue);
					} else {
						newCollection.add(otherValue);
					}

				case Notification.REMOVING_ADAPTER:
					
					if (oldValue instanceof Collection) {
						newCollection = (Collection<Object>) oldValue;
					} else {
						newCollection = new java.util.ArrayList<Object>();
						newCollection.add(oldValue);
					}
					
					otherValue = other.getOldValue();
					
					if (otherValue instanceof Collection) {
						newCollection.addAll((Collection<?>) otherValue);
					} else {
						newCollection.add(otherValue);
					}

	 * <code>EObject</code> that is attached to a resource (i.e., it is not
	 * deleted)
	 */
	private class AttachedToResourceNotificationFilter
			implements FilteredCollection.Filter<Notification> {
		
		public boolean accept(Notification element) {
			return (element.getNotifier() instanceof EObject) &&
				(((EObject) element.getNotifier()).eResource() != null);
			}
            
			return false;
		}
	}
}




	}

	// implements the inherited method
	@Override
	protected void executeImpl(
			IModelConstraintProvider provider,
			Collection<IModelConstraint> constraints) {
		assert provider != null;

		provider.getBatchConstraints(getEObject(), constraints);
	}
	
	// implements the inherited method
	@Override
	protected AbstractValidationContext createContext() {
		class BatchOnlyFilter implements FilteredCollection.Filter<IModelConstraint> {
			private final FilteredCollection.Filter<IModelConstraint> delegate;
			
			BatchOnlyFilter(FilteredCollection.Filter<IModelConstraint> delegate) {
				this.delegate = delegate;
			}
			
			// additionally exclude any live mode constraints
			public boolean accept(IModelConstraint element) {
				return element.getDescriptor().getEvaluationMode().isBatchOnly()
					&& delegate.accept(element);
				return constraint.getDescriptor().getEvaluationMode().isBatchOnly()
					&& delegate.accept(constraint);
			}
		}
		

			// overrides the inherited method to provide a filter that
			//    additionally excludes "live" mode constraints if we are
			//    only looking for batch mode
			@Override
			public FilteredCollection.Filter<IModelConstraint> getConstraintFilter() {
				if (!batchOnly) {
					return super.getConstraintFilter();
				} else {





import org.eclipse.emf.validation.internal.EMFModelValidationDebugOptions;
import org.eclipse.emf.validation.internal.util.Trace;
import org.eclipse.emf.validation.model.IModelConstraint;
import org.eclipse.emf.validation.service.IModelConstraintProvider;
import org.eclipse.emf.validation.util.FilteredCollection;


 * 
 * @author Christian W. Damus (cdamus)
 */
public abstract class AbstractGetConstraintsOperation
		implements IProviderOperation<Collection<IModelConstraint>> {
	
	/** The EMF object to be validated. */
	private EObject eObject;

	/** The constraints which I have gathered from providers. */
	private final Collection<IModelConstraint> myConstraints =
		new java.util.ArrayList<IModelConstraint>();
	
	private Collection<IModelConstraint> filteredConstraints;
	
	private AbstractValidationContext context;


		// initialize the context now, if necessary
		if (context == null) {
			context = createContext();
			filteredConstraints = new FilteredCollection<IModelConstraint>(
					getUnfilteredConstraints(),
					context.getConstraintFilter());
		}
	}
	
	// implements the interface method
	public final Collection<IModelConstraint> getConstraints() {
		return filteredConstraints;
	}


	 * 
	 * @return my full collection of constraints
	 */
	protected Collection<IModelConstraint> getUnfilteredConstraints() {
		return myConstraints;
	}
	

	 * @param provider a constraint provider
	 * @return my unmodifiable constraints collection
	 */
	public Collection<IModelConstraint> execute(IModelConstraintProvider provider) {
		Trace.entering(
				EMFModelValidationDebugOptions.PROVIDERS,
				getClass(),

	 */
	protected abstract void executeImpl(
			IModelConstraintProvider provider,
			Collection<IModelConstraint> constraints);
}




/******************************************************************************
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * @author Christian W. Damus (cdamus)
 */
public abstract class AbstractValidationContext implements IValidationContext {
	private final IProviderOperation<Collection<IModelConstraint>> operation;
	
	// tracks the eObjects that are ignored by a constraint
	private final ConstraintIgnorement ignoredConstraints =

	
	private ConstraintFilter filter;  // lazily initialized
	
	private final Map<IConstraintDescriptor, Object> constraintData =
		new java.util.HashMap<IConstraintDescriptor, Object>();

	private IModelConstraint currentConstraint = null;
	private IConstraintDescriptor currentDescriptor = null;
		
	private final Set<EObject> resultLocus = new java.util.HashSet<EObject>();
	
	private boolean reportSuccesses = false;
	
	private Collection<IClientContext> clientContexts = Collections.emptySet();
	
	//	filters out all ignored and disabled, as well as constraints
	//	   that have already been executed on the current target
	private class ConstraintFilter implements FilteredCollection.Filter<IModelConstraint> {
		/** Initializes me. */
		ConstraintFilter() {
			// nothing to initialize.  Just declare the constructor explicitly

		 * I filter out any constraint that is disabled, ignored, or has already
		 * been evaluated against the current target object.
		 */
		public boolean accept(IModelConstraint constraint) {
			IConstraintDescriptor desc = constraint.getDescriptor();
				((IModelConstraint)constraint).getDescriptor();
			
			return (desc.isEnabled() && !isIgnored(desc));
		}

	//    whether they are triggered for specific features (in the live and
	//    feature validation cases) or just by the object type (batch mode)
	private class ConstraintIgnorement {
		private final Map<EObject, Collection<IConstraintDescriptor>> ignoreMap =
			new java.util.HashMap<EObject, Collection<IConstraintDescriptor>>();
		
		/**
		 * Ignores the specified <code>constraint</code> for this

		 * @param constraint the constraint
		 */
		void ignore(EObject eObject, IConstraintDescriptor constraint) {
			Collection<IConstraintDescriptor> ignored = getIgnoredConstraints(eObject);
			
			if (ignored == null) {
				ignored = initIgnoredConstraints(eObject);

		 * @return whether the <code>constraint</code> is ignored
		 */
		boolean isIgnored(EObject eObject, IConstraintDescriptor constraint) {
			Collection<IConstraintDescriptor> ignored = getIgnoredConstraints(eObject);
			
			return (ignored != null) && ignored.contains(constraint);
		}

		 *    and that are not triggered by a feature, or <code>null</code> if
		 *    no ignored constraints collection exists, yet
		 */
		private Collection<IConstraintDescriptor> getIgnoredConstraints(EObject target) {
			return ignoreMap.get(target);
		}
	
		/**

		 * @param target a validation target object
		 * @return the new ignored constraints collection
		 */
		private Collection<IConstraintDescriptor> initIgnoredConstraints(EObject target) {
			Collection<IConstraintDescriptor> result = new java.util.HashSet<IConstraintDescriptor>();
			
			ignoreMap.put(target, result);
		

	 * @param operation the operation for which I provide a validation context
	 */
	protected AbstractValidationContext(
			IProviderOperation<Collection<IModelConstraint>> operation) {
		this.operation = operation;
	}


	 * 
	 * @return my operation
	 */
	protected final IProviderOperation<Collection<IModelConstraint>> getOperation() {
		return operation;
	}
	

	/**
	 * Default implementation simply returns an empty list.
	 */
	public List<Notification> getAllEvents() {
		return Collections.emptyList();
	}

	/**

	}
	
	// implements the interface method
	public void skipCurrentConstraintForAll(Collection<?> eObjects) {
		for (Object next : eObjects) {
			Object next = iter.next();
			
			if (next instanceof EObject) {
				skipCurrentConstraintFor((EObject)next);
			}

	 * 
	 * @return a constraint filter for this context
	 */
	public FilteredCollection.Filter<IModelConstraint> getConstraintFilter() {
		if (filter == null) {
			filter = new ConstraintFilter();
		}

	
	// implements the interface method
	public final Object putCurrentConstraintData(Object newData) {
		return constraintData.put(getConstraint().getDescriptor(), newData);
	}
	
	/**

		resultLocus.add(eObject);
	}
	
	public void addResults(Collection<? extends EObject> eObjects) {
		assert eObjects != null;
		
		// explicitly iterate instead of calling resultLocus.addAll() in order
		//    to assert the types of the elements by casting
		for (EObject next : eObjects) {
			addResult(next);
		}
	}
	
	// implements the interface method
	public Set<EObject> getResultLocus() {
		return java.util.Collections.unmodifiableSet(resultLocus);
	}
	

	}
	
	/**
	 * Obtains the descriptor of the constraint currently being evaluated.
	 * 
	 * @return the current constraint'sdescriptor
	 */

	}

	// implements the interface method
	public IStatus createFailureStatus(Object... messageArgs) {
		
		String message = TextUtils.formatMessage(
				getDescriptor().getMessagePattern(),

	 * 
	 * @return my constraints
	 */
	final Collection<IModelConstraint> getConstraints() {
		// use only those constraints that match the client contexts
		final Collection<IModelConstraint> delegate = ClientContextManager.getInstance().getBindings(
				clientContexts,
				getOperation().getConstraints());
		
		// wraps my constraints collection's iterator in order to access
		//    the descriptor of each constraint as it is traversed
		class ConstraintsIterator implements Iterator<IModelConstraint> {
			private final Iterator<? extends IModelConstraint> delegateIterator;

			ConstraintsIterator(Collection<? extends IModelConstraint> delegateCollection) {
				this.delegateIterator = delegateCollection.iterator();
			}
			

			// implements the interface method, additionally setting attributes
			//    of the enclosing context object from the next constraint
			//    descriptor
			public IModelConstraint next() {
				IModelConstraint result = delegateIterator.next();
				
				// make this descriptor available in the context
				setConstraint(result);
				
				// set the default result locus for this next constraint
				AbstractValidationContext.this.initializeResultLocus();

				throw new UnsupportedOperationException();
			}}
		
		return new AbstractCollection<IModelConstraint>() {
			@Override
			public Iterator<IModelConstraint> iterator() {
				return new ConstraintsIterator(delegate);
			}

			@Override
			public int size() {
				return delegate.size();
			}};

	 *    {@link org.eclipse.emf.validation.internal.service.IClientContext}s
	 *    or <code>null</code> to specify none
	 */
	final void setClientContexts(Collection<IClientContext> clientContexts) {
		if (clientContexts == null) {
			clientContexts = Collections.emptySet();
		}
		
		this.clientContexts = clientContexts;

	 * @return a collection of
	 *    {@link org.eclipse.emf.validation.internal.service.IClientContext}s
	 */
	final Collection<IClientContext> getClientContexts() {
		return clientContexts;
	}
	

		/* (non-Javadoc)
		 * Implements the inherited method.
		 */
		public Set<EObject> getResultLocus() {
			return Collections.emptySet();
		}
	}
}




/******************************************************************************
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.emf.validation.internal.EMFModelValidationDebugOptions;
import org.eclipse.emf.validation.internal.util.Trace;
import org.eclipse.emf.validation.model.EvaluationMode;
import org.eclipse.emf.validation.model.IModelConstraint;
import org.eclipse.emf.validation.service.IBatchValidator;
import org.eclipse.emf.validation.service.ITraversalStrategy;


 *
 * @author Christian W. Damus (cdamus)
 */
public class BatchValidator extends AbstractValidator<EObject> implements IBatchValidator {
	private boolean includeLiveConstraints = false;
	private IProgressMonitor progressMonitor = null;
	

	 * @param executor used by me to execute operations (must not be
	 *      <code>null</code>)
	 */
	public BatchValidator(
			IProviderOperationExecutor<Collection<IModelConstraint>> executor) {
		super(EvaluationMode.BATCH, executor);
	}



		this.traversalStrategy = strategy;
	}
	
	/* (non-Javadoc)
	 * Implements the inherited method.
	 */

	/* (non-Javadoc)
	 * Implements the inherited method.
	 */
	public IStatus validate(Collection<? extends EObject> objects, IProgressMonitor monitor) {
		IStatus result;
		
		progressMonitor = monitor;

	/* (non-Javadoc)
	 * Implements the inherited method.
	 */
	@Override
	protected Collection<IStatus> doValidate(Collection<? extends EObject> objects,
			Set<IClientContext> clientContexts) {
		
		List<IStatus> result = new java.util.ArrayList<IStatus>(64);  // anticipate large scale
		
		GetBatchConstraintsOperation operation =
			new GetBatchConstraintsOperation(!isIncludeLiveConstraints());

	 */
	private void validate(
			ITraversalStrategy traversal,
			List<IStatus> evaluationResults,
			AbstractValidationContext ctx,
			Collection<? extends EObject> objects,
			GetBatchConstraintsOperation operation, 
			Set<IClientContext> clientContexts) {
		
		IProgressMonitor monitor = progressMonitor;
		if (monitor == null) {

				final EObject next = traversal.next();

				if (recomputeClients) {
					Collection<IClientContext> contexts = ClientContextManager.getInstance()
							.getClientContextsFor(next);
					ctx.setClientContexts(contexts);
					clientContexts.addAll(contexts);

			AbstractValidationContext ctx,
			EObject eObject,
			GetBatchConstraintsOperation operation,
			List<IStatus> results) {
		if (Trace.shouldTraceEntering(EMFModelValidationDebugOptions.PROVIDERS)) {
			Trace.entering(getClass(), "validate", //$NON-NLS-1$
					new Object[] {eObject});

	}
	
	private static class DefaultRecursiveTraversalStrategy implements ITraversalStrategy {
		private Map<ITraversalStrategy, Collection<EObject>> delegates;
		private Map<ITraversalStrategy, IProgressMonitor> monitors;
		private Iterator<ITraversalStrategy> delegateIterator;
		private ITraversalStrategy current;
		
		/* (non-Javadoc)
		 * Redefines/Implements/Extends the inherited method.
		 */
		public void startTraversal(Collection<? extends EObject> traversalRoots,
				IProgressMonitor monitor) {
			delegates = initDelegates(traversalRoots);
			monitors = new java.util.HashMap<ITraversalStrategy, IProgressMonitor>();
			
			monitor.beginTask("", delegates.size() * 1024); //$NON-NLS-1$
			
			for (Map.Entry<ITraversalStrategy, Collection<EObject>> next :
					delegates.entrySet()) {
				
				SubProgressMonitor sub = new SubProgressMonitor(
					monitor,
					1024,
					SubProgressMonitor.SUPPRESS_SUBTASK_LABEL);
				next.getKey().startTraversal(next.getValue(), sub);
					(Collection)next.getValue(),
					sub);
				
				monitors.put(next.getKey(), sub);
			}
			
			delegateIterator = delegates.keySet().iterator();

		 */
		public boolean hasNext() {
			if ((current == null) && (delegateIterator.hasNext())) {
				current = delegateIterator.next();
			}
			
			if (current == null) {

			}
			
			if (!current.hasNext()) {
				monitors.get(current).done();
				current = null;
				
				return hasNext();  // get the next delegate and try it

			current.elementValidated(element, status);
		}
		
		private Map<ITraversalStrategy, Collection<EObject>> initDelegates(
				Collection<? extends EObject> traversalRoots) {
			
			Map<ITraversalStrategy, Collection<EObject>> result =
				new java.util.HashMap<ITraversalStrategy, Collection<EObject>>();
			
			for (EObject next : traversalRoots) {
				ITraversalStrategy delegate = TraversalStrategyManager
					.getInstance().getTraversalStrategy(next);
				
				Collection<EObject> delegateRoots = result.get(delegate);
				if (delegateRoots == null) {
					delegateRoots = new java.util.ArrayList<EObject>();
					result.put(delegate, delegateRoots);
				}
				




 * implementations in this package to execute operations
 * in the context of the object that created them.
 *
 * @param <T> the result type of the operation that I execute
 *
 * @author Christian W. Damus (cdamus)
 */
public interface IProviderOperationExecutor<T> {
	/**
	 * Executes the specified <code>op</code>eration.
	 * 
	 * @param op the operation to execute.  The execution result must be
	 *     obtained from it
	 */
	void execute(IProviderOperation<? extends T> op);
}




	 * weak map to avoid interfering with garbage-collection of EMF metamodels
	 * (and to clean up the cache when metamodels disappear!).
	 */
	private final Map<EClass, EClassBucket> buckets =
		new java.util.WeakHashMap<EClass, EClassBucket>();
	
	/** The cacheable providers. */
	private final Collection<IProviderDescriptor> providers =
		new java.util.ArrayList<IProviderDescriptor>();
	
	/**
	 * A container for the constraints provided by all cacheable providers

	 * @author Christian W. Damus (cdamus)
	 */
	private static class EClassBucket {
		private Collection<IModelConstraint> batchConstraints;
		private final Map<EMFEventType, Map<String, Collection<IModelConstraint>>>
		liveConstraints = new java.util.HashMap<EMFEventType, Map<String, Collection<IModelConstraint>>>();
		
		/**
		 * Initializes me.

		 * @return my batch constraints, or <code>null</code> if they have not
		 *    yet been retrieved from my registered providers
		 */
		Collection<IModelConstraint> getBatchConstraints() {
			return batchConstraints;
		}
		

		 * 
		 * @param constraints the batch constraints
		 */
		void cacheBatchConstraints(Collection<IModelConstraint> constraints) {
			batchConstraints = new java.util.ArrayList<IModelConstraint>(constraints);
		}
		
		/**

		 * @return the corresponding constraints, or <code>null</code> if they
		 *     have not yet been retrieved from my registered providers
		 */
		Collection<IModelConstraint> getLiveConstraints(EMFEventType eventType, String featureName) {
			if (featureName == null) {
				featureName = NOT_A_FEATURE_NAME;
			}
			
			Map<String, Collection<IModelConstraint>> constraintMap =
				liveConstraints.get(eventType);
			
			if (constraintMap != null) {
				return constraintMap.get(featureName);
			} else {
				return null;
			}

		void cacheLiveConstraints(
				EMFEventType eventType,
				String featureName,
				Collection<IModelConstraint> constraints) {
			
			if (featureName == null) {
				featureName = NOT_A_FEATURE_NAME;
			}
	
			Map<String, Collection<IModelConstraint>> constraintMap =
				liveConstraints.get(eventType);
	
			if (constraintMap == null) {
				constraintMap = new java.util.HashMap<String, Collection<IModelConstraint>>();
				liveConstraints.put(eventType, constraintMap);
			}
			
			constraintMap.put(
					featureName,
					new java.util.ArrayList<IModelConstraint>(constraints));
		}
		
		/**

			}
			
			// replace in the live constraints, if appropriate
			for (Map<String, Collection<IModelConstraint>> next : liveConstraints.values()) {
				for (Collection<IModelConstraint> constraints : next.values()) {
				
				for (Iterator nested = next.values().iterator(); nested.hasNext();) {
					Collection constraints = (Collection) nested.next();
					
					if ((constraints != null) && constraints.remove(oldConstraint)) {
						constraints.add(newConstraint);
					}

	public IProviderDescriptor getDescriptor() {
		return new IProviderDescriptor() {
			// the cache is assumed to always have an answer
			public boolean provides(
					IProviderOperation<? extends Collection<? extends IModelConstraint>> operation) {
				return true;
			}


	 * 
	 * @return the cached providers
	 */
	public Collection<IProviderDescriptor> getProviders() {
		return providers;
	}


	 * @return the corresponding bucket
	 */
	private EClassBucket getBucket(EClass clazz) {
		EClassBucket result = buckets.get(clazz);
		
		if (result == null) {
			result = new EClassBucket();

	 * @param operation the operation to execute
	 * @return the constraints retrieved by the operation
	 */
	private Collection<IModelConstraint> execute(AbstractGetConstraintsOperation operation) {
		for (Iterator<IProviderDescriptor> iter = getProviders().iterator(); iter.hasNext(); ) {
			IProviderDescriptor next = iter.next();
				(IProviderDescriptor)iter.next();

			if (next.provides(operation)) {
				try {

	}

	// implements the interface method
	public Collection<IModelConstraint> getLiveConstraints(
			Notification notification,
			Collection<IModelConstraint> constraints) {
		
		assert notification != null;
		
		Collection<IModelConstraint> result = constraints;

		if (result == null) {
			result = new java.util.ArrayList<IModelConstraint>();
		}

		if (notification.getNotifier() instanceof EObject) {

			}
			
			EClassBucket bucket = getBucket(eObject.eClass());
			Collection<IModelConstraint> cached = bucket.getLiveConstraints(
				eventType, featureName);
			
			if (cached == null) {
				if (Trace.shouldTrace(EMFModelValidationDebugOptions.CACHE)) {

	}

	// implements the interface method
	public Collection<IModelConstraint> getBatchConstraints(
			EObject eObject,
			Collection<IModelConstraint> constraints) {

		Collection<IModelConstraint> result = constraints;

		if (result == null) {
			result = new java.util.ArrayList<IModelConstraint>();
		}

		EClassBucket bucket = getBucket(eObject.eClass());
		Collection<IModelConstraint> cached = bucket.getBatchConstraints();
		if (cached == null) {
			if (Trace.shouldTrace(EMFModelValidationDebugOptions.CACHE)) {
				Trace.trace(

		
		// ask each bucket to replace the old constraint with the new, if
		// that constraint is in that bucket
		for (EClassBucket next : buckets.values()) {
			EClassBucket next = (EClassBucket) iter.next();
			
			next.replace(oldConstraint, newConstraint);
		}
	}




import org.eclipse.emf.validation.internal.util.StringMatcher;
import org.eclipse.emf.validation.internal.util.Trace;
import org.eclipse.emf.validation.model.EvaluationMode;
import org.eclipse.emf.validation.model.IModelConstraint;
import org.eclipse.emf.validation.service.AbstractConstraintProvider;
import org.eclipse.emf.validation.service.IModelConstraintProvider;
import org.eclipse.emf.validation.service.ModelValidationService;

	private final IConfigurationElement myConfig;
	private IConfigurationElement[] targets;
	private String[] nsUris;
	private final StringMatcher[] nsUriMatchers;
	private IModelConstraintProvider provider = null;
	private final boolean shouldCacheConstraints;

	private final EvaluationMode<?> mode;
    
    // map of (String => Boolean) caching whether a namespace is provided
    private final Map<String, Boolean> providedNamespaces =
    	new java.util.HashMap<String, Boolean>();

	/**
	 * The "null" provider never provides any constraints.  It is used as a

			super();
		}
		
		@Override
		public Collection<IModelConstraint> getBatchConstraints(EObject eObject,
			Collection<IModelConstraint> constraints) {
			return noOp(constraints);			
		}
		
		@Override
		public Collection<IModelConstraint> getLiveConstraints(Notification notification,
			Collection<IModelConstraint> constraints) {
			return noOp(constraints);
		}
		
		private Collection<IModelConstraint> noOp(Collection<IModelConstraint> constraints) {
			return (constraints == null)
				? new java.util.ArrayList<IModelConstraint>()
				: constraints;
		}		
	}


		this.mode = getMode(config);

		Set<String> uriSet = new java.util.HashSet<String>();
		Map<String, StringMatcher> uriMatcherMap = new java.util.HashMap<String, StringMatcher>();
		
		// backward compatibility for the namespaceUri attribute
		String uri = config.getAttribute(XmlConfig.A_NAMESPACE_URI);

		}
		
		IConfigurationElement[] pkgs = config.getChildren(XmlConfig.E_PACKAGE);
		for (IConfigurationElement element : pkgs) {
			uri = element.getAttribute(XmlConfig.A_NAMESPACE_URI);
			if (uri != null) {
				uri = uri.trim();
				

			throw e;
		}
		
		nsUris = uriSet.toArray(new String[uriSet.size()]);
		nsUriMatchers = uriMatcherMap.values().toArray(new StringMatcher[uriMatcherMap.size()]);
			new StringMatcher[uriMatcherMap.size()]);
		
		String shouldCache = config.getAttribute(XmlConfig.A_CACHE);
		shouldCacheConstraints = (shouldCache == null)

	 * @return the evaluation mode, or {@link EvaluationMode#NULL} if the
	 *     provider provides constraints in mixed modes
	 */
	private EvaluationMode<?> getMode() {
		return mode;
	}


	 * @return whether the provider has any chance of providing constraints
	 *     for this context
	 */
	public boolean provides(
			IProviderOperation<? extends Collection<? extends IModelConstraint>> operation) {
		if (operation instanceof GetLiveConstraintsOperation) {
			return providesLiveConstraints(operation);
		} else if (operation instanceof GetBatchConstraintsOperation) {

	 *    <CODE>true</CODE>, otherwise 
	 */
	private boolean providesLiveConstraints(
			IProviderOperation<? extends Collection<? extends IModelConstraint>> operation) {
		
		Trace.entering(
				EMFModelValidationDebugOptions.PROVIDERS,

			} else {
				EObject eObject = op.getEObject();
	
				for (IConfigurationElement next : targets) {
					IConfigurationElement next = targets[i];
	
					if (isLive()
							&& providerHandlesEObject(eObject, next)
							&& providerHandlesEvent(op.getEventType(), next)) {

	 *    <CODE>true</CODE>, otherwise 
	 */
	private boolean providesBatchConstraints(
			IProviderOperation<? extends Collection<? extends IModelConstraint>> operation) {
		
		Trace.entering(
				EMFModelValidationDebugOptions.PROVIDERS,

			} else {
				EObject eObject = op.getEObject();
	
				for (IConfigurationElement next : targets) {
					IConfigurationElement next = targets[i];
	
					if (providerHandlesEObject(eObject, next)) {
						result = true;
						break;

		EPackage epkg = eObject.eClass().getEPackage();
		String targetNsUri = epkg.getNsURI();
		
        Boolean result = providedNamespaces.get(targetNsUri);
        if (result == null) {
            result = providerHandlesNamespace(targetNsUri, targetNsUri);

            if (result == null) {
                // look for EPackages that this package extends
                Set<EPackage> extended = getExtendedEPackages(epkg);

                if (!extended.isEmpty()) {
                    for (Iterator<EPackage> iter = extended.iterator(); iter.hasNext()
                        && (result == null);) {
                        
                        EPackage next = iter.next();
                        result = providerHandlesNamespace(targetNsUri, next
                            .getNsURI());
                    }

     * @return all of the packages containing classifiers extended by this
     *         package's classifiers, not including the original package
     */
    private Set<EPackage> getExtendedEPackages(EPackage epackage) {
        Set<EPackage> result = new java.util.HashSet<EPackage>();

        getExtendedEPackages(epackage, result);
        result.remove(epackage);

     * Recursive helper implementation of
     * {@link #getExtendedEPackages(EPackage)}.
     */
    private void getExtendedEPackages(EPackage epackage, Set<EPackage> result) {
        for (Object next : epackage.getEClassifiers()) {
            .hasNext();) {
            Object next = iter.next();

            if (next instanceof EClass) {
                for (EClass zuper : ((EClass) next).getESuperTypes()) {
                    EPackage nextPackage = zuper.getEPackage();
                    EPackage nextPackage = ((EClass) jter.next()).getEPackage();

                    if ((nextPackage != epackage)
                        && !result.contains(nextPackage)) {

			// it is implied that all events are supported
			result = true;
		} else {
			for (IConfigurationElement element : events) {
				final String eventName = element.getAttribute(
						XmlConfig.A_NAME);
				
				if (eventType.getName().equalsIgnoreCase(eventName)) {

	 * @return the evaluation mode of the constraint provider, or
	 *    {@link EvaluationMode#NULL} if it has none
	 */
	private EvaluationMode<?> getMode(IConfigurationElement config) {
		String result = config.getAttribute(XmlConfig.A_MODE);

		if (result == null) {

	}
	
	// redefines the inherited method
	@Override
	public String toString() {
		StringBuffer result = new StringBuffer(64);
		




import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.validation.EMFEventType;
import org.eclipse.emf.validation.model.IModelConstraint;
import org.eclipse.emf.validation.service.IModelConstraintProvider;

/**

	
	private EMFEventType eventType;
	private Notification notification;
	private List<Notification> allEvents;
	
	/**
	 * Initializes me.

	 * 
	 * @param events the {@link Notification}s
	 */
	protected void setAllEvents(List<? extends Notification> events) {
		this.allEvents = Collections.unmodifiableList(events);
	}


	 * 
	 * @return the events
	 */
	public final List<Notification> getAllEvents() {
		return allEvents;
	}
	

	}

	// implements the inherited method
	@Override
	protected void executeImpl(
			IModelConstraintProvider provider,
			Collection<IModelConstraint> constraints) {
		assert provider != null;

		provider.getLiveConstraints(getNotification(), constraints);
	}
	
	// implements the inherited method
	@Override
	protected AbstractValidationContext createContext() {
		return new AbstractValidationContext(this) {
			// re-implements the inherited method
			@Override
			public EStructuralFeature getFeature() {
				EStructuralFeature result = null;
				

			/*
			 * Redefines the inherited method.
			 */
			@Override
			public Object getFeatureNewValue() {
				Object result = null;
				

			}
			
			// re-implements the inherited method
			@Override
			public EMFEventType getEventType() {
				return GetLiveConstraintsOperation.this.getEventType();
			}
			
			// re-implements the inherited method
			@Override
			public List<Notification> getAllEvents() {
				return GetLiveConstraintsOperation.this.getAllEvents();
			}

			@Override
			public Notification getNotification() {
				return GetLiveConstraintsOperation.this.getNotification();
			}};




	private static final TraversalStrategyManager INSTANCE =
		new TraversalStrategyManager();
	
	private final Map<String, Descriptor> packageDescriptors =
	    new java.util.HashMap<String, Descriptor>();
	
	/**
	 * Not instantiated by clients.

	 * @return the corresponding descriptor
	 */
	private Descriptor getDescriptor(String nsUri) {
		Descriptor result = packageDescriptors.get(nsUri);
		
		if (result == null) {
			result = new Descriptor(nsUri);

	 */
	private static class Descriptor {
		private final String nsUri;
		private Map<Object, ThreadLocal<ITraversalStrategy>> eclassMap =
		    new java.util.HashMap<Object, ThreadLocal<ITraversalStrategy>>();
		private ThreadLocal<ITraversalStrategy> packageDefaultStrategy;
		private boolean isResolved;
		
		/**

		 * Determines whether <code>other</code> is a descriptor for the
		 * same EPackage as me. 
		 */
		@Override
        public boolean equals(Object other) {
			return (other instanceof Descriptor) && 
				getNamespaceUri().equals(
					((Descriptor)other).getNamespaceUri());
		}
		
		// overrides the inherited implementation
		@Override
        public int hashCode() {
			return getNamespaceUri().hashCode();
		}
		

		 */
		void addTraversalStrategy(IConfigurationElement config) {
			IConfigurationElement[] eclasses = config.getChildren(E_ECLASS);

            ThreadLocal<ITraversalStrategy> strategy =
                new ThreadLocalLazyStrategy(config);
			
			if ((eclasses.length == 0) && (packageDefaultStrategy == null)) {
				// can only have one wildcard strategy
				packageDefaultStrategy = strategy;
			} else {
				for (int i = 0; i < eclasses.length; i++) {
					IConfigurationElement next = eclasses[i];

					
					if (!eclassMap.containsKey(eclassName)) {
						// take the first one registered against a name
						eclassMap.put(eclassName, strategy);
					}
				}
			}

		private void resolve(EPackage ePackage) {
			isResolved = true;
			
			Map<Object, ThreadLocal<ITraversalStrategy>> newMap =
			    new java.util.HashMap<Object, ThreadLocal<ITraversalStrategy>>();
			
			for (Map.Entry<Object, ThreadLocal<ITraversalStrategy>> next : eclassMap.entrySet()) {
				Map.Entry next = (Map.Entry)iter.next();
				String eclassName = (String)next.getKey();
				
				EClassifier eclass = ePackage.getEClassifier(eclassName);
				if (eclass instanceof EClass) {
					newMap.put(eclass, next.getValue());
					    (IConfigurationElement) next.getValue()));
				} else {
					// not a valid eclass
					Log.warningMessage(

    				resolve(eclass.getEPackage());
    			}
    			
    			ThreadLocal<ITraversalStrategy> strategy = eclassMap.get(eclass);
				
    			if (strategy == null) {
    				strategy = inheritStrategy(eclass);
    				eclassMap.put(eclass, strategy);
    			}
                
                return strategy.get();
			}
		}
		

		 * @return the inherited strategy, or the package's default, if none
		 *     better is found
		 */
		private ThreadLocal<ITraversalStrategy> inheritStrategy(EClass eclass) {
		    ThreadLocal<ITraversalStrategy> result = getInheritedStrategy(eclass);
			
			if (result == null) {
				// use the wildcard strategy

		 * @return the inherited strategy, or <code>null</code> if none was
		 *     provided by any extension point
		 */
		private ThreadLocal<ITraversalStrategy> getInheritedStrategy(EClass eclass) {
		    ThreadLocal<ITraversalStrategy> result = null;
			
			for (Iterator<EClass> iter = eclass.getESuperTypes().iterator();
					(result == null) && iter.hasNext();) {
				
				EClass next = iter.next();
				
				if (eclassMap.containsKey(next)) {
					result = eclassMap.get(next);
				} else {
					result = getInheritedStrategy(next);
				}

			// replace all ocurrences of the configuration element with the
			//   newly instantiated traversal strategy for future look-ups
			if (packageDefaultStrategy != null) {
			    ((ThreadLocalLazyStrategy) packageDefaultStrategy).preinitialize(result, config);
			}
			
			for (Object next : eclassMap.values()) {
				((ThreadLocalLazyStrategy) next).preinitialize(result, config);
				
				next.preinitialize(result, config);
			}
			
			return result;
		}
		
		private class ThreadLocalLazyStrategy extends ThreadLocal<ITraversalStrategy> {
		    private final IConfigurationElement config;
            
            ThreadLocalLazyStrategy() {

		        this.config = config;
		    }
		    
		    @Override
            protected ITraversalStrategy initialValue() {
		        return (config == null)? new ITraversalStrategy.Recursive() :
		            initializeStrategy(config);
		    }




	
	private static final ClientContextManager INSTANCE = new ClientContextManager();
	
	private final Set<IClientContext> clientContexts = new java.util.HashSet<IClientContext>();
	private final Map<String, IClientContext> clientContextMap = new java.util.HashMap<String, IClientContext>();
	
	private final Set<IClientContext> defaultContexts = new java.util.HashSet<IClientContext>();
	
	/**
	 * Not instantiable by clients.

	 *     under this ID
	 */
	public IClientContext getClientContext(String contextId) {
		return clientContextMap.get(contextId);
	}
	
	/**

	 * 
	 * @return the available {@link IClientContext}s
	 */
	public Set<IClientContext> getClientContexts() {
		return clientContexts;
	}


	 *    <code>eObject</code> belongs.  This may be empty if no context
	 *    selector matches this element
	 */
	public Collection<IClientContext> getClientContextsFor(EObject eObject) {
		Collection<IClientContext> result = new java.util.ArrayList<IClientContext>();
		
		EvaluationContext ctx = new EvaluationContext(null, eObject);
		
		for (Iterator<IClientContext> iter = getClientContexts().iterator(); iter.hasNext();) {
			IClientContext next = iter.next();
			IClientSelector selector = next.getSelector();
			
			final Object toTest = (selector instanceof XmlExpressionSelector)

	 * @return the {@link IModelConstraint}s from amongst the specified
	 *     <code>constraints</code> that are bound to the <code>context</code>
	 */
	public Collection<IModelConstraint> getBindings(EObject eObject,
			Collection<? extends IModelConstraint> constraints) {
		
		Collection<IModelConstraint> result;
		
		Collection<IClientContext> contexts = getClientContextsFor(eObject);
		
		if (contexts.isEmpty()) {
			// no context recognizes this object?  Oh, well, then there are
			//   no constraints
			result = Collections.emptyList();
		} else if (contexts.size() == 1) {
			// easy when there's just one context
			result = getBindings(contexts.iterator().next(), constraints); 
				(IClientContext) contexts.iterator().next(),
				constraints); 
		} else {
			// multiple contexts require more looping
			result = getBindings(contexts, constraints);

	 * @return the {@link IModelConstraint}s from amongst the specified
	 *     <code>constraints</code> that are bound to the <code>context</code>
	 */
	public Collection<IModelConstraint> getBindings(IClientContext context,
			Collection<? extends IModelConstraint> constraints) {
		
		Collection<IModelConstraint> result = new java.util.ArrayList<IModelConstraint>(
				constraints.size());
		
		for (IModelConstraint constraint : constraints) {
			if (context.includes(constraint)) {
				result.add(constraint);
			} else if (context.isDefault()) {

	 * @return the {@link IModelConstraint}s from amongst the specified
	 *     <code>constraints</code> that are bound to the <code>context</code>
	 */
	public Collection<IModelConstraint> getBindings(
			Collection<? extends IClientContext> contexts,
			Collection<? extends IModelConstraint> constraints) {
		
		Collection<IModelConstraint> result = new java.util.ArrayList<IModelConstraint>(
				constraints.size());
		
		// use an array for performance (to avoid creating so many iterators)
		IClientContext[] ctxArray = contexts.toArray(new IClientContext[contexts.size()]);
			new IClientContext[contexts.size()]);
		
		// in case we don't find an explicit binding, we need to know whether
		//   we need to look for default bindings.  This will only be the case
		//   if any of the current contexts is default
		boolean anyContextIsDefault = false;
		
		for (IModelConstraint constraint : constraints) {
			IModelConstraint constraint = (IModelConstraint) iter.next();
			boolean bound = false;
			
			for (IClientContext element : ctxArray) {
				bound = element.includes(constraint);
				
				if (bound) {
					result.add(constraint);
					break;  // needn't look at any more contexts
				} else if (element.isDefault()) {
					// no need to check for default contexts as long as we
					//   find explicit bindings
					anyContextIsDefault = true;

		boolean result = true;
		String id = constraint.getDescriptor().getId();
		
		for (Iterator<IClientContext> iter = clientContexts.iterator();
				result && iter.hasNext();) {
			
			result = !iter.next().includes(constraint);
		}
		
		if (result) {
			// add the constraint to all default contexts so that we don't do
			//   this computation again
			for (IClientContext next : defaultContexts) {
				((ClientContext) next).bindConstraint(id);
			}
		}
		

	 *     <code>constraintBindings</code> extension point
	 */
	private void configureClientContexts(IConfigurationElement[] elements) {
		for (IConfigurationElement config : elements) {
			IConfigurationElement config = elements[i];
			
			if (E_CLIENT_CONTEXT.equals(config.getName())) {
				try {
					ClientContext context = new ClientContext(config);

	 *     <code>constraintBindings</code> extension point
	 */
	private void configureBindings(IConfigurationElement[] elements) {
		for (IConfigurationElement config : elements) {
			IConfigurationElement config = elements[i];
			
			if (E_BINDING.equals(config.getName())) {
				String contextId = config.getAttribute(A_CONTEXT);
				

		}
		
		IConfigurationElement[] children = config.getChildren(A_CONSTRAINT);
		for (IConfigurationElement element : children) {
			final String ref = element.getAttribute(A_REF);
			
			if (ref == null) {
				Log.warningMessage(

		}
		
		children = config.getChildren(A_CATEGORY);
		for (IConfigurationElement element : children) {
			final String ref = element.getAttribute(A_REF);
			
			if (ref == null) {
				Log.errorMessage(

Lines 12-17 Link Here

(-)src/org/eclipse/emf/validation/internal/service/IProviderDescriptor.java (-1 / +5 lines)
12		12
13	package org.eclipse.emf.validation.internal.service;	13	package org.eclipse.emf.validation.internal.service;
14		14
		15	import java.util.Collection;
		16
		17	import org.eclipse.emf.validation.model.IModelConstraint;
15	import org.eclipse.emf.validation.service.IModelConstraintProvider;	18	import org.eclipse.emf.validation.service.IModelConstraintProvider;
16		19
17	/**	20	/**
Lines 33-39 Link Here
33	* @return whether the provider has any chance of providing constraints	36	* @return whether the provider has any chance of providing constraints
34	* for this context	37	* for this context
35	*/	38	*/
36	boolean provides(IProviderOperation operation);	39	boolean provides(
		40	IProviderOperation<? extends Collection<? extends IModelConstraint>> operation);
37		41
38	/**	42	/**
39	* Queries whether the system should cache constraints retrieved from	43	* Queries whether the system should cache constraints retrieved from




 *
 * @author Christian W. Damus (cdamus)
 */
abstract class AbstractValidator<T> implements IValidator<T> {
	private final EvaluationMode<T> mode;
	private final Map<String, Object> clientData = new java.util.HashMap<String, Object>();
	private final IProviderOperationExecutor<Collection<IModelConstraint>> executor;
	
	private boolean reportSuccesses = false;
	
	private Collection<IConstraintFilter> filters = null;
	
	/**
	 * Initializes me with the evaluation <code>mode</code> that I support and

	 *      <code>null</code>)
	 */
	protected AbstractValidator(
			EvaluationMode<T> mode,
			IProviderOperationExecutor<Collection<IModelConstraint>> executor) {
		assert mode != null && !mode.isNull();
		assert executor != null;
		

	/* (non-Javadoc)
	 * Implements the inherited method.
	 */
	public final EvaluationMode<T> getEvaluationMode() {
		return mode;
	}


	 * validation API is also encouraged to delegate to this method after
	 * first checking that arguments are of or coerced to the correct types.
	 */
	public final IStatus validate(T object) {
		return validate(Collections.singleton(object));
	}


	 * returns an appropriate {@link IStatus#CANCEL} status when it catches one.
	 * </p>
	 */
	public final IStatus validate(Collection<? extends T> objects) {
		IStatus result;
		
		Set<IClientContext> encounteredClientContexts = new HashSet<IClientContext>();
		
		try {
			result = createStatus(doValidate(objects, encounteredClientContexts));

	 * @return The client contexts ids provided to this validator by the last call
	 *  to the {@link #evaluateConstraints(AbstractValidationContext, List) method.
	 */
	private Collection<String> getClientContextIds(Collection<IClientContext> clientContexts) {
		List<String> contextIds = new ArrayList<String>();
		
		if (clientContexts == null) {
			return contextIds;
		}
		
		for (IClientContext context : clientContexts) {
			IClientContext context = (IClientContext)i.next();
			contextIds.add(context.getId());
		}
		
		return contextIds;
	}


	 *     canceled (e.g., when a constraint returns
	 *     {@link IStatus#CANCEL} status)
	 */
	protected abstract Collection<IStatus> doValidate(Collection<? extends T> objects,
		Set<IClientContext> clientContexts);
	
	/**
	 * Helper method to evaluate a bunch of constraints.  Disabled constraints

	 */
	protected IStatus evaluateConstraints(
			AbstractValidationContext ctx,
			List<IStatus> results) {
		IStatus resultStatus = Status.OK_STATUS;
		
		for (Object element : ctx.getConstraints()) {
			IModelConstraint next = (IModelConstraint)element;

			if (!acceptConstraint(next.getDescriptor(), ctx.getTarget())) {
				continue;

	 * 
	 * @param operation the operation to execute
	 */
	protected final void execute(
			IProviderOperation<Collection<IModelConstraint>> operation) {
		getOperationExecutor().execute(operation);
	}
	

	 * 
	 * @return my operation executor
	 */
	private IProviderOperationExecutor<Collection<IModelConstraint>> getOperationExecutor() {
		return executor;
	}
	

	 * @return a multi-status if more than one result; a plain {@link IStatus},
	 *     otherwise
	 */
	private IStatus createStatus(Collection<IStatus> results) {	
		if (results.isEmpty()) {
			return new org.eclipse.core.runtime.Status(
				IStatus.OK,

				EMFModelValidationStatusCodes.NO_CONSTRAINTS_EVALUATED_MSG,
				null);
		} else if (results.size() == 1) {
			return results.iterator().next();
		} else {
			return new AggregateStatus(results);
		}


	private boolean acceptConstraint(IConstraintDescriptor constraint, EObject target) {
        if (filters != null) {
    		for (Object element : filters) {
    			IConstraintFilter filter = (IConstraintFilter)element;
                
    			if (!filter.accept(constraint, target)) {
    				return false;


	public void addConstraintFilter(IConstraintFilter filter) {
		if (filters == null) {
			filters = new BasicEList<IConstraintFilter>(4);
		}
        
		filters.add(filter);

        }
    }
    
	public Collection<IConstraintFilter> getConstraintFilters() {
		if (filters == null) {
			return Collections.emptyList();
		}
        
		return Collections.unmodifiableCollection(filters);

	 * @author Christian W. Damus (cdamus)
	 */
	private static class AggregateStatus implements IStatus {
		private final Collection<? extends IStatus> children;
		private final int severity;
		private final int code;
		private final String message;

		 * 
		 * @param statuses the statuses that I aggregate
		 */
		AggregateStatus(Collection<? extends IStatus> statuses) {
			// aggregate the results into a multi-status

			int maxSeverity = getMaximalSeverity(statuses);

		
		// implements the interface method
		public IStatus[] getChildren() {
			return children.toArray(new IStatus[children.size()]);
		}

		// implements the interface method

		 * @param statuses a collection of {@link IStatus} objects
		 * @return the maximal severity amongst the <code>statuses</code>
		 */
		private int getMaximalSeverity(Collection<? extends IStatus> statuses) {
			int result = IStatus.OK;
		
			for (Iterator<? extends IStatus> iter = statuses.iterator();
					(result < IStatus.ERROR) && iter.hasNext();) {
			
				IStatus next = iter.next();
			
				if (next.getSeverity() > result) {
					result = next.getSeverity();

Lines 16-29 Link Here

(-)src/org/eclipse/emf/validation/internal/service/IProviderOperation.java (-3 / +6 lines)
16		16
17	import org.eclipse.emf.ecore.EObject;	17	import org.eclipse.emf.ecore.EObject;
18		18
		19	import org.eclipse.emf.validation.model.IModelConstraint;
19	import org.eclipse.emf.validation.service.IModelConstraintProvider;	20	import org.eclipse.emf.validation.service.IModelConstraintProvider;
20		21
21	/**	22	/**
22	* Interface describing an {@link IModelConstraintProvider} operation.	23	* Interface describing an {@link IModelConstraintProvider} operation.
23	*	24	*
		25	* @param <T> the result type of the operation
		26	*
24	* @author Christian W. Damus (cdamus)	27	* @author Christian W. Damus (cdamus)
25	*/	28	*/
26	public interface IProviderOperation {	29	public interface IProviderOperation<T> {
27	/**	30	/**
28	* Obtains the EMF object that is to be validated.	31	* Obtains the EMF object that is to be validated.
29	*	32	*
Lines 37-43 Link Here
37	*	40	*
38	* @return the constraints	41	* @return the constraints
39	*/	42	*/
40	Collection getConstraints();	43	Collection<IModelConstraint> getConstraints();
41		44
42	/**	45	/**
43	* Executes me on the specified constraint <code>provider</code>.	46	* Executes me on the specified constraint <code>provider</code>.
Lines 45-49 Link Here
45	* @param provider a constraint provider	48	* @param provider a constraint provider
46	* @return my {@link #getConstraints constraints collection}	49	* @return my {@link #getConstraints constraints collection}
47	*/	50	*/
48	Object execute(IModelConstraintProvider provider);	51	T execute(IModelConstraintProvider provider);
49	}	52	}

Lines 29-34 Link Here

(-)src/org/eclipse/emf/validation/internal/service/ValidationCanceledException.java (+2 lines)
29	* @author Christian W. Damus (cdamus)	29	* @author Christian W. Damus (cdamus)
30	*/	30	*/
31	public class ValidationCanceledException extends RuntimeException {	31	public class ValidationCanceledException extends RuntimeException {
		32	private static final long serialVersionUID = -2541909077699487325L;
		33
32	private final IStatus status;	34	private final IStatus status;
33		35
34	/**	36	/**




	private final boolean isDefault;
	
	// set of String constraint IDs that are bound to me
	private final Set<String> constraintBindings = new java.util.HashSet<String>();
	
	// set of String category IDs that are bound to me
	private final Set<String> categoryBindings = new java.util.HashSet<String>();
	
	/**
	 * Initializes me with my XML configuration.

	 * @return <code>true</code> if any of the <code>categories</code> is bound,
	 *     or if any of their ancestors is bound; <code>false</code>, otherwise
	 */
	private boolean hasCategoryBinding(Collection<Category> categories) {
		boolean result = false;
		
		for (Iterator<Category> iter = categories.iterator(); !result && iter.hasNext();) {
			Category category = iter.next();
			
			result = categoryBindings.contains(category.getPath());
			

	/**
	 * The context ID fully determines equality.
	 */
	@Override
	public boolean equals(Object obj) {
		return (obj instanceof ClientContext)
			&& ((ClientContext) obj).getId().equals(getId());

	/**
	 * The context ID fully determines equality.
	 */
	@Override
	public int hashCode() {
		return getId().hashCode();
	}
	
	@Override
	public String toString() {
		return "ClientContext[" + getId() + ']'; //$NON-NLS-1$
	}




import java.util.Collections;
import java.util.List;

import org.eclipse.emf.common.util.Enumerator;

/**
 * Enumeration for a constraint change event type.

 * 
 * @author David Cummings (dcummin)
 */
public enum ConstraintChangeEventType
	implements Enumerator {

	private static final long serialVersionUID = 1L;

	/**
	 * An internal unique identifier for this enumerated type.
	 */
	private static int nextOrdinal = 0;

	/**
	 * Registered constraint change event type
	 */
	REGISTERED("Registered"), //$NON-NLS-1$
		"Registered"); //$NON-NLS-1$

	/**
	 * Unregistered constraint change event type
	 */
	UNREGISTERED ("Unregistered"), //$NON-NLS-1$
		"Unregistered"); //$NON-NLS-1$

	/**
	 * Enabled constraint change event type
	 */
	ENABLED("Enabled"), //$NON-NLS-1$
		"Enabled"); //$NON-NLS-1$
	
	/**
	 * Disabled constraint change event type
	 */
	DISABLED("Disabled"), //$NON-NLS-1$
		"Disabled"); //$NON-NLS-1$
	
	/**
	 * Added category constraint change event type
	 */
	ADDED_CATEGORY("Added Category"), //$NON-NLS-1$
		"Added Category"); //$NON-NLS-1$
	
	/**
	 * Removed category constraint change event type
	 */
	REMOVED_CATEGORY ("Removed Category"); //$NON-NLS-1$
		"Removed Category"); //$NON-NLS-1$


	private static final long serialVersionUID = 1L;
	
	private static final ConstraintChangeEventType[] VALUES = { REGISTERED,
																UNREGISTERED,

																ADDED_CATEGORY,
																REMOVED_CATEGORY };

	private final String name;
	
	/**
	 * Constructs a new constraint change event type with the specified name and
	 * ordinal.
	 * 
	 * @param name The name of the constraint change event type
	 * @param ordinal The ordinal for the constraint change event type.
	 */
	private ConstraintChangeEventType(String name, int ordinal) {
		super(ordinal, name);
	}

	/**
	 * Constructs a new constraint change event type with the specified name.
	 * 
	 * @param name The name of the new constraint change event type.
	 */
	private ConstraintChangeEventType(String name) {
		this.name = name;
	}

	/**

	 * 
	 * @return an unmodifiable collection of the event types
	 */
	protected List<ConstraintChangeEventType> getValues() {
		return Collections.unmodifiableList(Arrays.asList(VALUES));
	}
	
	public int getValue() {
		return ordinal();
	}
	
	public String getLiteral() {
		return getName();
	}
	
	public String getName() {
		return name;
	}
}




 * 
 * @author Christian W. Damus (cdamus)
 */
public interface IBatchValidator extends IValidator<EObject> {
	/**
	 * <p>
	 * Queries whether I also evaluate applicable live constraints on each

	 * @return the validation status
	 * @see IValidator#validate(Object)
	 */
	IStatus validate(Collection<? extends EObject> eObjects, IProgressMonitor monitor);
	
	/**
	 * Validates a single {@link EObject EMF element} without using any
	 * progress monitor.
	 * 
	 * @param object the object to validate
	 * @throws ClassCastException if <code>object</code> is not an
	 *     {@link org.eclipse.emf.ecore.EObject}
	 */
	IStatus validate(EObject eobject);
	
	/**
	 * Validates multiple {@link EObject EMF elements} without using any

	 * @throws ClassCastException if any of the <code>objects</code> is
	 *     not an {@link org.eclipse.emf.ecore.EObject}
	 */
	IStatus validate(Collection<? extends EObject> objects);
}




/******************************************************************************
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

/**
 * Event notifying {@link IValidationListener}s that a validation operation
 * has occurred.
 * 
 * @author Christian W. Damus (cdamus)
 */
public final class ValidationEvent


	private static final long serialVersionUID = -7900125537603879206L;
	
	private final EvaluationMode<?> mode;
	private final Map<String, ?> clientData;
	private final IStatus status;
	private final Collection<?> targets;
	private List<IConstraintStatus> results;
	
	private Collection<String> clientContextIds = null;
	
	/**
	 * Initializes me with the evaluation mode, client data, elements or
	 * notifications validated, and validation results that I will pass along
	 * to listeners.
	 * 
	 * @param <T> the kind of objects that were validated
	 * 
	 * @param mode the evaluation mode
	 * @param clientData data specific to the particular validation client
	 *      that performed the validation wishes to make available to listeners

	 *      mode) that were validated
	 * @param status the validation results
	 */
	public <T> ValidationEvent(
		EvaluationMode<T> mode,
		Map<String, ?> clientData,
		Collection<? extends T> targets,
		IStatus status) {
		
		super(ModelValidationService.getInstance());

		this.targets = Collections.unmodifiableCollection(targets);
		
		if (clientData == null) {
			this.clientData = Collections.emptyMap();
		} else {
			this.clientData = Collections.unmodifiableMap(clientData);
		}

	/**
	 * Initializes me with the evaluation mode, client data, elements or
	 * notifications validated, and validation results that I will pass along
	 * to listeners. Also, I will be initialized with the client context IDs
	 * that were involved in the validation.
	 * 
	 * 
	 * @param <T> the kind of objects that were validated
	 * 
	 * @param mode the evaluation mode
	 * @param clientData data specific to the particular validation client
	 *      that performed the validation wishes to make available to listeners

	 * @param clientContextIds the client context Ids that were involved in the
	 *  validation.
	 */
	public <T> ValidationEvent(
		EvaluationMode<T> mode,
		Map<String, ?> clientData,
		Collection<? extends T> targets,
		IStatus status,
		Collection<String> clientContextIds) {
		
		this(mode,clientData,targets,status);
		

	 * @return A collection of the client context ids in String form. These
	 *  ids should not be modified in any way as they may affect other listeners.
	 */
	public Collection<String> getClientContextIds() {
		if (clientContextIds == null) {
			clientContextIds = Collections.emptyList();
		}
		return clientContextIds;
	}

	 * @return the evaluation mode; never <code>null</code> or
	 *     even {@link EvaluationMode#NULL}
	 */
	public EvaluationMode<?> getEvaluationMode() {
		return mode;
	}
	

	 * 
	 * @return an unmodifiable mapping of client data
	 */
	public Map<String, ?> getClientData() {
		return clientData;
	}
	

	 * 
	 * @see #getValidationResults()
	 */
	public Collection<?> getValidationTargets() {
		return targets;
	}
	

	 * 
	 * @see #getValidationTargets()
	 */
	public List<IConstraintStatus> getValidationResults() {
		if (results == null) {
			// lazily compute the results
			if (status.isMultiStatus()) {
				IStatus[] children = status.getChildren();
				results = new java.util.ArrayList<IConstraintStatus>(children.length);
				for (IStatus element : children) {
					if (element instanceof IConstraintStatus) {
						results.add((IConstraintStatus) element);
					}
				}
				results = Collections.unmodifiableList(results);
			} else if (status instanceof IConstraintStatus) {
				results = Collections.singletonList((IConstraintStatus) status);
			} else {
				results = Collections.emptyList();
			}
		}
		




package org.eclipse.emf.validation.service;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;

			IExecutableExtension {

	private String[] namespaceUris;
	private final List<IModelConstraint> myConstraints = new java.util.ArrayList<IModelConstraint>();
	
	/**
	 * A proxy for a lazily instantiated implementation of the

			
			// replace me with my delegate in the list of constraints, to avoid
			//   the delegation in future invocations and to free some memory
			for (ListIterator<IModelConstraint> iter = getConstraints().listIterator();
					iter.hasNext();) {
				
				if (iter.next() == this) {

	 * 
	 * @since 1.1
	 */
	protected List<IModelConstraint> getConstraints() {
		return myConstraints;
	}
	

			String propertyName,
			Object data) throws CoreException {
		
		Set<String> uris = new java.util.HashSet<String>();
		
		// backwards compatibility to the namespaceUri attribute
		String uri = config.getAttribute(

		
		IConfigurationElement[] pkgs = config.getChildren(XmlConfig.E_PACKAGE);
		
		for (IConfigurationElement element : pkgs) {
			uri = element.getAttribute(XmlConfig.A_NAMESPACE_URI);
			if (uri != null) {
				uris.add(uri.trim());
			}

			throw e;
		}
		
		namespaceUris = uris.toArray(new String[uris.size()]);
	}
	
	/**
	 * @since 1.1
	 */
	public Collection<IModelConstraint> getLiveConstraints(
			Notification notification,
			Collection<IModelConstraint> constraints) {
		
		assert notification != null;
		

			Trace.entering(getClass(), "getLiveConstraints"); //$NON-NLS-1$
		}
		
		Collection<IModelConstraint> result = constraints;

		if (result == null) {
			result = new java.util.ArrayList<IModelConstraint>();
		}
		
		if (notification.getNotifier() instanceof EObject) {
			EObject eObject = (EObject)notification.getNotifier();
			
			for (IModelConstraint next : getConstraints()) {
				IModelConstraint next = (IModelConstraint)iter.next();
				IConstraintDescriptor desc = next.getDescriptor();
	
				if (desc.isLive() && desc.targetsTypeOf(eObject)

	/**
	 * @since 1.1
	 */
	public Collection<IModelConstraint> getBatchConstraints(
			EObject eObject,
			Collection<IModelConstraint> constraints) {		
		
		if (Trace.shouldTraceEntering(EMFModelValidationDebugOptions.PROVIDERS)) {
			Trace.entering(getClass(), "getBatchConstraints"); //$NON-NLS-1$
		}
		
		Collection<IModelConstraint> result = constraints;

		if (result == null) {
			result = new java.util.ArrayList<IModelConstraint>();
		}

		for (IModelConstraint next : getConstraints()) {
			IModelConstraint next = (IModelConstraint)iter.next();
			IConstraintDescriptor desc = next.getDescriptor();

			if (desc.isBatch() && desc.targetsTypeOf(eObject)) {

	 * 
	 * @since 1.2
	 */
	protected void registerConstraints(
	        Collection<? extends IModelConstraint> constraints)
	        throws ConstraintExistsException {
	    
	    if (!constraints.isEmpty()) {
    	    List<IConstraintDescriptor> descriptors =
    	        new java.util.ArrayList<IConstraintDescriptor>(constraints.size());
    	    
    	    for (IModelConstraint next : constraints) {
    	        descriptors.add(next.getDescriptor());
    	    }
    	    
    	    ConstraintRegistry.getInstance().bulkRegister(descriptors);




package org.eclipse.emf.validation.service;

import java.util.Collection;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.emf.validation.internal.EMFModelValidationDebugOptions;

public class ConstraintRegistry {
	private static final ConstraintRegistry INSTANCE = new ConstraintRegistry();
	
	private final Map<String, IConstraintDescriptor> descriptors =
	    new java.util.HashMap<String, IConstraintDescriptor>();
	
	private volatile IConstraintListener[] constraintListeners;
	

	 *     does not exist
	 */
	public IConstraintDescriptor getDescriptor(String id) {
		return descriptors.get(id);
	}
	
	/**

	 *     does not exist
	 */
	public IConstraintDescriptor getDescriptor(String pluginId, String id) {
		return descriptors.get(
				XmlConstraintDescriptor.normalizedId(pluginId, id));
	}
	

	 * @return the available constraint descriptors, as an unmodifiable
	 *     collection
	 */
	public Collection<IConstraintDescriptor> getAllDescriptors() {
	    synchronized (descriptors) {
	        return new java.util.ArrayList<IConstraintDescriptor>(descriptors.values());
	    }
	}
	

	 * @throws ConstraintExistsException if any constraint's ID is already
	 *    registered under a different descriptor
	 */
	void bulkRegister(Collection<? extends IConstraintDescriptor> constraints)
	throws ConstraintExistsException {
	    Collection<IConstraintDescriptor> registered =
	        new java.util.ArrayList<IConstraintDescriptor>(constraints.size());
	    
	    synchronized (descriptors) {
    	    for (IConstraintDescriptor next : constraints) {
    	        IConstraintDescriptor next = (IConstraintDescriptor) iter.next();
    	        
    	        if (doRegister(next)) {
    	            registered.add(next);
    	        }

	        ConstraintChangeEvent event =
	            new ConstraintChangeEvent(null, ConstraintChangeEventType.REGISTERED);
	        
    	    for (IConstraintDescriptor next : registered) {
    	        event.setConstraint(next);
                broadcastConstraintChangeEvent(event);
    	    }
	    }





import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.validation.model.IModelConstraint;

/**
 * <p>

	 *        <CODE>constraints </CODE> parameter (with additions), or a new
	 *        collection if <CODE>constraints == null</CODE>
	 */
	Collection<IModelConstraint> getBatchConstraints(EObject eObject,
		Collection<IModelConstraint> constraints);

	/**
	 * Obtains a collection of live

	 *        <CODE>constraints </CODE> parameter (with additions), or a new
	 *        collection if <CODE>constraints == null</CODE>
	 */
	Collection<IModelConstraint> getLiveConstraints(
			Notification notification,
			Collection<IModelConstraint> constraints);
}




 * 
 * @author Christian W. Damus (cdamus)
 */
public interface ILiveValidator extends IValidator<Notification> {
	/**
	 * Validates the specified {@link Notification EMF event}.  This method is a
	 * synonym for the inherited {@link IValidator#validate(Object)}.

	 */
	IStatus validate(Notification notification);
	
	/**
	 * {@inheritDoc}
	 * 
	 * @param object must be a {@link Notification}
	 * @throws ClassCastException if <code>object</code> is not a
	 *      {@link Notification}
	 */
	IStatus validate(Object object);
	
    /**
     * Obtains a filter that is used to determine which notifications will be
     * validated (passed on to constraints to check).  The default filter, if

     * 
     * @since 1.1
     */
    FilteredCollection.Filter<Notification> getNotificationFilter();
    
	/**
	 * Sets the filter that is used to determine which notifications will be

     * 
     * @since 1.1
	 */
	void setNotificationFilter(FilteredCollection.Filter<Notification> filter);
}

Lines 94-100 Link Here

(-)src/org/eclipse/emf/validation/service/IConstraintDescriptor.java (-2 / +2 lines)
94	*	94	*
95	* @return my evaluation mode	95	* @return my evaluation mode
96	*/	96	*/
97	EvaluationMode getEvaluationMode();	97	EvaluationMode<?> getEvaluationMode();
98		98
99	/**	99	/**
100	* Queries whether I target the type (or any supertype) of the specified	100	* Queries whether I target the type (or any supertype) of the specified
Lines 196-202 Link Here
196	*	196	*
197	* @return an unmodifiable set of {@link Category}s	197	* @return an unmodifiable set of {@link Category}s
198	*/	198	*/
199	Set getCategories();	199	Set<Category> getCategories();
200		200
201	/**	201	/**
202	* Adds a category to me. If, previously, I was in the default category,	202	* Adds a category to me. If, previously, I was in the default category,




 * @author Christian W. Damus (cdamus)
 */
public abstract class AbstractConstraintDescriptor implements IConstraintDescriptor {
	private final Set<Category> categories = new java.util.HashSet<Category>();
	private final Set<Category> unmodCategories =
		java.util.Collections.unmodifiableSet(categories);
	
	private Throwable exception;

	private boolean isMandatory() {
		boolean result = false;
		
		for (Iterator<Category> iter = getCategories().iterator();
				!result && iter.hasNext();) {
			
			result = iter.next().isMandatory();
		}
		
		return result;
	}
	
	// implements the interface method
	public Set<Category> getCategories() {
		return unmodCategories;
	}
	

	}
	
	// redefines the inherited method
	@Override
	public int hashCode() {
		return (getId() == null) ? 0 : getId().hashCode();
	}

	 * 
	 * @see #getId()
	 */
	@Override
	public boolean equals(Object other) {
		return (other instanceof IConstraintDescriptor)
			&& ((IConstraintDescriptor)other).getId().equals(getId());
	}
	
	// redefines the inherited method
	@Override
	public String toString() {
		StringBuffer result = new StringBuffer(64);
		




	/** Don't allow client's progress to count more steps than this number. */
	private static final int MAX_PROGRESS_TICKS = 2048;
	
	private Iterator<? extends EObject> iterator;
	private IProgressMonitor monitor;
	
	/**

	 * updates).
	 */
	public void startTraversal(
		Collection<? extends EObject> traversalRoots,
		IProgressMonitor progressMonitor) {

		int taskSize = countElements(traversalRoots);

	 * @return the total number of elements to be validated within these
	 *     sub-trees
	 */
	protected abstract int countElements(Collection<? extends EObject> traversalRoots);
	
	/**
	 * Implemented by subclasses to return an iterator that provides all of the

	 * @param traversalRoots the roots of the traversal sub-trees
	 * @return an iterator that covers all of the elements to be validated
	 */
	protected abstract Iterator<? extends EObject> createIterator(
		Collection<? extends EObject> traversalRoots);
	
	/**
	 * Provides subclasses with access to the progress monitor, if they want it

	 * @see #createIterator
	 */
	public EObject next() {
		return iterator.next();
	}
	
	/**




public class ModelValidationService {
	private static final ModelValidationService instance = new ModelValidationService();
	
	private final Collection<IProviderDescriptor> constraintProviders =
		new java.util.HashSet<IProviderDescriptor>();
	
	// latch to control multiple invocations of loadXmlConstraintDefinitions()
	private boolean xmlConstraintDeclarationsLoaded = false;

	 * The resulting validator may be retained as long as it is needed, and
	 * reused any number of times.  Each validator has its own separate state.
	 * </p>
	 * 
	 * @param <T> the kind of validator to return
	 * 
	 * @param mode the evaluation mode for which to create a new validator.
	 *       Must not be <code>null</code> or {@link EvaluationMode#NULL}
	 * 
	 * @return a new validator
	 * 
	 * @throws IllegalArgumentException if the <code>mode</code> is not a
	 *       valid evaluation mode
	 */
	@SuppressWarnings("unchecked")
	public <T, V extends IValidator<T>> V newValidator(EvaluationMode<T> mode) {
		assert mode != null && !mode.isNull();
		
		IProviderOperationExecutor<Collection<IModelConstraint>> executor =
			new IProviderOperationExecutor<Collection<IModelConstraint>>() {
				public void execute(IProviderOperation<? extends Collection<IModelConstraint>> op) {
					ModelValidationService.this.execute(op);
				}};
		
		if (mode == EvaluationMode.BATCH) {
			return (V) new BatchValidator(executor);
		} else if (mode == EvaluationMode.LIVE) {
			return (V) new LiveValidator(executor);
		} else {
			throw new IllegalArgumentException();
		}

	 */
	public void broadcastValidationEvent(ValidationEvent event) {
		// Check if listeners exist
		if (listeners == null) {
			return;
		}
		
		IValidationListener[] array = listeners; // copy the reference
		
		for (IValidationListener element : array) {
			try {
				element.validationOccurred(event);
			} catch (Exception e) {
				Trace.catching(getClass(), "broadcastValidationEvent", e); //$NON-NLS-1$
				
				if (Trace.shouldTrace(EMFModelValidationDebugOptions.LISTENERS)) {
					Trace.trace(
							EMFModelValidationDebugOptions.LISTENERS,
							"Uncaught exception in listener: " + element.getClass().getName()); //$NON-NLS-1$
				}
				
				Log.l7dWarning(

	public void configureListeners(IConfigurationElement[] elements) {
		assert elements != null;

		for (IConfigurationElement element : elements) {
			if (element.getName().equals("listener")) { //$NON-NLS-1$
				try {
					addValidationListener(new LazyListener(element));
				} catch (CoreException e) {
					Trace.catching(getClass(), "configureListeners()", e); //$NON-NLS-1$
					


		constraintCache = new ConstraintCache();
		
		Collection<IProviderDescriptor> providers = getProviders();

		// include the cache in my collection of providers
		providers.add(constraintCache.getDescriptor());
		
		for (IConfigurationElement element : elements) {
			if (element.getName().equals(XmlConfig.E_CONSTRAINT_PROVIDER)) {
				try {
					IProviderDescriptor descriptor =
						new ProviderDescriptor(element);
					
					if (descriptor.isCacheEnabled()) {
						constraintCache.addProvider(descriptor);

	 * 
	 * @return a collection of {@link ProviderDescriptor}s
	 */
	private Collection<IProviderDescriptor> getProviders() {
		return constraintProviders;
	}


	 * 
	 * @param operation the operation to execute
	 */
	private void execute(
			IProviderOperation<? extends Collection<? extends IModelConstraint>> operation) {
		
		for (Iterator<IProviderDescriptor> iter = getProviders().iterator(); iter.hasNext(); ) {
			IProviderDescriptor next = iter.next();

			if (next.provides(operation)) {
				try {

	 * 
	 * @param providers the available providers
	 */
	private void loadXmlConstraintDeclarations(Collection<IProviderDescriptor> providers) {
		for (IProviderDescriptor next : providers) {
			IProviderDescriptor next = (IProviderDescriptor)iter.next();
			
			if (next.isXmlProvider()) {
				// the initialization of this provider is not very expensive
				//    and is guaranteed not to load any other plug-ins

		if (epackage != null) {
			EClassifier classifier = null;
			
			List<String> packageNames = parsePackageNames(className);
			if (packageNames == null) {
				classifier = epackage.getEClassifier(className);
			} else if (packageHasName(epackage, packageNames)) {

	 * @see #findClass(String, String)
	 */
	private static EPackage findPackage(String namespaceUri) {
		Map<String, Object> registry = org.eclipse.emf.ecore.EPackage.Registry.INSTANCE;
		
		Object result = registry.get(namespaceUri);
		

	 * @return the package names in right-to-left order, as a list of
	 *    strings, or <code>null</code> if the class name is not qualified
	 */
	private static List<String> parsePackageNames(String qualifiedClassName) {
		List<String> result = null;
		int end = qualifiedClassName.lastIndexOf('.'); // known BMP code point
		
		if (end >= 0) {
			result = new java.util.ArrayList<String>();
			
			// skip the class name part and collect other parts in
			//  reverse order

	 *    the package from bottom to top of the containment hierarchy;
	 *    <code>false</code>, otherwise
	 */
	private static boolean packageHasName(EPackage epackage, List<String> name) {
		boolean result = true;
		EPackage pkg = epackage;
		Iterator<String> iter = name.iterator();
		
		while (result && iter.hasNext() && (pkg != null)) {
			result = iter.next().equals(pkg.getName());

	 */
	private final class LazyListener implements IValidationListener {
		private final IConfigurationElement config;
		private List<String> registeredClientContexts = null;
		private IValidationListener validationListener = null;
		
		private static final String E_CLIENT_CONTEXT = "clientContext"; //$NON-NLS-1$

				IConfigurationElement[] children = config.getChildren(E_CLIENT_CONTEXT);
				
				// Probably a small number of registered client contexts.
				registeredClientContexts = new ArrayList<String>(4);
				
				for (IConfigurationElement element : children) {
					registeredClientContexts.add(element.getAttribute(A_CLIENT_CONTEXT_ID));
				}
			}
			

			
			// Otherwise, we will delay the loading of this listener until
			//  we are certain that they are interested in listening.
			for (String clientContextId : registeredClientContexts) {
				String clientContextId = (String)i.next();
				
				if (event.getClientContextIds().contains(clientContextId)) {
					try {
						if (validationListener == null) {

Lines 61-74 Link Here

(-)src/org/eclipse/emf/validation/service/ITraversalStrategy.java (-30 / +35 lines)
61	/* (non-Javadoc)	61	/* (non-Javadoc)
62	* Implements the inherited method.	62	* Implements the inherited method.
63	*/	63	*/
64	protected int countElements(Collection traversalRoots) {	64	@Override
		65	protected int countElements(Collection<? extends EObject> traversalRoots) {
65	return traversalRoots.size();	66	return traversalRoots.size();
66	}	67	}
67		68
68	/* (non-Javadoc)	69	/* (non-Javadoc)
69	* Implements the inherited method.	70	* Implements the inherited method.
70	*/	71	*/
71	protected Iterator createIterator(Collection traversalRoots) {	72	@Override
		73	protected Iterator<? extends EObject> createIterator(
		74	Collection<? extends EObject> traversalRoots) {
72	return traversalRoots.iterator();	75	return traversalRoots.iterator();
73	}	76	}
74	}	77	}
Lines 89-95 Link Here
89	* @author Christian W. Damus (cdamus)	92	* @author Christian W. Damus (cdamus)
90	*/	93	*/
91	final class Recursive extends AbstractTraversalStrategy {	94	final class Recursive extends AbstractTraversalStrategy {
92	private Collection roots;	95	private Collection<EObject> roots;
93	private boolean contextChanged = true;	96	private boolean contextChanged = true;
94		97
95	/**	98	/**
Lines 99-106 Link Here
99	super();	102	super();
100	}	103	}
101		104
102	public void startTraversal(	105	@Override
103	Collection traversalRoots,	106	public void startTraversal(
		107	Collection<? extends EObject> traversalRoots,
104	IProgressMonitor progressMonitor) {	108	IProgressMonitor progressMonitor) {
105		109
106	roots = makeTargetsDisjoint(traversalRoots);	110	roots = makeTargetsDisjoint(traversalRoots);
Lines 108-136 Link Here
108	super.startTraversal(traversalRoots, progressMonitor);	112	super.startTraversal(traversalRoots, progressMonitor);
109	}	113	}
110		114
111	private Collection getRoots() {	115	private Collection<EObject> getRoots() {
112	return roots;	116	return roots;
113	}	117	}
114		118
115	/* (non-Javadoc)	119	/* (non-Javadoc)
116	* Implements the inherited method.	120	* Implements the inherited method.
117	*/	121	*/
118	protected int countElements(Collection ignored) {	122	@Override
		123	protected int countElements(Collection<? extends EObject> ignored) {
119	return countRecursive(getRoots());	124	return countRecursive(getRoots());
120	}	125	}
121		126
122	private int countRecursive(Collection elements) {	127	private int countRecursive(Collection<? extends EObject> elements) {
123	int result = 0;	128	int result = 0;
124		129
125	result = elements.size();	130	result = elements.size();
126		131
127	for (Iterator iter = elements.iterator(); iter.hasNext(); ) {	132	for (EObject next : elements) {
128	Object next = iter.next();	133	result = result + countRecursive(next.eContents());
129
130	if (next instanceof EObject) {
131	result = result + countRecursive(
132	((EObject)next).eContents());
133	}
134	}	134	}
135		135
136	return result;	136	return result;
Lines 139-159 Link Here
139	/* (non-Javadoc)	139	/* (non-Javadoc)
140	* Implements the inherited method.	140	* Implements the inherited method.
141	*/	141	*/
142	protected Iterator createIterator(Collection ignored) {	142	@Override
143	return new EcoreUtil.ContentTreeIterator(getRoots()) {	143	protected Iterator<? extends EObject> createIterator(
		144	Collection<? extends EObject> ignored) {
		145
		146	return new EcoreUtil.ContentTreeIterator<EObject>(getRoots()) {
144	private static final long serialVersionUID = -5653134989235663973L;	147	private static final long serialVersionUID = -5653134989235663973L;
145		148
146	public Iterator getChildren(Object obj) {	149	@Override
		150	public Iterator<EObject> getChildren(Object obj) {
147	if (obj == getRoots()) {	151	if (obj == getRoots()) {
148	return new Iterator() {	152	return new Iterator<EObject>() {
149	private final Iterator delegate =	153	private final Iterator<EObject> delegate =
150	getRoots().iterator();	154	getRoots().iterator();
151		155
152	public boolean hasNext() {	156	public boolean hasNext() {
153	return delegate.hasNext();	157	return delegate.hasNext();
154	}	158	}
155		159
156	public Object next() {	160	public EObject next() {
157	// if I'm being asked for my next element, then	161	// if I'm being asked for my next element, then
158	// we are stepping to another traversal root	162	// we are stepping to another traversal root
159	contextChanged = true;	163	contextChanged = true;
Lines 169-175 Link Here
169	}	173	}
170	}	174	}
171		175
172	public Object next() {	176	@Override
		177	public EObject next() {
173	// this will be set to true again the next time we test hasNext() at	178	// this will be set to true again the next time we test hasNext() at
174	// the traversal root level	179	// the traversal root level
175	contextChanged = false;	180	contextChanged = false;
Lines 178-204 Link Here
178	}};	183	}};
179	}	184	}
180		185
181	public boolean isClientContextChanged() {	186	@Override
		187	public boolean isClientContextChanged() {
182	return contextChanged;	188	return contextChanged;
183	}	189	}
184		190
185	private Set makeTargetsDisjoint(Collection objects) {	191	private Set<EObject> makeTargetsDisjoint(Collection<? extends EObject> objects) {
186	Set result = new java.util.HashSet();	192	Set<EObject> result = new java.util.HashSet<EObject>();
187		193
188	// ensure that any contained (descendent) elements of other elements	194	// ensure that any contained (descendent) elements of other elements
189	// that we include are not included, because they will be	195	// that we include are not included, because they will be
190	// traversed by recursion, anyway	196	// traversed by recursion, anyway
191		197
192	for (Iterator it = objects.iterator(); it.hasNext();) {	198	for (EObject target : objects) {
193	EObject target = (EObject)it.next();
194
195	// EcoreUtil uses the InternalEObject interface to check	199	// EcoreUtil uses the InternalEObject interface to check
196	// containment, so we do the same. Also, we kip up a level to	200	// containment, so we do the same. Also, we kip up a level to
197	// the immediate container for efficiency: an object is its	201	// the immediate container for efficiency: an object is its
198	// own ancestor, so we can "pre-step" up a level to avoid the	202	// own ancestor, so we can "pre-step" up a level to avoid the
199	// cost of doing it individually for every miss in the collection	203	// cost of doing it individually for every miss in the collection
200	if (!EcoreUtil.isAncestor(objects,	204	if (!EcoreUtil.isAncestor(objects,
201	((InternalEObject) target).eInternalContainer())) {	205	((InternalEObject) target).eInternalContainer())) {
202	result.add(target);	206	result.add(target);
203	}	207	}
204	}	208	}
Lines 222-228 Link Here
222	* @param monitor the progress monitor used to track progress. The receiver	226	* @param monitor the progress monitor used to track progress. The receiver
223	* may retain this progress monitor for the duration of the traversal	227	* may retain this progress monitor for the duration of the traversal
224	*/	228	*/
225	void startTraversal(Collection traversalRoots, IProgressMonitor monitor);	229	void startTraversal(Collection<? extends EObject> traversalRoots,
		230	IProgressMonitor monitor);
226		231
227	/**	232	/**
228	* Queries whether there is another element to be validated.	233	* Queries whether there is another element to be validated.

Lines 14-19 Link Here

(-)src/org/eclipse/emf/validation/service/INotificationGenerator.java (-1 / +4 lines)
14		14
15	import java.util.Collection;	15	import java.util.Collection;
16		16
		17	import org.eclipse.emf.common.notify.Notification;
		18
17	/**	19	/**
18	* Interface implemented by clients who wish to define a notification	20	* Interface implemented by clients who wish to define a notification
19	* generator.	21	* generator.
Lines 37-41 Link Here
37	* @param notifications that are eligible for validation	39	* @param notifications that are eligible for validation
38	* @return collection of newly generated notifications	40	* @return collection of newly generated notifications
39	*/	41	*/
40	public Collection generateNotifications(Collection notifications);	42	public Collection<Notification> generateNotifications(
		43	Collection<? extends Notification> notifications);
41	}	44	}




 * <b>Note</b> that clients are not intended to implement this interface.
 * </p>
 * 
 * @param <T> the kind of target element validated by the validator
 * 
 * @see ModelValidationService#newValidator(EvaluationMode)
 * 
 * @author Christian W. Damus (cdamus)
 */
public interface IValidator<T> {
	/**
	 * Indicates the evaluation mode that I support.  This indicates the kind
	 * of objects expected by the <code>validate()</code> methods to process.
	 * 
	 * @return my evaluation mode
	 */
	EvaluationMode<T> getEvaluationMode();
	
	/**
	 * Queries whether successful constraint evaluations are reported, in

	 * @throws ClassCastException if the <code>object</code> is not of
	 *    the correct type for this validator
	 */
	IStatus validate(T object);
	
	/**
	 * Validates multiple objects, all in the same

	 *    not of the correct type for this validator
	 * @see #validate(Object)
	 */
	IStatus validate(Collection<? extends T> objects);
	
	/**
	 * Adds a constraint filter to this validator.  The validator

     * 
     * @since 1.1
     */
	Collection<IConstraintFilter> getConstraintFilters();
}




	private static final String A_FEATURE_SPECIFIC = "featureSpecific"; //$NON-NLS-1$
	private static final String A_NOTIFICATION_GENERATOR = "notificationGenerator"; //$NON-NLS-1$
	
	private final Map<String, INotificationGenerator> notificationGenerators;
	
	/**
	 * Cannot be instantiated by clients.
	 */
	private EventTypeService() {
		notificationGenerators = new HashMap<String, INotificationGenerator>();
	}

	/**

	public void configureEventTypes(IConfigurationElement[] elements) {
		assert elements != null;

		for (IConfigurationElement element : elements) {
			if (element.getName().equals("eventType")) { //$NON-NLS-1$
				try {
					String name = element.getAttribute(A_NAME);
					if ((name != null) && (name.length() > 0)) {
						EMFEventType.addEventType(name,
								Boolean.valueOf(element.getAttribute(A_FEATURE_SPECIFIC)).booleanValue()
								);
						
						String notificationGenerator = element.getAttribute(A_NOTIFICATION_GENERATOR);
						if ((notificationGenerator != null) && (notificationGenerator.length() > 0)) {
							notificationGenerators.put(
								name,
								(INotificationGenerator) element.createExecutableExtension(A_NOTIFICATION_GENERATOR));
						}
					}
				} catch (CoreException e) {

	 * 
	 * @return collection of notification generators
	 */
	public Collection<INotificationGenerator> getNotificationGenerators() {
		return Collections.unmodifiableCollection(notificationGenerators.values());
	}
	

	 *         null otherwise
	 */
	public INotificationGenerator getNotificationGenerator(String eventName) {
		return notificationGenerators.get(eventName);
	}
}




		IConfigurationElement constraint,
		String name) {
		
		List<String> result = new java.util.ArrayList<String>();
		
		IConfigurationElement[] parms = constraint.getChildren(E_PARAM);
		for (IConfigurationElement element : parms) {
			if (name.equals(element.getAttribute(A_NAME))) {
				String value = element.getAttribute(A_VALUE);
				
				if (value == null) {
					value = element.getValue();
				}
				
				if (value != null) {

			}
		}
		
		return result.toArray(new String[result.size()]);
	}

	/**

			String path = tokens.nextToken().trim();
			
			if (path.length() > 0) {
				for (IConfigurationElement element : children) {
					final String id = element.getAttribute(A_ID);
					
					IConstraintDescriptor constraint =
						ConstraintRegistry.getInstance().getDescriptor(

					
					if (constraint == null) {
						try {
							constraint = new XmlConstraintDescriptor(element);
						} catch (ConstraintExistsException e) {
							// shouldn't happen because I checked for existence
							continue;




 * Wrapper for a Java 2 {@link Collection} that provides a filtered view of its
 * contents according to a client-specified filter algorithm.
 * 
 * @param <E> the collection element type
 * 
 * @author Christian W. Damus (cdamus)
 */
public class FilteredCollection<E> extends AbstractCollection<E> {
	/**
	 * Indicates the end of iteration.  Cannot use 'null' for this purpose, as
	 * it may legitimately be present in a collection.
	 */
	private static final Object END_TOKEN = new Object();
	
	private final Collection<? extends E> filteree;
	private final Filter<? super E> filter;
	
	/**
	 * Interface for the algorithm that determines which elements are in and
	 * which are out of the filtered collection.
	 * 
	 * @param <E> the collection element type to filter
	 * 
	 * @author Christian W. Damus (cdamus)
	 */
	public static interface Filter<E> {
		/**
		 * Determines whether to accept or reject the specified
		 * <code>element</code> from the collection.

		 * @return <CODE>true</CODE> if the <code>element</code> should be
		 *     included in the filtered view; <CODE>false</CODE>, otherwise
		 */
		boolean accept(E element);
	}
	
	/**

	 * @param collection the collection that I am to filter 
	 * @param filter the filter algorithm to apply
	 */
	public FilteredCollection(Collection<? extends E> collection, Filter<? super E> filter) {
		this.filteree = collection;
		this.filter = filter;
	}

	 * 
	 * @return my filter
	 */
	public final Filter<? super E> getFilter() {
		return filter;
	}


	 * 
	 * @author Christian W. Damus (cdamus)
	 */
	@SuppressWarnings("unchecked")
	private class Iter implements Iterator<E> { 
		private final Iterator<? extends E> filteredIterator = filteree.iterator();
		
		private E next = (E) END_TOKEN;
		
		/**
		 * Queries whether I have another object that matches the

						break;
					} else {
						// try again
						next = (E) END_TOKEN;
					}
				}
			}

		/**
		 * Retrieves the next object that matches my {@link #getFilter filter}.
		 */
		public E next() {
			if (!hasNext()) {
				throw new NoSuchElementException();
			}
			
			E result = next;
			
			next = (E) END_TOKEN;
			
			return result;
		}

	 * @return an iterator the exposes only the elements of my wrapped
	 *     collection that match my filter
	 */
	@Override
	public Iterator<E> iterator() {
		return new Iter();
	}


	 * @return the number of elements in my wrapped collection that match my
	 *      filter
	 */
	@Override
	public int size() {
		int result = 0;
		
		for (Iterator<E> iter = iterator(); iter.hasNext(); iter.next()) {
			result++;
		}
		




package org.eclipse.emf.validation.internal.util;

import java.util.Collection;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;

import org.eclipse.emf.validation.EMFEventType;
import org.eclipse.emf.validation.internal.EMFModelValidationDebugOptions;
import org.eclipse.emf.validation.internal.EMFModelValidationPlugin;

	private String name;
	private String id;
	private int statusCode;
	private final String pluginId;

	private String description;
	private ConstraintSeverity severity = ConstraintSeverity.ERROR;
	private EvaluationMode<?> mode;

	private Map<Object, TargetDescriptor> targetMap =
		new java.util.HashMap<Object, TargetDescriptor>();

	private String messagePattern;


					new Object[] {key});
		}

		TargetDescriptor result = targetMap.get(key);

		if (result == null) {
			result = new TargetDescriptor();

	}

	// implements the interface method
	public EvaluationMode<?> getEvaluationMode() {
		return mode;
	}

	private void setEvaluationMode(EvaluationMode<?> mode) {
		this.mode = mode;
	}


		
		resolved = true;
		
		Map<Object, TargetDescriptor> oldMap = targetMap;
		targetMap = new java.util.HashMap<Object, TargetDescriptor>();

		for (Iterator iter = oldMap.entrySet().iterator(); iter.hasNext(); ) {
			Map.Entry next = (Map.Entry)iter.next();

		for (Map.Entry<Object, TargetDescriptor> next : oldMap.entrySet()) {
			String typeName = (String) next.getKey();
			
			EClass targetEClass = null;
			// See if the typeName value from the extension has a qualified

		// that are for ancestor EClasses.  This is an O{n**2) algorithm, but
		// there are not expected ever to be more than a handful of targets in
		// any given constraint
		for (Map.Entry<Object, TargetDescriptor> next : targetMap.entrySet()) {
			inheritTriggers((EClass) next.getKey(), next.getValue());
			
			inheritTriggers(
				(EClass) next.getKey(),
				(TargetDescriptor) next.getValue());
		}
	}
	

	 * @param descriptor its descriptor
	 */
	private void inheritTriggers(EClass target, TargetDescriptor descriptor) {
		for (Map.Entry<Object, TargetDescriptor> next : targetMap.entrySet()) {
			Map.Entry next = (Map.Entry) iter.next();
			EClass otherTarget = (EClass) next.getKey();
			
			if ((otherTarget != target) && (otherTarget.isSuperTypeOf(target))) {
				descriptor.merge(next.getValue());
			}
		}
	}


		IConfigurationElement[] targets = extConfig.getChildren(XmlConfig.E_TARGET);

		for (final IConfigurationElement target : targets) {
			final IConfigurationElement target = targets[i];

			TargetDescriptor targetType = addTargetType(
					target.getAttribute(XmlConfig.A_CLASS));
			

				//   to events in the model
				IConfigurationElement[] events = XmlConfig.getEvents(target);

				for (IConfigurationElement element : events) {
					EMFEventType eventType = EMFEventType.getInstance(
							element.getAttribute(XmlConfig.A_NAME));

					if (!eventType.isNull()) {
						// add specific supported features, if any
						IConfigurationElement[] features =
							element.getChildren(XmlConfig.E_FEATURE);
						
						if ((features == null) || (features.length == 0)) {
							targetType.addEvent(eventType);
						} else {
							for (IConfigurationElement element2 : features) {
								targetType.addEvent(
										eventType,
										element2.getAttribute(
												XmlConfig.A_NAME));
							}
						}

				EMFModelValidationStatusCodes.CONSTRAINT_NOT_INITED,
				EMFModelValidationPlugin.getMessage(
						RULE_INCOMPLETE,
						missingItem),
				null));
			
			Trace.throwing(getClass(), "assertNotNull", ce); //$NON-NLS-1$

	 * @author Christian W. Damus (cdamus)
	 */
	private static class TargetDescriptor {
		private final Collection<EMFEventType> nonFeatureSpecificEvents =
			new java.util.HashSet<EMFEventType>();
		private final Map<EMFEventType, Collection<String>> featureSpecificEvents =
			new java.util.HashMap<EMFEventType, Collection<String>>();

		/**
		 * Indicates whether I explicitly support my target EClass, or whether

		 */
		void addEvent(EMFEventType eventType, String featureName) {
			if (featureName != null) {
				Collection<String> currentFeatures = featureSpecificEvents.get(
						eventType);
				
				if (currentFeatures == null) {
					currentFeatures = new java.util.HashSet<String>();
					featureSpecificEvents.put(eventType, currentFeatures);
				}
				

						// see whether the collection of supported event
						//   types includes this feature
						if (featureSpecificEvents.containsKey(eventType)) {
							Collection<String> eventFeatures =
								featureSpecificEvents.get(eventType);
							
							// if no features are registered and I am supported and
							//    I have no parents, then it is implied that I

			
			this.nonFeatureSpecificEvents.addAll(parent.nonFeatureSpecificEvents);
			
			for (Map.Entry<EMFEventType, Collection<String>> next : parent.featureSpecificEvents.entrySet()) {
				EMFEventType eventType = next.getKey();
				Collection<String> features = next.getValue();
				Collection features = (Collection) next.getValue();
				
				Collection<String> myFeatures = this.featureSpecificEvents.get(eventType);
				if (myFeatures == null) {
					// add all of my parent's features.  Need to create a copy
					// because I might inherit other features from a different
					// parent
					this.featureSpecificEvents.put(
						eventType,
						new java.util.HashSet<String>(features));
				} else {
					myFeatures.addAll(features);
				}





import java.net.MalformedURLException;
import java.net.URL;
import java.util.Iterator;
import java.util.List;
import java.util.Map;


import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.osgi.framework.Bundle;

import org.eclipse.emf.validation.internal.EMFModelValidationPlugin;
import org.eclipse.emf.validation.internal.EMFModelValidationStatusCodes;
import org.eclipse.emf.validation.util.XmlConfig;
import org.osgi.framework.Bundle;

/**
 * A custom implementation of the Eclipse configuration element API which is

	private final URL baseUrl;

	private String value;
	private final Map<String, String> attributes;
	private final List<IConfigurationElement> children =
		new java.util.ArrayList<IConfigurationElement>();
	private Object parent;

	/**

	 * @param baseUrl the base of any relative URL of files that I load
	 */
	XmlConfigurationElement(String name, IExtension extension, URL baseUrl) {
		this(name, new java.util.HashMap<String, String>(), extension, baseUrl);
	}

	/**

	 */
	XmlConfigurationElement(
			String name,
			Map<String, String> attributes,
			IExtension extension,
			URL baseUrl) {
		this.myName = name;


	// implements the interface method
	public String getAttribute(String name) {
		return attributes.get(name);
	}

	// implements the interface method


	// implements the interface method
	public String[] getAttributeNames() {
		return attributes.keySet().toArray(new String[attributes.size()]);
				.toArray(new String[attributes.size()]);
	}

	/**


	// implements the interface method
	public IConfigurationElement[] getChildren() {
		return children.toArray(new IConfigurationElement[children.size()]);
				new IConfigurationElement[children.size()]);
	}

	// implements the interface method
	public IConfigurationElement[] getChildren(String name) {
		java.util.List<IConfigurationElement> result =
			new java.util.ArrayList<IConfigurationElement>(children.size());
		for (Iterator iter = children.iterator(); iter.hasNext(); ) {
			IConfigurationElement next = (IConfigurationElement)iter.next();

		for (IConfigurationElement next : children) {
			if (next.getName().equals(name)) {
				result.add(next);
			}
		}

		return result.toArray(new IConfigurationElement[result.size()]);
				new IConfigurationElement[result.size()]);
	}

	/**

	 *     constraintses
	 */
	public void flatten(IConfigurationElement[] constraintses) throws CoreException {
		for (IConfigurationElement element : constraintses) {
			flatten(element);
			removeChild(element);
		}
	}


	 *     files
	 */
	public void include(IConfigurationElement[] includes) throws CoreException {
		for (IConfigurationElement element : includes) {
			include(element);
		}
	}


	private void absorb(IConfigurationElement includedConstraints) {
		IConfigurationElement[] elements = includedConstraints.getChildren();
		
		for (IConfigurationElement element : elements) {
			addChild(element);
		}
	}

	// redefines the inherited method
	@Override
	public String toString() {
		StringBuffer result = new StringBuffer(64);





/******************************************************************************
 * Copyright (c) 2002, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

		/*
		 * (Non JavaDoc)
		 */
		private final int start; //inclusive

		/*
		 * (Non JavaDoc)
		 */
		private final int end; //exclusive

		/**
		 * Creates a new position.

	 */
	public StringMatcher(String pattern, boolean ignoreCase,
			boolean ignoreWildCards) {
		if (pattern == null) {
			throw new IllegalArgumentException();
		}
		fIgnoreCase = ignoreCase;
		fIgnoreWildCards = ignoreWildCards;
		fPattern = pattern;

	 * is returned. For a pattern like"*??*" in text "abcdf", (1,3) is returned
	 */
	public StringMatcher.Position find(String text, int start, int end) {
		if (text == null) {
			throw new IllegalArgumentException();
		}

		int tlen = text.length();
		if (start < 0) {
			start = 0;
		}
		if (end > tlen) {
			end = tlen;
		}
		if (end < 0 || start >= end) {
			return null;
		}
		if (fLength == 0) {
			return new Position(start, start);
		}
		if (fIgnoreWildCards) {
			int x = posIn(text, start, end);
			if (x < 0) {
				return null;
			}
			return new Position(x, x + fLength);
		}

		int segCount = fSegments.length;
		if (segCount == 0) {
			return new Position(start, end);
		}

		int curPos = start;
		int matchStart = -1;

		for (i = 0; i < segCount && curPos < end; ++i) {
			String current = fSegments[i];
			int nextMatch = regExpPosIn(text, curPos, end, current);
			if (nextMatch < 0) {
				return null;
			}
			if (i == 0) {
				matchStart = nextMatch;
			}
			curPos = nextMatch + current.length();
		}
		if (i < segCount) {
			return null;
		}
		return new Position(matchStart, curPos);
	}


	 *            substring
	 */
	public boolean match(String text, int start, int end) {
		if (null == text) {
			throw new IllegalArgumentException();
		}

		if (start > end) {
			return false;
		}

		if (fIgnoreWildCards) {
			return (end - start == fLength)
				&& fPattern.regionMatches(fIgnoreCase, 0, text, start, fLength);
		}
		int segCount = fSegments.length;
		if (segCount == 0 && (fHasLeadingStar || fHasTrailingStar)) {
			// contains
			// only
			// '*'(s)
			return true;
		}
		if (start == end) {
			return fLength == 0;
		}
		if (fLength == 0) {
			return start == end;
		}

		int tlen = text.length();
		if (start < 0) {
			start = 0;
		}
		if (end > tlen) {
			end = tlen;
		}

		int tCurPos = start;
		int bound = end - fBound;
		if (bound < 0) {
			return false;
		}
		int i = 0;
		String current = fSegments[i];
		int segLength = current.length();

			int k = current.indexOf(fSingleWildCard); // known BMP code point
			if (k < 0) {
				currentMatch = textPosIn(text, tCurPos, end, current);
				if (currentMatch < 0) {
					return false;
				}
			} else {
				currentMatch = regExpPosIn(text, tCurPos, end, current);
				if (currentMatch < 0) {
					return false;
				}
			}
			tCurPos = currentMatch + current.length();
			i++;

	 *            and/or '?'
	 */
	private void parseWildCards() {
		if (fPattern.startsWith("*")) { //$NON-NLS-1$
			fHasLeadingStar = true;
		}
		// if it is equal to '*', then it clearly is not a UTF-32 surrogate
		if (UTF16.charAt(fPattern, fLength - 1) == '*') {
			/* make sure it's not an escaped wildcard */

			}
		}

		Vector<String> temp = new Vector<String>();

		int pos = 0;
		StringBuffer buf = new StringBuffer();


		if (!fIgnoreCase) {
			int i = UTF16.indexOf(text, fPattern, start);
			if (i == -1 || i > max) {
				return -1;
			}
			return i;
		}

		for (int i = start; i <= max; ++i) {
			if (text.regionMatches(true, i, fPattern, 0, fLength)) {
				return i;
			}
		}

		return -1;


		int max = end - plen;
		for (int i = start; i <= max; ++i) {
			if (regExpRegionMatches(text, i, p, 0, plen)) {
				return i;
			}
		}
		return -1;
	}

					continue;
				}
			}
			if (pchar == tchar) {
				continue;
			}
			if (fIgnoreCase && Normalizer.compare(
					tchar, pchar, Normalizer.COMPARE_IGNORE_CASE) == 0) {
				continue;


		if (!fIgnoreCase) {
			int i = UTF16.indexOf(text, p, start);
			if (i == -1 || i > max) {
				return -1;
			}
			return i;
		}

		for (int i = start; i <= max; ++i) {
			if (text.regionMatches(true, i, p, 0, plen)) {
				return i;
			}
		}

		return -1;




				ResourceSet resourceSet = resource.getResourceSet();
				
				if (resourceSet != null) {
					List<AdapterFactory> factories = resourceSet.getAdapterFactories();
					
					// iterate only as long as we don't find an adapter factory
					//    that successfully adapted the eObject
					for (Iterator<AdapterFactory> iter = factories.iterator();
							iter.hasNext() && (result == null);) {
						
						AdapterFactory next = iter.next();
						
						if (next.isFactoryForType(type)) {
							result = next.adapt(eObject, type);

	 * Applies the specified arguments to my message pattern.
	 * 
	 * @param messagePattern the message pattern
	 * @param inputArg the pattern arguments
	 * @return the formatted message string
	 * 
	 * @since 1.1
	 */
	public static String formatMessage(String messagePattern, Object... inputArg) {
		Object[] args = new Object[inputArg.length];

		for (int i = 0; i < args.length; i++) {
			Object next = inputArg[i];

			if (next instanceof Collection) {
				next = formatMultiValue((Collection<?>) next);
			} else if (next instanceof Object[]) {
				next = formatMultiValue(Arrays.asList((Object[]) next));
			} else {
				next = formatScalarValue(next);
			}

			args[i] = next;
		}

		return NLS.bind(messagePattern, args);

	 * @param multiValuedArg the multiple objects
	 * @return the string representation of the list
	 */
	private static String formatMultiValue(Collection<?> multiValuedArg) {
		List<Object> args = new java.util.ArrayList<Object>(multiValuedArg);

		for (ListIterator<Object> iter = args.listIterator(); iter.hasNext(); ) {
			iter.set(formatScalarValue(iter.next()));
		}


	 */
	private static String formatScalarValue(Object value) {
		if (value instanceof EObject) {
			return TextUtils.getText((EObject) value);
		} else {
			return String.valueOf(value);
		}





import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;

import org.eclipse.emf.validation.internal.EMFModelValidationPlugin;

/**

		if (patternArgs instanceof Object[]) {
			args = (Object[])patternArgs;
		} else if (patternArgs instanceof Collection) {
			Collection<?> argsCollection = (Collection<?>) patternArgs;
			
			args = argsCollection.toArray(new Object[argsCollection.size()]);
		} else {

		
		log(severity,
			code,
			EMFModelValidationPlugin.getMessage(messagePattern,
			    (Object[]) patternArgKeys), exception);
	}
}

Lines 47-53 Link Here

(-)src/org/eclipse/emf/validation/internal/util/XmlConstraintFactory.java (-6 / +12 lines)
47	"constraintParsers"; //$NON-NLS-1$	47	"constraintParsers"; //$NON-NLS-1$
48		48
49	/** Mapping of language names to parser implementations. */	49	/** Mapping of language names to parser implementations. */
50	private final java.util.Map parserMap = new java.util.HashMap();	50	private final java.util.Map<String, IConstraintParser> parserMap =
		51	new java.util.HashMap<String, IConstraintParser>();
51		52
52	/**	53	/**
53	* Initializes me. I load my parsers from the <tt>constraintParsers</tt>	54	* Initializes me. I load my parsers from the <tt>constraintParsers</tt>
Lines 60-65 Link Here
60	}	61	}
61		62
62	// implements the inherited method	63	// implements the inherited method
		64	@Override
		65	@SuppressWarnings("deprecation")
63	protected IModelConstraint createConstraint(IXmlConstraintDescriptor desc) {	66	protected IModelConstraint createConstraint(IXmlConstraintDescriptor desc) {
64	IConfigurationElement config = desc.getConfig();	67	IConfigurationElement config = desc.getConfig();
65		68
Lines 98-103 Link Here
98	}	101	}
99	}	102	}
100		103
		104	@Override
		105	@SuppressWarnings("deprecation")
101	protected IModelConstraint createConstraint(IConstraintDescriptor descriptor) {	106	protected IModelConstraint createConstraint(IConstraintDescriptor descriptor) {
102	if (descriptor instanceof IXmlConstraintDescriptor) {	107	if (descriptor instanceof IXmlConstraintDescriptor) {
103	return createConstraint((IXmlConstraintDescriptor) descriptor);	108	return createConstraint((IXmlConstraintDescriptor) descriptor);
Lines 110-115 Link Here
110	}	115	}
111	}	116	}
112		117
		118	@SuppressWarnings("deprecation")
113	protected IModelConstraint createConstraint(IParameterizedConstraintDescriptor descriptor) {	119	protected IModelConstraint createConstraint(IParameterizedConstraintDescriptor descriptor) {
114	final String lang = descriptor.getLanguage();	120	final String lang = descriptor.getLanguage();
115		121
Lines 151-156 Link Here
151	*	157	*
152	* @param config the Eclipse extension configuration data for the parser	158	* @param config the Eclipse extension configuration data for the parser
153	*/	159	*/
		160	@SuppressWarnings("deprecation")
154	void registerParser(IConfigurationElement config) {	161	void registerParser(IConfigurationElement config) {
155	assert config != null;	162	assert config != null;
156		163
Lines 163-169 Link Here
163		170
164	if (parser instanceof IXmlConstraintParser	171	if (parser instanceof IXmlConstraintParser
165	\|\| parser instanceof IParameterizedConstraintParser) {	172	\|\| parser instanceof IParameterizedConstraintParser) {
166	parserMap.put(UCharacter.toLowerCase(language), parser);	173	parserMap.put(UCharacter.toLowerCase(language),
		174	(IConstraintParser) parser);
167		175
168	Trace.trace(	176	Trace.trace(
169	EMFModelValidationDebugOptions.PARSERS,	177	EMFModelValidationDebugOptions.PARSERS,
Lines 194-200 Link Here
194	* @return the parser, or <code>null</code> if it cannot be found	202	* @return the parser, or <code>null</code> if it cannot be found
195	*/	203	*/
196	private IConstraintParser getParser(String language) {	204	private IConstraintParser getParser(String language) {
197	return (IConstraintParser) parserMap.get(UCharacter.toLowerCase(language));	205	return parserMap.get(UCharacter.toLowerCase(language));
198	}	206	}
199		207
200	/**	208	/**
Lines 207-215 Link Here
207	EMFModelValidationPlugin.getPluginId(),	215	EMFModelValidationPlugin.getPluginId(),
208	CONSTRAINT_PARSERS_EXT_P_NAME);	216	CONSTRAINT_PARSERS_EXT_P_NAME);
209		217
210	for (int i = 0; i < configs.length; i++) {	218	for (IConfigurationElement config : configs) {
211	IConfigurationElement config = configs[i];
212
213	registerParser(config);	219	registerParser(config);
214	}	220	}
215	}	221	}




	 * @param methodName The name of method that is being entered.
	 */
	public static void entering(
		Class<?> clazz,
		String methodName) {
	
			EMFModelValidationPlugin.Tracing.entering(

	 * @param parameter The parameter to the method being entered.
	 */
	public static void entering(
		Class<?> clazz,
		String methodName,
		Object parameter) {
	

	 * @param parameters The parameters to the method being entered.
	 */
	public static void entering(
		Class<?> clazz,
		String methodName,
		Object[] parameters) {
	

	 */
	public static void entering(
		String option,
		Class<?> clazz,
		String methodName) {
	
		if (shouldTraceEntering()) {

	 */
	public static void entering(
		String option,
		Class<?> clazz,
		String methodName,
		Object parameter) {
	

	 */
	public static void entering(
		String option,
		Class<?> clazz,
		String methodName,
		Object[] parameters) {
	

	 * @param methodName The name of method that is being exited.
	 */
	public static void exiting(
		Class<?> clazz,
		String methodName) {
	
			EMFModelValidationPlugin.Tracing.exiting(

	 * @param returnValue The return value of the method being exited.
	 */
	public static void exiting(
		Class<?> clazz,
		String methodName,
		Object returnValue) {
	

	 */
	public static void exiting(
		String option,
		Class<?> clazz,
		String methodName) {
	
		if (shouldTraceExiting()) {

	 */
	public static void exiting(
		String option,
		Class<?> clazz,
		String methodName,
		Object returnValue) {
	

	 * @param throwable The throwable that is being caught.
	 */
	public static void catching(
		Class<?> clazz,
		String methodName,
		Throwable throwable) {
	

	 * @param throwable The throwable that is being thrown.
	 */
	public static void throwing(
		Class<?> clazz,
		String methodName,
		Throwable throwable) {
	




	 * the single-instance model of {@link AbstractModelConstraint} any class
	 * implementing one or more ad hoc validation method signatures.
	 */
	private static final Map<Class<?>, Object> constraintImplementationMap =
		new java.util.HashMap<Class<?>, Object>();
	
	/**
	 * Adapts instances of {@link AbstractModelConstraint} to the internal

				descriptor);
	}
    
	@SuppressWarnings("deprecation")
    public IModelConstraint parseConstraint(IXmlConstraintDescriptor descriptor)
        throws ConstraintParserException {
        

		Bundle bundle = Platform.getBundle(bundleName);
		
		try {
			Class<?> resultType = bundle.loadClass(className);

			if (AbstractModelConstraint.class.isAssignableFrom(resultType)) {
				// instantiate the class extending AbstractModelConstraint

	 * @throws IllegalAccessException if the instance needs to be created
	 *     and the default constructor is not accessible
	 */
	static Object getInstance(Class<?> constraintClass)
			throws InstantiationException, IllegalAccessException {
		
		Object result = constraintImplementationMap.get(constraintClass);




/******************************************************************************
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	 * @author Christian W. Damus (cdamus)
	 */
	private class Stack {
		private final List<XmlConfigurationElement> contents =
			new java.util.ArrayList<XmlConfigurationElement>();
		private final List<StringBuffer> bodies = new java.util.ArrayList<StringBuffer>();
		private int lastIndex = -1;
		
		/**

				throw se;
			}

			XmlConfigurationElement result = contents.get(lastIndex);
				(XmlConfigurationElement)contents.get(lastIndex);
			
			result.setValue(localize(getBody().toString().trim()));


				throw se;
			}

			return contents.get(lastIndex);
		}

		/**

				throw se;
			}

			return bodies.get(lastIndex);
		}
	}
	

	 * @author Christian W. Damus (cdamus)
	 */
	private static final class ResourceBundleCache {
		private final Map<Bundle, Map<String, ResourceBundle>> map =
			new java.util.HashMap<Bundle, Map<String, ResourceBundle>>();
		
		/**
		 * Obtains the resource bundle named <code>baseName</code> in the

		 */
		ResourceBundle get(Bundle osgiBundle, String baseName) {
			ResourceBundle result = null;
			Map<String, ResourceBundle> secondLevel = map.get(osgiBundle);
			
			if (secondLevel != null) {
				result = secondLevel.get(baseName);
			}
			
			return result;

		 * @param rb the resource bundle to cache
		 */
		void put(Bundle osgiBundle, String baseName, ResourceBundle rb) {
			Map<String, ResourceBundle> secondLevel = map.get(osgiBundle);
			
			if (secondLevel == null) {
				secondLevel = new java.util.HashMap<String, ResourceBundle>();
				map.put(osgiBundle, secondLevel);
			}
			

	/**
	 * Pushes a new element onto the top of the stack.
	 */
	@Override
	public void startElement(
			String namespaceURI,
			String localName,
			String qName,
			Attributes atts) {
		int attCount = atts.getLength();
		Map<String, String> attMap = new java.util.HashMap<String, String>();
		
		for (int i = 0; i < attCount; i++) {
			attMap.put(atts.getQName(i), localize(atts.getValue(i)));

	 * 
	 * @see #getResult
	 */
	@Override
	public void endElement(
			String namespaceURI,
			String localName,

	/**
	 * Appends text to the body of the top element on the stack.
	 */
	@Override
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		

	 * @throws SAXException if a version is indicated in the processing
	 *     instruction that is not a supported version 
	 */
	@Override
	public void processingInstruction(String target, String data)
			throws SAXException {
		if (target.equals(EMF_VALIDATION_INSTRUCTION)) {

	//
	
	// extends the inherited method
	@Override
	public void fatalError(SAXParseException e) throws SAXException {
		Log.errorMessage(
				EMFModelValidationStatusCodes.ERROR_PARSING_XML_FILE,

	}
	
	// extends the inherited method
	@Override
	public void error(SAXParseException e) throws SAXException {
		Log.errorMessage(
				EMFModelValidationStatusCodes.ERROR_PARSING_XML_FILE,

	}
	
	// extends the inherited method
	@Override
	public void warning(SAXParseException e) throws SAXException {
		Log.warningMessage(
				EMFModelValidationStatusCodes.ERROR_PARSING_XML_FILE,




package org.eclipse.emf.validation.model;

import java.util.Collection;
import java.util.Iterator;
import java.util.SortedSet;

import org.eclipse.core.runtime.IConfigurationElement;

	 * @return an unmodifiable set of {@link Category}s, sorted by their
	 *     names
	 */
	public SortedSet<Category> getTopLevelCategories() {
		return globalCategory.getChildren();
	}
	

		}
		
		// first, recursively remove the child categories
		Collection<Category> children = category.getChildren();
		Category[] childrenArray = children.toArray(new Category[children.size()]);
		for (Category child : childrenArray) {
			removeCategory(child);
		}
		
		// purge the constraints from this category, so that they know they
		//   are no longer in it
		Collection<IConstraintDescriptor> constraints = category.getConstraints();
		IConstraintDescriptor[] constraintsArray = constraints.toArray(
			new IConstraintDescriptor[constraints.size()]);
		for (IConstraintDescriptor constraint : constraintsArray) {
			category.removeConstraint(constraint);
		}
		
		// finally, remove the category from its parent

				EMFModelValidationPlugin.CONSTRAINT_PROVIDERS_EXT_P_NAME)
					.getConfigurationElements();
		
		for (IConfigurationElement next : elements) {
			IConfigurationElement next = elements[i];
			
			if (next.getName().equals(XmlConfig.E_CATEGORY)) {
				loadCategories(globalCategory, next);
			}

			IConfigurationElement[] subcategories = element.getChildren(
					XmlConfig.E_CATEGORY);
		
			for (IConfigurationElement element2 : subcategories) {
				// recursively load the child categories, if any
				loadCategories(category, element2);
			}
		} else {
			Trace.trace(

	 *  
	 * @return the mandatory categories
	 */
	public Collection<Category> getMandatoryCategories() {
		Collection<Category> result = new java.util.ArrayList<Category>();
		
		globalCategory.getMandatoryCategories(result);
		

Lines 15-23 Link Here

(-)src/org/eclipse/emf/validation/model/EvaluationMode.java (-38 / +24 lines)
15	import java.io.Serializable;	15	import java.io.Serializable;
16	import java.util.Arrays;	16	import java.util.Arrays;
17	import java.util.Collections;	17	import java.util.Collections;
18	import java.util.Iterator;
19	import java.util.List;	18	import java.util.List;
20		19
		20	import org.eclipse.emf.common.notify.Notification;
		21	import org.eclipse.emf.ecore.EObject;
21	import org.eclipse.emf.validation.internal.l10n.ValidationMessages;	22	import org.eclipse.emf.validation.internal.l10n.ValidationMessages;
22		23
23	/**	24	/**
Lines 31-46 Link Here
31	* still want critical constraints to be evaluated on batch invocations.	32	* still want critical constraints to be evaluated on batch invocations.
32	* </p>	33	* </p>
33	*	34	*
		35	* @param <T> the kind of object that is validated in an evaluation mode
		36	*
34	* @author Christian W. Damus (cdamus)	37	* @author Christian W. Damus (cdamus)
35	*/	38	*/
36	public final class EvaluationMode implements Serializable {	39	public final class EvaluationMode<T> implements Serializable {
37	private static final long serialVersionUID = -2088295328444150344L;
38
39	static final String LIVE_MODE = ValidationMessages.mode_live;
40	static final String BATCH_MODE = ValidationMessages.mode_batch;
41	static final String NULL_MODE = ValidationMessages.mode_unknown;
42		40
43	private static int nextOrdinal = 0;	41	private static final long serialVersionUID = 1862313226055912569L;
44		42
45	/**	43	/**
46	* <p>	44	* <p>
Lines 56-92 Link Here
56	* contexts.	54	* contexts.
57	* </b>	55	* </b>
58	*/	56	*/
59	public static final EvaluationMode LIVE =	57	public static final EvaluationMode<Notification> LIVE = new EvaluationMode<Notification>("Live", //$NON-NLS-1$
60	new EvaluationMode("Live", LIVE_MODE); //$NON-NLS-1$	58	ValidationMessages.mode_live);
61		59
62	/**	60	/**
63	* Constraints executed in the "Batch" context are intended to be	61	* Constraints executed in the "Batch" context are intended to be
64	* constraints that are evaluated on demand (when the user elects to	62	* constraints that are evaluated on demand (when the user elects to
65	* evaluate them). These do not, therefore, udually define conditions for	63	* evaluate them). These do not, therefore, usually define conditions for
66	* data integrity, but rather semantic rules that guide a user to creating	64	* data integrity, but rather semantic rules that guide a user to creating
67	* a better model.	65	* a better model.
68	*/	66	*/
69	public static final EvaluationMode BATCH =	67	public static final EvaluationMode<EObject> BATCH = new EvaluationMode<EObject>("Batch", //$NON-NLS-1$
70	new EvaluationMode("Batch", BATCH_MODE); //$NON-NLS-1$	68	ValidationMessages.mode_batch);
71		69
72	/**	70	/**
73	* This special value is a pointer-safe null value according to the	71	* This special value is a pointer-safe null value according to the
74	* <i>Null Object</i> pattern. It is not a valid evaluation mode for	72	* <i>Null Object</i> pattern. It is not a valid evaluation mode for
75	* a constraint.	73	* a constraint.
76	*/	74	*/
77	public static final EvaluationMode NULL =	75	public static final EvaluationMode<Void> NULL = new EvaluationMode<Void>("none", //$NON-NLS-1$
78	new EvaluationMode("none", NULL_MODE); //$NON-NLS-1$	76	ValidationMessages.mode_unknown);
79		77
80	/** All valid instances. */	78	/** All valid instances. */
81	private static final List instances = Collections.unmodifiableList(	79	private static final List<EvaluationMode<?>> instances = Collections.unmodifiableList(
82	Arrays.asList(new EvaluationMode[]{	80	Arrays.asList(new EvaluationMode<?>[] {LIVE, BATCH, NULL}));
83	LIVE,
84	BATCH,
85	NULL,
86	}));
87		81
88	private final String name;	82	private final String name;
89	private final int ordinal;
90	private final String localizedName;	83	private final String localizedName;
91		84
92	/**	85	/**
Lines 98-104 Link Here
98	*/	91	*/
99	private EvaluationMode(String name, String localizedName) {	92	private EvaluationMode(String name, String localizedName) {
100	this.name = name;	93	this.name = name;
101	this.ordinal = nextOrdinal++;
102	this.localizedName = localizedName;	94	this.localizedName = localizedName;
103	}	95	}
104		96
Lines 111-124 Link Here
111	* @param name the name of the instance to retrieve (not case-sensitive)	103	* @param name the name of the instance to retrieve (not case-sensitive)
112	* @return the named instance, or {@link #NULL} if no such instance exists	104	* @return the named instance, or {@link #NULL} if no such instance exists
113	*/	105	*/
114	public static EvaluationMode getInstance(String name) {	106	@SuppressWarnings("unchecked")
115	EvaluationMode result = NULL;	107	public static <T> EvaluationMode<T> getInstance(String name) {
116		108	EvaluationMode<T> result = (EvaluationMode<T>) NULL;
117	for (Iterator iter = instances.iterator(); iter.hasNext(); ) {
118	EvaluationMode next = (EvaluationMode)iter.next();
119		109
		110	for (EvaluationMode<?> next : instances) {
120	if (next.getName().equalsIgnoreCase(name)) {	111	if (next.getName().equalsIgnoreCase(name)) {
121	result = next;	112	result = (EvaluationMode<T>) next;
122	break;	113	break;
123	}	114	}
124	}	115	}
Lines 131-137 Link Here
131	*	122	*
132	* @return all values	123	* @return all values
133	*/	124	*/
134	public static final List getAllInstances() {	125	public static final List<EvaluationMode<?>> getAllInstances() {
135	return instances;	126	return instances;
136	}	127	}
137		128
Lines 193-209 Link Here
193	}	184	}
194		185
195	// re-implements the inherited method	186	// re-implements the inherited method
		187	@Override
196	public String toString() {	188	public String toString() {
197	return getName();	189	return getName();
198	}	190	}
199		191
200	/**
201	* Implements the instance substitution protocol defined by the Java
202	* Serialization Specification.
203	*
204	* @return the correct pre-defined instance of the enumeration
205	*/
206	private Object readResolve() {	192	private Object readResolve() {
207	return getAllInstances().get(ordinal);	193	return getInstance(getName());
208	}	194	}
209	}	195	}




	 * <p>
	 * <b>Note</b> that it is best to use the
	 * {@link IValidationContext#createSuccessStatus()} and
	 * {@link IValidationContext#createFailureStatus(Object...)} methods of the context
	 * object to create the status object returned from this method, to ensure
	 * that the status object returned is correctly handled by the validation
	 * system.

	 * cases, it can return a
	 * {@link ConstraintStatus#createMultiStatus(IValidationContext, Collection) multi-status} of
	 * multiple results created by the overloaded variants of the
	 * {@link ConstraintStatus#createStatus(IValidationContext, org.eclipse.emf.ecore.EObject, Collection, String, Object...)}
	 * method.  In these cases, also, each resulting status can store a distinct
	 * result locus.  For example:
	 * </p>

	 *         Must not return <code>null</code>
	 *         
	 * @see IValidationContext#createSuccessStatus()
	 * @see IValidationContext#createFailureStatus(Object...)
	 * @see ConstraintStatus#createStatus(IValidationContext, org.eclipse.emf.ecore.EObject, Collection, String, Object[])
	 */
	IStatus validate(IValidationContext ctx);

Lines 49-53 Link Here

(-)src/org/eclipse/emf/validation/model/IConstraintStatus.java (-1 / +1 lines)
49	* successful validation, the result is an empty collection. The result	49	* successful validation, the result is an empty collection. The result
50	* is never <code>null</code>	50	* is never <code>null</code>
51	*/	51	*/
52	Set getResultLocus();	52	Set<EObject> getResultLocus();
53	}	53	}





package org.eclipse.emf.validation.model;

import java.io.Serializable;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.emf.common.util.Enumerator;
import org.eclipse.emf.validation.internal.l10n.ValidationMessages;

/**

 * 
 * @author Christian W. Damus (cdamus)
 */
public enum ConstraintSeverity implements Enumerator {
	private static final long serialVersionUID = -5310833954198275258L;

	private static int nextOrdinal = 0;

	/**
	 * Indicates that failure of the constraint should only generate an
	 * informational message to the user.
	 */
	INFO("INFO", ValidationMessages.severity_info, IStatus.INFO), //$NON-NLS-1$
			"INFO", ValidationMessages.severity_info, IStatus.INFO); //$NON-NLS-1$
	
	/**
	 * Indicates that failure of the constraint constitutes a warning condition.
	 */
	WARNING("WARNING", ValidationMessages.severity_warning, IStatus.WARNING), //$NON-NLS-1$
			"WARNING", ValidationMessages.severity_warning, IStatus.WARNING); //$NON-NLS-1$

	/**
	 * Indicates that failure of the constraint constitutes an error condition.
	 */
	ERROR("ERROR", ValidationMessages.severity_error, IStatus.ERROR), //$NON-NLS-1$
			"ERROR", ValidationMessages.severity_error, IStatus.ERROR); //$NON-NLS-1$

	/**
	 * Indicates that failure of the constraint constitutes an error condition
	 * that should cancel the validation operation (no further constraints are
	 * evaluated).
	 */
	CANCEL("CANCEL", ValidationMessages.severity_cancel, IStatus.CANCEL), //$NON-NLS-1$
			"CANCEL", ValidationMessages.severity_cancel, IStatus.CANCEL); //$NON-NLS-1$
	/**
	 * This special value is a pointer-safe null value according to the
	 * <i>Null Object</i> pattern.  It is not a valid severity for
	 * a constraint.
	 */
	NULL("none", ValidationMessages.severity_null, IStatus.OK); //$NON-NLS-1$

	private static final long serialVersionUID = -5310833954198275258L;

	/** All of my values. */
	private static final List<ConstraintSeverity> instances = Collections.unmodifiableList(
			Arrays.asList(new ConstraintSeverity[]{
					INFO,
					WARNING,


	private final String name;
	private final String localizedName;
	private final int ordinal;
	private final int istatusSeverity;

	/**

	 */
	private ConstraintSeverity(String name, String localizedName, int istatusSeverity) {
		this.name = name;
		this.ordinal = nextOrdinal++;
		this.istatusSeverity = istatusSeverity;
		
		this.localizedName = localizedName;

	public static ConstraintSeverity getInstance(String name) {
		ConstraintSeverity result = NULL;

		for (ConstraintSeverity next : instances) {
			ConstraintSeverity next = (ConstraintSeverity)iter.next();

			if (next.getName().equalsIgnoreCase(name)) {
				result = next;
				break;

	 * 
	 * @return all values
	 */
	public static final List<ConstraintSeverity> getAllInstances() {
		return instances;
	}


	}

	// re-implements the inherited method
	@Override
	public String toString() {
		return getName();
	}
	
	public int getValue() {
		return ordinal();
	}
	
	public String getLiteral() {
		return getName();
	private Object readResolve() {
		return getAllInstances().get(ordinal);
	}
}




/******************************************************************************
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;


 * 
 * @author Christian W. Damus (cdamus)
 */
public class Category implements Comparable<Category> {
	static final String SLASH = "/"; //$NON-NLS-1$
	
	/**

	private boolean mandatory;
	
	private final Category parent;
	private final Map<String, Category> children =
		new java.util.HashMap<String, Category>();
	
	private final Set<IConstraintDescriptor> constraints =
		new java.util.HashSet<IConstraintDescriptor>();
	
	/**
	 * Initializes me with my ID and parent category.

	 * @return the {@link IConstraintDescriptor}s that are members of me as an
	 *     unmodifiable set
	 */
	public Set<IConstraintDescriptor> getConstraints() {
		return Collections.unmodifiableSet(constraints);
	}
	

	 * @return an unmodifiable set of the {@link Category}s that are
	 *     my children, sorted by {@link #getName name}.  May be an empty set
	 */
	public SortedSet<Category> getChildren() {
		return Collections.unmodifiableSortedSet(
				new java.util.TreeSet<Category>(children.values()));
	}
	
	/**

	 * @return the matching category, or <code>null</code> if not found
	 */
	public Category getChild(String childId) {
		return children.get(childId);
	}
	
	/**

	}
	
	// redefines the inherited method
	@Override
	public int hashCode() {
		return getPath().hashCode();
	}
	
	// redefines the inherited method
	@Override
	public boolean equals(Object other) {
		return (other instanceof Category)
			&& ((Category)other).getPath().equals(getPath());

	}
	
	// implements the interface method
	public int compareTo(Category other) {
		// this will throw if o has the wrong type.  That's expected
		Category other = (Category)o;

		Collator aCollator = getCollator();
		
		int result = aCollator.compare(getName(), other.getName());

	}
	
	// redefines the inherited method
	@Override
	public String toString() {
		StringBuffer result = new StringBuffer(32);
		

	 * 
	 * @param collection the collection of mandatory categories to which I append
	 */
	void getMandatoryCategories(Collection<? super Category> collection) {
		if (isMandatory()) {
			collection.add(this);
		}
		
		for (Category next : getChildren()) {
			Category next = (Category)iter.next();
			
			next.getMandatoryCategories(collection);
		}
	}




	private final IModelConstraint constraint;
	private EObject target;
	
	private Set<EObject> resultLocus;

	/**
	 * Initializes me as a failure of the specified <code>constraint</code>

	public ConstraintStatus(IModelConstraint constraint,
							EObject target,
							String message,
							Set<? extends EObject> resultLocus) {
		this(
			constraint,
			target,

							int severity,
							int code,
							String message,
							Set<? extends EObject> resultLocus) {
		super(severity, constraint.getDescriptor().getPluginId(), code, message, null);
		
		assert constraint != null;

		
		// unmodifiable defensive copy
		this.resultLocus = (resultLocus != null)
			? Collections.unmodifiableSet(new java.util.HashSet<EObject>(resultLocus))
			: Collections.<EObject>emptySet();
	}
	
	/**

	public static ConstraintStatus createStatus(
			IValidationContext ctx,
			EObject target,
			Collection<? extends EObject> resultLocus,
			String messagePattern,
			Object... messageArguments) {
		
		IConstraintDescriptor desc = ConstraintRegistry.getInstance().getDescriptor(
				ctx.getCurrentConstraintId());

	public static ConstraintStatus createStatus(
			IValidationContext ctx,
			EObject target,
			Collection<? extends EObject> resultLocus,
			int severity,
			int errorCode,
			String messagePattern,
			Object... messageArguments) {
		
		// need a prototype status to get certain critical information, such
		//    as the constraint object and target
		ConstraintStatus result = (ConstraintStatus) ctx.createFailureStatus();
		
		if (target != null) {
			result.target = target;
		}
		
		Set<EObject> results;
		if (resultLocus == null) {
			results = Collections.singleton(result.getTarget());
		} else {
			results = new java.util.HashSet<EObject>(resultLocus);
			if (!results.contains(result.getTarget())) {
				results.add(result.getTarget());
			}

	 */
	public static ConstraintStatus createStatus(
			IValidationContext ctx,
			Collection<? extends EObject> resultLocus,
			String messagePattern,
			Object... messageArguments) {
		
		IConstraintDescriptor desc = ConstraintRegistry.getInstance().getDescriptor(
				ctx.getCurrentConstraintId());

	 */
	public static ConstraintStatus createStatus(
			IValidationContext ctx,
			Collection<? extends EObject> resultLocus,
			int severity,
			int errorCode,
			String messagePattern,
			Object... messageArguments) {
		return createStatus(ctx, null, resultLocus,
				severity, errorCode,
				messagePattern, messageArguments);

	public static IStatus createSuccessStatus(
			IValidationContext ctx,
			EObject target,
			Collection<? extends EObject> resultLocus) {
		IStatus status = ctx.createSuccessStatus();

		if (status instanceof IConstraintStatus) {
			IConstraintStatus successStatus = (IConstraintStatus)status;
			ConstraintStatus constraintStatus = new ConstraintStatus(successStatus.getConstraint(), target);
			
			Set<EObject> results;
			if (resultLocus == null) {
				results = Collections.singleton(target);
			} else {
				results = new java.util.HashSet<EObject>(resultLocus);
				if (!results.contains(target)) {
					results.add(target);
				}

	 * 
	 * @see #createMultiStatus(IValidationContext, String, Object[], Collection)
	 */
	public static IStatus createMultiStatus(IValidationContext ctx,
			Collection<? extends IStatus> statuses) {
		return createMultiStatus(
				ctx,
				ValidationMessages.eval_some_fail_WARN_, null,

	public static IStatus createMultiStatus(
			IValidationContext ctx,
			String messagePattern, Object[] messageArguments,
			Collection<? extends IStatus> statuses) {
		if (statuses == null || statuses.isEmpty()) {
			throw new IllegalArgumentException("no statuses to aggregate"); //$NON-NLS-1$
		}
		
		IStatus[] children = statuses.toArray(new IStatus[statuses.size()]);
		
		IConstraintDescriptor desc = ConstraintRegistry.getInstance().getDescriptor(
				ctx.getCurrentConstraintId());

	 *     successful validation, the result is an empty collection.  The result
	 *     is never <code>null</code>
	 */
	public final Set<EObject> getResultLocus() {
		return resultLocus;
	}
	

			implements IConstraintStatus {
		private final IModelConstraint constraint;
		private final EObject target;
		private final Set<EObject> resultLocus;
		
		Multi(String pluginId, int code, IStatus[] children, String message) {
			super(pluginId, code, children, message, null);
			
			IConstraintStatus prototype = null;
			
			for (IStatus element : children) {
				if (element instanceof IConstraintStatus) {
					prototype = (IConstraintStatus) element;
					break;
				}
			}

			if (prototype == null) {
				constraint = null;
				target = null;
				resultLocus = Collections.emptySet();
			} else {
				constraint = prototype.getConstraint();
				target = prototype.getTarget();

			return target;
		}
		
		public Set<EObject> getResultLocus() {
			return resultLocus;
		}
	}




 *
 * @author Christian W. Damus (cdamus)
 */
@SuppressWarnings("deprecation")
public class EMFConstraintParser
		implements IParameterizedConstraintParser, IXmlConstraintParser {
	private static final String PARAMETER_CLASS = "class"; //$NON-NLS-1$

	private static final String METHOD_NOT_FOUND = ValidationMessages.emfadapter_methodNotFound_WARN_;
	
	/** The signature of validation methods in the EMF API. */
	private static final Class<?>[] VALIDATION_METHOD_SIGNATURE = new Class<?>[] {
			DiagnosticChain.class,
			java.util.Map.class,
		};

		try {
			// use the contributing plug-in's class loader to get the interface
			//    type (in case the plug-in isn't my own)
			Class<?> emfInterface = bundle.loadClass(className);
			
			// get the method, which we know has always the same signature in
			//    the EMF API




	 * since the EMF APIs have no access to it and there is nothing else in
	 * this adapter layer maintains a reference to it.
	 */
	private static final Map<IValidationContext, Map<Object, Object>> contextMapCache =
		new java.util.WeakHashMap<IValidationContext, Map<Object,Object>>();
	
	private final IConstraintDescriptor descriptor;
	private final Method validationMethod;

			(EMFValidationContextAdapter)validationArgs[0];
		
		ctxAdapter.setAdaptedContext(ctx);
		validationArgs[1] = getEMFContextFor(ctx);
		
		try {
			boolean success = ((Boolean)validationMethod.invoke(

	private IStatus fail(EMFValidationContextAdapter ctxAdapter) {
		final IValidationContext ctx = ctxAdapter.getAdaptedContext();
		
		List<EObject> resultLocus = new java.util.ArrayList<EObject>(ctx.getResultLocus());
		resultLocus.remove(ctx.getTarget());
		
		Diagnostic status = ctxAdapter.getLastStatus();

		//   1 - the result locus minus the target(as a collection of
		//       model elements)
		return ctx.createFailureStatus(
			new Object[] {
				(status == null) ? null : status.getMessage(),
				resultLocus);
	}
	
	/**

			getDescriptor().getStatusCode(),
			EMFModelValidationPlugin.getMessage(
				ValidationMessages.emfadapter_disabled_WARN_,
				getDescriptor().getName()),
			Collections.<EObject>emptySet());
		
		EMFModelValidationPlugin.getPlugin().getLog().log(
			new Status(

	 * @param ctx our validation context
	 * @return the corresponding EMF validation context
	 */
	private static Map<Object, Object> getEMFContextFor(IValidationContext ctx) {
		Map<Object, Object> result = contextMapCache.get(ctx);
		
		if (result == null) {
			result = new java.util.HashMap<Object, Object>();
			
			// add a substitution label provider for good measure
			result.put(





package org.eclipse.emf.validation.internal.emfadapter;

import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.common.util.BasicDiagnostic;

	/* (non-Javadoc)
	 * Redefines the inherited method
	 */
	@Override
	public void add(Diagnostic diagnostic) {
		if (diagnostic.getSeverity() != Diagnostic.OK) {
			List<?> ddata = diagnostic.getData();
			
			if (ddata != null) {
				// add any EObjects that we find to our results
				
				for (Object next : ddata) {
					Object next = iter.next();
					
					if (next instanceof EObject) {
						adaptedContext.addResult((EObject) next);
					}

Lines 54-60 Link Here

(-)src/org/eclipse/emf/validation/AbstractModelConstraint.java (-2 / +2 lines)
54	* <p>	54	* <p>
55	* <b>Note</b> that it is best to use the	55	* <b>Note</b> that it is best to use the
56	* {@link IValidationContext#createSuccessStatus()} and	56	* {@link IValidationContext#createSuccessStatus()} and
57	* {@link IValidationContext#createFailureStatus(Object[])} methods of the context	57	* {@link IValidationContext#createFailureStatus(Object...)} methods of the context
58	* object to create the status object returned from this method, to ensure	58	* object to create the status object returned from this method, to ensure
59	* that the status object returned is correctly handled by the validation	59	* that the status object returned is correctly handled by the validation
60	* system.	60	* system.
Lines 110-116 Link Here
110	* Must not return <code>null</code>	110	* Must not return <code>null</code>
111	*	111	*
112	* @see IValidationContext#createSuccessStatus()	112	* @see IValidationContext#createSuccessStatus()
113	* @see IValidationContext#createFailureStatus(Object[])	113	* @see IValidationContext#createFailureStatus(Object...)
114	* @see ConstraintStatus#createStatus(IValidationContext, java.util.Collection, String, Object[])	114	* @see ConstraintStatus#createStatus(IValidationContext, java.util.Collection, String, Object[])
115	* @see ConstraintStatus#createMultiStatus(IValidationContext, Collection)	115	* @see ConstraintStatus#createMultiStatus(IValidationContext, Collection)
116	*/	116	*/




import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;



	private static int nextNotificationTypeCode = 0;
	
    private static final Map<String, EMFEventType> nameToInstance =
    	new java.util.HashMap<String, EMFEventType>();
    
	/**
	 * The EMF "Add" event (corresponds to {@link Notification#ADD}).

			-1);

	/** All of my values. */
	private static final List<EMFEventType> predefinedInstances = Collections.unmodifiableList(
			Arrays.asList(new EMFEventType[]{
					ADD,
					ADD_MANY,

					NULL,
				}));

	private static final List<EMFEventType> instances = new ArrayList<EMFEventType>(
			predefinedInstances);
	
	private final String name;
	private final boolean featureSpecific;

	public static EMFEventType getInstance(String name) {
		EMFEventType result = NULL;

		for (EMFEventType next : instances) {
			EMFEventType next = (EMFEventType)iter.next();

			if (next.getName().equalsIgnoreCase(name)) {
				result = next;
				break;

	public static EMFEventType getInstance(int code) {
		EMFEventType result = NULL;

		for (EMFEventType next : instances) {
			EMFEventType next = (EMFEventType)iter.next();

			if (next.toNotificationType() == code) {
				result = next;
				break;

	 * 
	 * @return all values
	 */
	public static final List<EMFEventType> getAllInstances() {
		return instances;
	}


	 * 
	 * @return all predefined values
	 */
	public static final List<EMFEventType> getPredefinedInstances() {
		return predefinedInstances;
	}
	

	}

	// re-implements the inherited method
	@Override
	public String toString() {
		return getName();
	}




/******************************************************************************
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import java.util.Set;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.validation.model.ConstraintStatus;

	 * @return the raw {@link org.eclipse.emf.common.notify.Notification}s being validated, or an empty
	 *    list if this is a batch validation.  This list is not modifiable
	 */
	List<Notification> getAllEvents();
	
	/**
	 * In the case of a live constraint evaluation, obtains the particular

	 * 
	 * @see #skipCurrentConstraintFor(EObject)
	 */
	void skipCurrentConstraintForAll(Collection<?> eObjects);
	
	/**
	 * <p>

	 * 
	 * @see #addResult(EObject)
	 */
	Set<EObject> getResultLocus();
	
	/**
	 * Adds a result to the result locus of the current constraint.  The result

	 * 
	 * @see #addResult(EObject)
	 */
	void addResults(Collection<? extends EObject> eObjects);
	
	/**
	 * Creates a status object indicating successful evaluation of the

	 * the severity, error code, and message defined in the constraint meta-data
	 * in the XML.
	 * 
	 * @param messageArgument the positional {0}, {1}, etc. arguments to
	 *      replace in the message pattern (may by <code>null</code> if none
	 *      are needed)
	 * @return the status indicating a constraint violation
	 */
	IStatus createFailureStatus(Object... messageArgument);
}

Lines 29-33 Link Here

(-)build.properties (-2 / +2 lines)
29	jars.compile.order = .	29	jars.compile.order = .
30	source.. = src/	30	source.. = src/
31	output.. = bin/	31	output.. = bin/
32	javacSource = 1.4	32	javacSource = 1.5
33	javacTarget = 1.4	33	javacTarget = 1.5

Lines 1-7 Link Here

(-).classpath (-1 / +1 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<classpath>	2	<classpath>
3	<classpathentry kind="src" path="src"/>	3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/>	4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>	5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
6	<classpathentry kind="output" path="bin"/>	6	<classpathentry kind="output" path="bin"/>
7	</classpath>	7	</classpath>




			public void run(IProgressMonitor m)
				throws CoreException {
				
				final Map<URI, IFile> visitedResources = new HashMap<URI, IFile>();
				
				if (validationStatus.isMultiStatus()) {
					IStatus[] children = validationStatus.getChildren();
					for (IStatus element : children) {
						if (element instanceof IConstraintStatus) {
							createMarker((IConstraintStatus)element, markerType, configurator, visitedResources);
						}
					}
				} else if (validationStatus instanceof IConstraintStatus) {

	}

	private static void createMarker(IConstraintStatus status,
			String markerType, IMarkerConfigurator configurator,
			Map<URI, IFile> visitedResources) throws CoreException {

		Resource r = status.getTarget().eResource();
		URI uri = r.getURI();

		// Normalize the URI to something that we can deal with like file or platform scheme
		uri = r.getResourceSet().getURIConverter().normalize(uri);

		IFile file = visitedResources.get(uri);
		
		if (file == null) {
			if (PLATFORM_SCHEME.equals(uri.scheme()) && uri.segmentCount() > 1




	}

	// implements the inherited method
	@Override
	public ResourceLocator getPluginResourceLocator() {
		return plugin;
	}

		}

		// extends the inherited method
		@Override
		public void start(BundleContext context) throws Exception {
			super.start(context);


    	/**
    	 * The cached debug options (for optimization).
    	 */
    	private static final Map<String, Boolean> cachedOptions = new HashMap<String, Boolean>();

    	/**
    	 * Retrieves a Boolean value indicating whether tracing is enabled.

    			Boolean value = null;
    			
    			synchronized (cachedOptions) {
    				value = cachedOptions.get(option);
    	
    				if (null == value) {
    					value =

    	 */
    	public static void changing(
            String option,
            Class<?> clazz,
            String methodName,
            String valueDescription,
            Object oldValue,

    	 */
    	public static void catching(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Throwable throwable) {


    	 */
    	public static void throwing(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Throwable throwable) {


    	 */
    	public static void entering(
    		String option,
    		Class<?> clazz,
    		String methodName) {

    		if (shouldTrace(option)) {

    	 */
    	public static void entering(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Object parameter) {


    	 */
    	public static void entering(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Object[] parameters) {


    	 */
    	public static void exiting(
    		String option,
    		Class<?> clazz,
    		String methodName) {

    		if (shouldTrace(option)) {

    	 */
    	public static void exiting(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Object returnValue) {


    	}
    }

	public static void catching(Class<?> class1, String functionName, Throwable exception) {
		Tracing.catching(EMFModelValidationDebugOptions.EXCEPTIONS_CATCHING, class1, functionName, exception);
	}
	
	public static void throwing(Class<?> class1, String functionName, Throwable exception) {
		Tracing.throwing(EMFModelValidationDebugOptions.EXCEPTIONS_THROWING, class1, functionName, exception);
	}


	 * 
	 * @see org.eclipse.osgi.util.NLS
	 */
	public static String getMessage(String messagePattern, Object... args) {
		return formatMessage(messagePattern, args);
	}
	

	 * 
	 * @see org.eclipse.osgi.util.NLS
	 */
	private static String formatMessage(String messagePattern, Object... args) {
		try {
			return NLS.bind(messagePattern, args);
		} catch (Exception e) {

	 * @return the list, <code>strings[0]</code> if there is only one element,
	 *    or <code>""</code> if the array has no elements
	 */
	public static String formatList(Collection<?> items) {
		switch (items.size()) {
			case 0 :
				return ""; //$NON-NLS-1$

	 * 
	 * @see #formatList(Collection)
	 */
	private static String formatList2(Collection<?> items) {
		Iterator<?> iter = items.iterator();
		int max = items.size() - 1;

		final String sep = getString(

	 * 
	 * @see #formatList(Collection)
	 */
	private static String formatPair(Collection<?> items) {
		Iterator<?> iter = items.iterator();

		StringBuffer result = new StringBuffer(32);


Lines 25-28 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
25	com.ibm.icu;bundle-version="[3.4.3,4.0.0)",	25	com.ibm.icu;bundle-version="[3.4.3,4.0.0)",
26	org.eclipse.core.resources;bundle-version="[3.2.0,4.0.0)"	26	org.eclipse.core.resources;bundle-version="[3.2.0,4.0.0)"
27	Eclipse-LazyStart: true	27	Eclipse-LazyStart: true
28	Bundle-RequiredExecutionEnvironment: J2SE-1.4	28	Bundle-RequiredExecutionEnvironment: J2SE-1.5

Lines 1-5 Link Here

(-)src/org/eclipse/emf/validation/xml/AbstractXmlConstraintDescriptor.java (-1 / +2 lines)
1	/******************************************************************************	1	/******************************************************************************
2	* Copyright (c) 2005 IBM Corporation and others.	2	* Copyright (c) 2005, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 32-37 Link Here
32	*	32	*
33	* @author Chris McGee (cmcgee)	33	* @author Chris McGee (cmcgee)
34	*/	34	*/
		35	@SuppressWarnings("deprecation")
35	public abstract class AbstractXmlConstraintDescriptor	36	public abstract class AbstractXmlConstraintDescriptor
36	extends AbstractConstraintDescriptor	37	extends AbstractConstraintDescriptor
37	implements IXmlConstraintDescriptor {	38	implements IXmlConstraintDescriptor {




	 * @throws CoreException if the superclass implementation of this
	 *    method throws or on an error in accessing the <code>config</code>
	 */
	@Override
	public void setInitializationData(
			IConfigurationElement config,
			String propertyName,

		IConfigurationElement[] constraintses = config.getChildren(
				XmlConfig.E_CONSTRAINTS);
		
		for (IConfigurationElement element : constraintses) {
			IConfigurationElement next =
				XmlConfig.parseConstraintsWithIncludes(element);
			
			IConfigurationElement[] configs = next.getChildren();

			for (IConfigurationElement element2 : configs) {
				addConstraint(element2);
			}
		}
		

	 * 
	 * @param config the <TT>&lt;constraint&gt;</TT> element
	 */
	@SuppressWarnings("deprecation")
	private void addConstraint(IConfigurationElement config) {
		final String contributorId = config
			.getDeclaringExtension()

Lines 1-8 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-5 / +5 lines)
1	#Wed Dec 20 11:44:32 EST 2006	1	#Thu Nov 08 18:54:38 EST 2007
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled	3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.4	4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
5	org.eclipse.jdt.core.compiler.compliance=1.4	5	org.eclipse.jdt.core.compiler.compliance=1.5
6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error	6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning	7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
8	org.eclipse.jdt.core.compiler.source=1.4	8	org.eclipse.jdt.core.compiler.source=1.5

Lines 1-7 Link Here

(-).classpath (-1 / +1 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<classpath>	2	<classpath>
3	<classpathentry kind="src" path="src"/>	3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/>	4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>	5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
6	<classpathentry kind="output" path="bin"/>	6	<classpathentry kind="output" path="bin"/>
7	</classpath>	7	</classpath>

Lines 21-25 Link Here

(-)build.properties (-2 / +2 lines)
21	src.includes = plugin.xml,\	21	src.includes = plugin.xml,\
22	plugin.properties,\	22	plugin.properties,\
23	about.html	23	about.html
24	javacSource = 1.4	24	javacSource = 1.5
25	javacTarget = 1.4	25	javacTarget = 1.5




Bundle-ManifestVersion: 2
Bundle-Name: %Plugin.name
Bundle-SymbolicName: org.eclipse.emf.validation.ui.ide; singleton:=true
Bundle-Version: 1.2.0.qualifier
Bundle-Activator: org.eclipse.emf.validation.ui.ide.internal.ValidationUIIDEPlugin$Implementation
Bundle-Vendor: %Plugin.providerName
Bundle-Localization: plugin
Export-Package: org.eclipse.emf.validation.ui.ide.internal;x-internal:=true,
 org.eclipse.emf.validation.ui.ide.internal.l10n;x-internal:=true,
 org.eclipse.emf.validation.ui.ide.quickfix
Require-Bundle: org.eclipse.emf.validation;bundle-version="[1.2.0,2.0.0)",
 org.eclipse.emf.validation.ui;bundle-version="[1.2.0,2.0.0)";visibility:=reexport,
 org.eclipse.ui;bundle-version="[3.2.0,4.0.0)",
 org.eclipse.ui.ide;bundle-version="[3.2.0,4.0.0)",
 org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
 org.eclipse.core.resources;bundle-version="[3.2.0,4.0.0)"
Eclipse-LazyStart: true
Bundle-RequiredExecutionEnvironment: J2SE-1.5

Lines 1-8 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-5 / +5 lines)
1	#Wed Dec 20 11:49:40 EST 2006	1	#Thu Nov 08 19:08:49 EST 2007
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled	3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.4	4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
5	org.eclipse.jdt.core.compiler.compliance=1.4	5	org.eclipse.jdt.core.compiler.compliance=1.5
6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error	6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning	7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
8	org.eclipse.jdt.core.compiler.source=1.4	8	org.eclipse.jdt.core.compiler.source=1.5

Lines 88-97 Link Here

(-)src/org/eclipse/emf/validation/ui/ide/quickfix/ValidationMarkerResolution.java (-2 / +2 lines)
88	if (result) {	88	if (result) {
89	// see whether this constraint is in any mandatory category	89	// see whether this constraint is in any mandatory category
90		90
91	for (Iterator iter = constraint.getCategories().iterator();	91	for (Iterator<Category> iter = constraint.getCategories().iterator();
92	result && iter.hasNext();) {	92	result && iter.hasNext();) {
93		93
94	result = !((Category) iter.next()).isMandatory();	94	result = !iter.next().isMandatory();
95	}	95	}
96	}	96	}
97		97




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

        super(new ResourceLocator[] {});
    }

    @Override
    public ResourceLocator getPluginResourceLocator() {
        return plugin;
    }

    	/**
    	 * The cached debug options (for optimization).
    	 */
    	private static final Map<String, Boolean> cachedOptions =
    	    new HashMap<String, Boolean>();

    	/**
    	 * Retrieves a Boolean value indicating whether tracing is enabled.

    			Boolean value = null;
    			
    			synchronized (cachedOptions) {
    				value = cachedOptions.get(option);
    	
    				if (null == value) {
    					value =

    	 */
    	public static void changing(
            String option,
            Class<?> clazz,
            String methodName,
            String valueDescription,
            Object oldValue,

    	 */
    	public static void catching(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Throwable throwable) {


    	 */
    	public static void throwing(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Throwable throwable) {


    	 */
    	public static void entering(
    		String option,
    		Class<?> clazz,
    		String methodName) {

    		if (shouldTrace(option)) {

    	 */
    	public static void entering(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Object parameter) {


    	 */
    	public static void entering(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Object[] parameters) {


    	 */
    	public static void exiting(
    		String option,
    		Class<?> clazz,
    		String methodName) {

    		if (shouldTrace(option)) {

    	 */
    	public static void exiting(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Object returnValue) {


Lines 30-35 Link Here

(-)src/org/eclipse/emf/validation/examples/ocl/OCLConstraintProvider.java (-2 / +2 lines)
30	import org.eclipse.core.runtime.Status;	30	import org.eclipse.core.runtime.Status;
31	import org.eclipse.emf.validation.model.Category;	31	import org.eclipse.emf.validation.model.Category;
32	import org.eclipse.emf.validation.model.CategoryManager;	32	import org.eclipse.emf.validation.model.CategoryManager;
		33	import org.eclipse.emf.validation.model.IModelConstraint;
33	import org.eclipse.emf.validation.service.AbstractConstraintProvider;	34	import org.eclipse.emf.validation.service.AbstractConstraintProvider;
34	import org.eclipse.emf.validation.service.ConstraintExistsException;	35	import org.eclipse.emf.validation.service.ConstraintExistsException;
35	import org.eclipse.ocl.OCLInput;	36	import org.eclipse.ocl.OCLInput;
Lines 136-143 Link Here
136	}	137	}
137		138
138	private void addConstraint(Category category, String namespace, OCL ocl, Constraint constraint) {	139	private void addConstraint(Category category, String namespace, OCL ocl, Constraint constraint) {
139	@SuppressWarnings("unchecked")	140	Collection<IModelConstraint> constraints = getConstraints();
140	Collection<OCLConstraint> constraints = getConstraints();
141		141
142	OCLConstraintDescriptor desc = new OCLConstraintDescriptor(	142	OCLConstraintDescriptor desc = new OCLConstraintDescriptor(
143	namespace, constraint, constraints.size() + 1);	143	namespace, constraint, constraints.size() + 1);

Lines 61-67 Link Here

(-)src/org/eclipse/emf/validation/examples/ocl/OCLConstraintDescriptor.java (-2 / +2 lines)
61	return getBody();	61	return getBody();
62	}	62	}
63		63
64	public EvaluationMode getEvaluationMode() {	64	public EvaluationMode<?> getEvaluationMode() {
65	return EvaluationMode.BATCH;	65	return EvaluationMode.BATCH;
66	}	66	}
67		67
Lines 70-76 Link Here
70	}	70	}
71		71
72	public String getMessagePattern() {	72	public String getMessagePattern() {
73	return "Constraint " + getName() + " violated on {0}";	73	return String.format("Constraint %s violated on {0}", getName()); //$NON-NLS-1$
74	}	74	}
75		75
76	public String getName() {	76	public String getName() {




Bundle-ManifestVersion: 2
Bundle-Name: %Plugin.name
Bundle-SymbolicName: org.eclipse.emf.validation.examples.ocl; singleton:=true
Bundle-Version: 1.2.0.qualifier
Bundle-Activator: org.eclipse.emf.validation.examples.ocl.OCLValidationExamplePlugin
Bundle-Vendor: %Plugin.providerName
Bundle-Localization: plugin
Export-Package: org.eclipse.emf.validation.examples.ocl
Require-Bundle: org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
 org.eclipse.emf.validation;bundle-version="[1.2.0,2.0.0)",
 org.eclipse.emf.validation.ocl;bundle-version="[1.1.0,2.0.0)",
 org.eclipse.ocl.ecore;bundle-version="[1.1.0,2.0.0)"
Eclipse-LazyStart: true




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import java.util.Date;

import ordersystem.Account;
import ordersystem.Address;
import ordersystem.Customer;
import ordersystem.InventoryItem;
import ordersystem.LineItem;
import ordersystem.Order;
import ordersystem.OrderSystem;
import ordersystem.OrderSystemFactory;
import ordersystem.OrderSystemPackage;
import ordersystem.Product;
import ordersystem.Warehouse;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EDataType;
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;

/**
 * <!-- begin-user-doc -->

 */
public class OrderSystemFactoryImpl extends EFactoryImpl implements OrderSystemFactory {
	/**
	 * Creates the default factory implementation.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public static OrderSystemFactory init() {
		try {
			OrderSystemFactory theOrderSystemFactory = (OrderSystemFactory)EPackage.Registry.INSTANCE.getEFactory("http:///ordersystem.ecore"); //$NON-NLS-1$ 
			if (theOrderSystemFactory != null) {
				return theOrderSystemFactory;
			}
		}
		catch (Exception exception) {
			EcorePlugin.INSTANCE.log(exception);
		}
		return new OrderSystemFactoryImpl();
	}

	/**
	 * Creates an instance of the factory.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @generated

     * <!-- end-user-doc -->
	 * @generated
	 */
    @Override
				public EObject create(EClass eClass) {
		switch (eClass.getClassifierID()) {
			case OrderSystemPackage.ORDER: return createOrder();
			case OrderSystemPackage.PRODUCT: return createProduct();

     * <!-- end-user-doc -->
	 * @generated
	 */
    @Override
				public Object createFromString(EDataType eDataType, String initialValue) {
		switch (eDataType.getClassifierID()) {
			case OrderSystemPackage.JAVA_DATE:
				return createJavaDateFromString(eDataType, initialValue);

     * <!-- end-user-doc -->
	 * @generated
	 */
    @Override
				public String convertToString(EDataType eDataType, Object instanceValue) {
		switch (eDataType.getClassifierID()) {
			case OrderSystemPackage.JAVA_DATE:
				return convertJavaDateToString(eDataType, instanceValue);

	 * @deprecated
	 * @generated
	 */
    @Deprecated
				public static OrderSystemPackage getPackage() {
		return OrderSystemPackage.eINSTANCE;
	}
} //OrderSystemFactoryImpl




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;

import org.eclipse.emf.common.util.EList;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;

import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;

import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
import org.eclipse.emf.ecore.util.InternalEList;


	 * @generated
	 * @ordered
	 */
    protected EList<Customer> customer;

	/**
	 * The cached value of the '{@link #getProduct() <em>Product</em>}' containment reference list.

	 * @generated
	 * @ordered
	 */
    protected EList<Product> product;

	/**
	 * The cached value of the '{@link #getWarehouse() <em>Warehouse</em>}' containment reference list.

	 * @generated
	 * @ordered
	 */
    protected EList<Warehouse> warehouse;

	/**
	 * <!-- begin-user-doc -->

     * <!-- end-user-doc -->
	 * @generated
	 */
    @Override
				protected EClass eStaticClass() {
		return OrderSystemPackage.Literals.ORDER_SYSTEM;
	}

	/**

     * <!-- end-user-doc -->
	 * @generated
	 */
    public EList<Customer> getCustomer() {
		if (customer == null) {
			customer = new EObjectContainmentWithInverseEList<Customer>(Customer.class, this, OrderSystemPackage.ORDER_SYSTEM__CUSTOMER, OrderSystemPackage.CUSTOMER__OWNER);
		}
		return customer;
	}

     * <!-- end-user-doc -->
	 * @generated
	 */
    public EList<Product> getProduct() {
		if (product == null) {
			product = new EObjectContainmentWithInverseEList<Product>(Product.class, this, OrderSystemPackage.ORDER_SYSTEM__PRODUCT, OrderSystemPackage.PRODUCT__OWNER);
		}
		return product;
	}

     * <!-- end-user-doc -->
	 * @generated
	 */
    public EList<Warehouse> getWarehouse() {
		if (warehouse == null) {
			warehouse = new EObjectContainmentWithInverseEList<Warehouse>(Warehouse.class, this, OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE, OrderSystemPackage.WAREHOUSE__OWNER);
		}
		return warehouse;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@SuppressWarnings("unchecked")
		@Override
	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:
				return ((InternalEList<InternalEObject>)(InternalEList<?>)getCustomer()).basicAdd(otherEnd, msgs);
			case OrderSystemPackage.ORDER_SYSTEM__PRODUCT:
				return ((InternalEList<InternalEObject>)(InternalEList<?>)getProduct()).basicAdd(otherEnd, msgs);
			case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:
				return ((InternalEList<InternalEObject>)(InternalEList<?>)getWarehouse()).basicAdd(otherEnd, msgs);
					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseAdd(otherEnd, featureID, msgs);
			msgs = eBasicRemoveFromContainer(msgs);
		return eBasicSetContainer(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:
				return ((InternalEList<?>)getCustomer()).basicRemove(otherEnd, msgs);
			case OrderSystemPackage.ORDER_SYSTEM__PRODUCT:
				return ((InternalEList<?>)getProduct()).basicRemove(otherEnd, msgs);
			case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:
				return ((InternalEList<?>)getWarehouse()).basicRemove(otherEnd, msgs);
				default:
					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseRemove(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case OrderSystemPackage.ORDER_SYSTEM__VERSION:
				return new Integer(getVersion());
			case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:

			case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:
				return getWarehouse();
		}
		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 OrderSystemPackage.ORDER_SYSTEM__VERSION:
				setVersion(((Integer)newValue).intValue());
				return;
			case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:
				getCustomer().clear();
				getCustomer().addAll((Collection<? extends Customer>)newValue);
				return;
			case OrderSystemPackage.ORDER_SYSTEM__PRODUCT:
				getProduct().clear();
				getProduct().addAll((Collection<? extends Product>)newValue);
				return;
			case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:
				getWarehouse().clear();
				getWarehouse().addAll((Collection<? extends Warehouse>)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.ORDER_SYSTEM__VERSION:
				setVersion(VERSION_EDEFAULT);
				return;

				getWarehouse().clear();
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.ORDER_SYSTEM__VERSION:
				return version != VERSION_EDEFAULT;
			case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:

			case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:
				return warehouse != null && !warehouse.isEmpty();
		}
		return super.eIsSet(featureID);
	}

	/**
     * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
     */




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;

import org.eclipse.emf.common.util.EList;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;

import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;

import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.InternalEList;

	 * @generated
	 * @ordered
	 */
    protected EList<InventoryItem> item;

	/**
	 * The cached value of the '{@link #getLocation() <em>Location</em>}' containment reference.

	 * @generated
	 * @ordered
	 */
    protected Address location;

	/**
	 * <!-- begin-user-doc -->

     * <!-- end-user-doc -->
	 * @generated
	 */
    @Override
				protected EClass eStaticClass() {
		return OrderSystemPackage.Literals.WAREHOUSE;
	}

	/**

	 */
    public OrderSystem getOwner() {
		if (eContainerFeatureID != OrderSystemPackage.WAREHOUSE__OWNER) return null;
		return (OrderSystem)eContainer();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain basicSetOwner(OrderSystem newOwner, NotificationChain msgs) {
		msgs = eBasicSetContainer((InternalEObject)newOwner, OrderSystemPackage.WAREHOUSE__OWNER, msgs);
		return msgs;
	}

	/**

	 * @generated
	 */
    public void setOwner(OrderSystem newOwner) {
		if (newOwner != eInternalContainer() || (eContainerFeatureID != OrderSystemPackage.WAREHOUSE__OWNER && newOwner != null)) {
			if (EcoreUtil.isAncestor(this, newOwner))
				throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$
			NotificationChain msgs = null;
			if (eInternalContainer() != null)
				msgs = eBasicRemoveFromContainer(msgs);
			if (newOwner != null)
				msgs = ((InternalEObject)newOwner).eInverseAdd(this, OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE, OrderSystem.class, msgs);
			msgs = basicSetOwner(newOwner, msgs);
			if (msgs != null) msgs.dispatch();
		}
		else if (eNotificationRequired())

     * <!-- end-user-doc -->
	 * @generated
	 */
    public EList<InventoryItem> getItem() {
		if (item == null) {
			item = new EObjectContainmentWithInverseEList<InventoryItem>(InventoryItem.class, this, OrderSystemPackage.WAREHOUSE__ITEM, OrderSystemPackage.INVENTORY_ITEM__WAREHOUSE);
		}
		return item;
	}


	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@SuppressWarnings("unchecked")
		@Override
	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.WAREHOUSE__OWNER:
				if (eInternalContainer() != null)
					msgs = eBasicRemoveFromContainer(msgs);
				return basicSetOwner((OrderSystem)otherEnd, msgs);
			case OrderSystemPackage.WAREHOUSE__ITEM:
				return ((InternalEList<InternalEObject>)(InternalEList<?>)getItem()).basicAdd(otherEnd, msgs);
					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseAdd(otherEnd, featureID, msgs);
			msgs = eBasicRemoveFromContainer(msgs);
		return eBasicSetContainer(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.WAREHOUSE__OWNER:
				return basicSetOwner(null, msgs);
			case OrderSystemPackage.WAREHOUSE__ITEM:
				return ((InternalEList<?>)getItem()).basicRemove(otherEnd, msgs);
			case OrderSystemPackage.WAREHOUSE__LOCATION:
				return basicSetLocation(null, msgs);
				default:
					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseRemove(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
		switch (eContainerFeatureID) {
			case OrderSystemPackage.WAREHOUSE__OWNER:
				return eInternalContainer().eInverseRemove(this, OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE, OrderSystem.class, msgs);
				default:
					return eDynamicBasicRemoveFromContainer(msgs);
			}
		}
		return super.eBasicRemoveFromContainerFeature(msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case OrderSystemPackage.WAREHOUSE__NAME:
				return getName();
			case OrderSystemPackage.WAREHOUSE__OWNER:

			case OrderSystemPackage.WAREHOUSE__LOCATION:
				return getLocation();
		}
		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 OrderSystemPackage.WAREHOUSE__NAME:
				setName((String)newValue);
				return;

				return;
			case OrderSystemPackage.WAREHOUSE__ITEM:
				getItem().clear();
				getItem().addAll((Collection<? extends InventoryItem>)newValue);
				return;
			case OrderSystemPackage.WAREHOUSE__LOCATION:
				setLocation((Address)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.WAREHOUSE__NAME:
				setName(NAME_EDEFAULT);
				return;

				setLocation((Address)null);
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.WAREHOUSE__NAME:
				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
			case OrderSystemPackage.WAREHOUSE__OWNER:

			case OrderSystemPackage.WAREHOUSE__LOCATION:
				return location != null;
		}
		return super.eIsSet(featureID);
	}

	/**
     * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
     */




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import ordersystem.OrderSystemPackage;
import ordersystem.Product;
import ordersystem.Warehouse;

import ordersystem.special.SpecialPackage;

import ordersystem.special.impl.SpecialPackageImpl;

import org.eclipse.emf.ecore.EAttribute;

import org.eclipse.emf.ecore.EDataType;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EReference;

import org.eclipse.emf.ecore.impl.EPackageImpl;

/**

	 * @generated
	 */
    public static OrderSystemPackage init() {
		if (isInited) return (OrderSystemPackage)EPackage.Registry.INSTANCE.getEPackage(OrderSystemPackage.eNS_URI);

		// Obtain or create and register package
		OrderSystemPackageImpl theOrderSystemPackage = (OrderSystemPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(eNS_URI) instanceof OrderSystemPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(eNS_URI) : new OrderSystemPackageImpl());

		isInited = true;

		// Obtain or create and register interdependencies
		SpecialPackageImpl theSpecialPackage = (SpecialPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(SpecialPackage.eNS_URI) instanceof SpecialPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(SpecialPackage.eNS_URI) : SpecialPackage.eINSTANCE);

		// Create package meta-data objects
		theOrderSystemPackage.createPackageContents();
		theSpecialPackage.createPackageContents();

		// Initialize created meta-data
		theOrderSystemPackage.initializePackageContents();
		theSpecialPackage.initializePackageContents();

		// Mark meta-data to indicate it can't be changed
		theOrderSystemPackage.freeze();

		return theOrderSystemPackage;
	}


		setNsURI(eNS_URI);

		// Obtain other dependent packages
		SpecialPackage theSpecialPackage = (SpecialPackage)EPackage.Registry.INSTANCE.getEPackage(SpecialPackage.eNS_URI);

		// Add subpackages
		getESubpackages().add(theSpecialPackage);

		// Create type parameters

		// Set bounds for type parameters

		// Add supertypes to classes

		// Initialize classes and features; add operations and parameters
		initEClass(orderEClass, Order.class, "Order", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEAttribute(getOrder_PlacedOn(), this.getJavaDate(), "placedOn", null, 0, 1, Order.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getOrder_FilledOn(), this.getJavaDate(), "filledOn", null, 0, 1, Order.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getOrder_Completed(), ecorePackage.getEBoolean(), "completed", null, 0, 1, Order.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getOrder_Id(), ecorePackage.getEString(), "id", null, 0, 1, Order.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getOrder_Owner(), this.getCustomer(), this.getCustomer_Order(), "owner", null, 0, 1, Order.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getOrder_Item(), this.getLineItem(), this.getLineItem_Owner(), "item", null, 0, -1, Order.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		initEClass(productEClass, Product.class, "Product", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEAttribute(getProduct_Name(), ecorePackage.getEString(), "name", null, 0, 1, Product.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getProduct_Sku(), ecorePackage.getEString(), "sku", null, 0, 1, Product.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getProduct_Price(), ecorePackage.getEDouble(), "price", null, 0, 1, Product.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getProduct_Owner(), this.getOrderSystem(), this.getOrderSystem_Product(), "owner", null, 0, 1, Product.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		initEClass(warehouseEClass, Warehouse.class, "Warehouse", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEAttribute(getWarehouse_Name(), ecorePackage.getEString(), "name", null, 0, 1, Warehouse.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getWarehouse_Owner(), this.getOrderSystem(), this.getOrderSystem_Warehouse(), "owner", null, 0, 1, Warehouse.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getWarehouse_Item(), this.getInventoryItem(), this.getInventoryItem_Warehouse(), "item", null, 0, -1, Warehouse.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getWarehouse_Location(), this.getAddress(), null, "location", null, 1, 1, Warehouse.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		initEClass(orderSystemEClass, OrderSystem.class, "OrderSystem", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEAttribute(getOrderSystem_Version(), ecorePackage.getEInt(), "version", null, 0, 1, OrderSystem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getOrderSystem_Customer(), this.getCustomer(), this.getCustomer_Owner(), "customer", null, 0, -1, OrderSystem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getOrderSystem_Product(), this.getProduct(), this.getProduct_Owner(), "product", null, 0, -1, OrderSystem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getOrderSystem_Warehouse(), this.getWarehouse(), this.getWarehouse_Owner(), "warehouse", null, 0, -1, OrderSystem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		initEClass(lineItemEClass, LineItem.class, "LineItem", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEAttribute(getLineItem_Quantity(), ecorePackage.getEInt(), "quantity", null, 0, 1, LineItem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getLineItem_Discount(), ecorePackage.getEDouble(), "discount", null, 0, 1, LineItem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getLineItem_Owner(), this.getOrder(), this.getOrder_Item(), "owner", null, 0, 1, LineItem.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getLineItem_Product(), this.getProduct(), null, "product", null, 1, 1, LineItem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		addEOperation(lineItemEClass, ecorePackage.getEDouble(), "getCost", 0, 1, IS_UNIQUE, IS_ORDERED); //$NON-NLS-1$

		initEClass(inventoryItemEClass, InventoryItem.class, "InventoryItem", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEAttribute(getInventoryItem_InStock(), ecorePackage.getEInt(), "inStock", null, 0, 1, InventoryItem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getInventoryItem_RestockThreshold(), ecorePackage.getEInt(), "restockThreshold", null, 0, 1, InventoryItem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getInventoryItem_NextStockDate(), this.getJavaDate(), "nextStockDate", null, 0, 1, InventoryItem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getInventoryItem_Warehouse(), this.getWarehouse(), this.getWarehouse_Item(), "Warehouse", null, 0, 1, InventoryItem.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getInventoryItem_Product(), this.getProduct(), null, "product", null, 1, 1, InventoryItem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		initEClass(customerEClass, Customer.class, "Customer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEAttribute(getCustomer_LastName(), ecorePackage.getEString(), "lastName", null, 0, 1, Customer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getCustomer_FirstName(), ecorePackage.getEString(), "firstName", null, 0, 1, Customer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getCustomer_Owner(), this.getOrderSystem(), this.getOrderSystem_Customer(), "owner", null, 0, 1, Customer.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getCustomer_Account(), this.getAccount(), this.getAccount_Owner(), "account", null, 0, -1, Customer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getCustomer_Order(), this.getOrder(), this.getOrder_Owner(), "order", null, 0, -1, Customer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		initEClass(addressEClass, Address.class, "Address", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEAttribute(getAddress_Number(), ecorePackage.getEString(), "number", null, 0, 1, Address.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getAddress_Street(), ecorePackage.getEString(), "street", null, 0, 1, Address.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getAddress_Apartment(), ecorePackage.getEString(), "apartment", null, 0, 1, Address.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getAddress_City(), ecorePackage.getEString(), "city", null, 0, 1, Address.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getAddress_Province(), ecorePackage.getEString(), "province", null, 0, 1, Address.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getAddress_PostalCode(), ecorePackage.getEString(), "postalCode", null, 0, 1, Address.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getAddress_Country(), ecorePackage.getEString(), "country", null, 0, 1, Address.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		initEClass(accountEClass, Account.class, "Account", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEAttribute(getAccount_PaymentMethod(), ecorePackage.getEString(), "paymentMethod", null, 0, 1, Account.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEAttribute(getAccount_AccountNumber(), ecorePackage.getEString(), "accountNumber", null, 0, 1, Account.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getAccount_Owner(), this.getCustomer(), this.getCustomer_Account(), "owner", null, 0, 1, Account.class, IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getAccount_BillingAddress(), this.getAddress(), null, "billingAddress", null, 1, 1, Account.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
		initEReference(getAccount_ShippingAddress(), this.getAddress(), null, "shippingAddress", null, 1, 1, Account.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		// Initialize data types
		initEDataType(javaDateEDataType, Date.class, "JavaDate", IS_SERIALIZABLE, !IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$

		// Create resource
		createResource(eNS_URI);




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import ordersystem.Account;
import ordersystem.Address;
import ordersystem.Customer;

import ordersystem.OrderSystemPackage;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;

import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;

import org.eclipse.emf.ecore.util.EcoreUtil;

/**

	 * @generated
	 * @ordered
	 */
    protected Address billingAddress;

	/**
	 * The cached value of the '{@link #getShippingAddress() <em>Shipping Address</em>}' containment reference.

	 * @generated
	 * @ordered
	 */
    protected Address shippingAddress;

	/**
	 * <!-- begin-user-doc -->

     * <!-- end-user-doc -->
	 * @generated
	 */
    @Override
				protected EClass eStaticClass() {
		return OrderSystemPackage.Literals.ACCOUNT;
	}

	/**

	 */
    public Customer getOwner() {
		if (eContainerFeatureID != OrderSystemPackage.ACCOUNT__OWNER) return null;
		return (Customer)eContainer();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain basicSetOwner(Customer newOwner, NotificationChain msgs) {
		msgs = eBasicSetContainer((InternalEObject)newOwner, OrderSystemPackage.ACCOUNT__OWNER, msgs);
		return msgs;
	}

	/**

	 * @generated
	 */
    public void setOwner(Customer newOwner) {
		if (newOwner != eInternalContainer() || (eContainerFeatureID != OrderSystemPackage.ACCOUNT__OWNER && newOwner != null)) {
			if (EcoreUtil.isAncestor(this, newOwner))
				throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$
			NotificationChain msgs = null;
			if (eInternalContainer() != null)
				msgs = eBasicRemoveFromContainer(msgs);
			if (newOwner != null)
				msgs = ((InternalEObject)newOwner).eInverseAdd(this, OrderSystemPackage.CUSTOMER__ACCOUNT, Customer.class, msgs);
			msgs = basicSetOwner(newOwner, msgs);
			if (msgs != null) msgs.dispatch();
		}
		else if (eNotificationRequired())


	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.ACCOUNT__OWNER:
				if (eInternalContainer() != null)
					msgs = eBasicRemoveFromContainer(msgs);
				return basicSetOwner((Customer)otherEnd, msgs);
				default:
					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseAdd(otherEnd, featureID, msgs);
			msgs = eBasicRemoveFromContainer(msgs);
		return eBasicSetContainer(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.ACCOUNT__OWNER:
				return basicSetOwner(null, msgs);
			case OrderSystemPackage.ACCOUNT__BILLING_ADDRESS:
				return basicSetBillingAddress(null, msgs);
			case OrderSystemPackage.ACCOUNT__SHIPPING_ADDRESS:
				return basicSetShippingAddress(null, msgs);
				default:
					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseRemove(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
		switch (eContainerFeatureID) {
			case OrderSystemPackage.ACCOUNT__OWNER:
				return eInternalContainer().eInverseRemove(this, OrderSystemPackage.CUSTOMER__ACCOUNT, Customer.class, msgs);
				default:
					return eDynamicBasicRemoveFromContainer(msgs);
			}
		}
		return super.eBasicRemoveFromContainerFeature(msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case OrderSystemPackage.ACCOUNT__PAYMENT_METHOD:
				return getPaymentMethod();
			case OrderSystemPackage.ACCOUNT__ACCOUNT_NUMBER:

			case OrderSystemPackage.ACCOUNT__SHIPPING_ADDRESS:
				return getShippingAddress();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
			case OrderSystemPackage.ACCOUNT__PAYMENT_METHOD:
				setPaymentMethod((String)newValue);
				return;

				setShippingAddress((Address)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.ACCOUNT__PAYMENT_METHOD:
				setPaymentMethod(PAYMENT_METHOD_EDEFAULT);
				return;

				setShippingAddress((Address)null);
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.ACCOUNT__PAYMENT_METHOD:
				return PAYMENT_METHOD_EDEFAULT == null ? paymentMethod != null : !PAYMENT_METHOD_EDEFAULT.equals(paymentMethod);
			case OrderSystemPackage.ACCOUNT__ACCOUNT_NUMBER:

			case OrderSystemPackage.ACCOUNT__SHIPPING_ADDRESS:
				return shippingAddress != null;
		}
		return super.eIsSet(featureID);
	}

	/**
     * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
     */




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;

import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;

import org.eclipse.emf.ecore.util.EcoreUtil;

/**

	 * @generated
	 * @ordered
	 */
    protected Product product;

	/**
	 * <!-- begin-user-doc -->

     * <!-- end-user-doc -->
	 * @generated
	 */
    @Override
				protected EClass eStaticClass() {
		return OrderSystemPackage.Literals.INVENTORY_ITEM;
	}

	/**

	 */
    public Warehouse getWarehouse() {
		if (eContainerFeatureID != OrderSystemPackage.INVENTORY_ITEM__WAREHOUSE) return null;
		return (Warehouse)eContainer();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain basicSetWarehouse(Warehouse newWarehouse, NotificationChain msgs) {
		msgs = eBasicSetContainer((InternalEObject)newWarehouse, OrderSystemPackage.INVENTORY_ITEM__WAREHOUSE, msgs);
		return msgs;
	}

	/**

	 * @generated
	 */
    public void setWarehouse(Warehouse newWarehouse) {
		if (newWarehouse != eInternalContainer() || (eContainerFeatureID != OrderSystemPackage.INVENTORY_ITEM__WAREHOUSE && newWarehouse != null)) {
			if (EcoreUtil.isAncestor(this, newWarehouse))
				throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$
			NotificationChain msgs = null;
			if (eInternalContainer() != null)
				msgs = eBasicRemoveFromContainer(msgs);
			if (newWarehouse != null)
				msgs = ((InternalEObject)newWarehouse).eInverseAdd(this, OrderSystemPackage.WAREHOUSE__ITEM, Warehouse.class, msgs);
			msgs = basicSetWarehouse(newWarehouse, msgs);
			if (msgs != null) msgs.dispatch();
		}
		else if (eNotificationRequired())

	 */
    public Product getProduct() {
		if (product != null && product.eIsProxy()) {
			InternalEObject oldProduct = (InternalEObject)product;
			product = (Product)eResolveProxy(oldProduct);
			if (product != oldProduct) {
				if (eNotificationRequired())
					eNotify(new ENotificationImpl(this, Notification.RESOLVE, OrderSystemPackage.INVENTORY_ITEM__PRODUCT, oldProduct, product));


	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.INVENTORY_ITEM__WAREHOUSE:
				if (eInternalContainer() != null)
					msgs = eBasicRemoveFromContainer(msgs);
				return basicSetWarehouse((Warehouse)otherEnd, msgs);
				default:
					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseAdd(otherEnd, featureID, msgs);
			msgs = eBasicRemoveFromContainer(msgs);
		return eBasicSetContainer(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.INVENTORY_ITEM__WAREHOUSE:
				return basicSetWarehouse(null, msgs);
				default:
					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseRemove(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
		switch (eContainerFeatureID) {
			case OrderSystemPackage.INVENTORY_ITEM__WAREHOUSE:
				return eInternalContainer().eInverseRemove(this, OrderSystemPackage.WAREHOUSE__ITEM, Warehouse.class, msgs);
				default:
					return eDynamicBasicRemoveFromContainer(msgs);
			}
		}
		return super.eBasicRemoveFromContainerFeature(msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case OrderSystemPackage.INVENTORY_ITEM__IN_STOCK:
				return new Integer(getInStock());
			case OrderSystemPackage.INVENTORY_ITEM__RESTOCK_THRESHOLD:

				if (resolve) return getProduct();
				return basicGetProduct();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
			case OrderSystemPackage.INVENTORY_ITEM__IN_STOCK:
				setInStock(((Integer)newValue).intValue());
				return;

				setProduct((Product)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.INVENTORY_ITEM__IN_STOCK:
				setInStock(IN_STOCK_EDEFAULT);
				return;

				setProduct((Product)null);
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.INVENTORY_ITEM__IN_STOCK:
				return inStock != IN_STOCK_EDEFAULT;
			case OrderSystemPackage.INVENTORY_ITEM__RESTOCK_THRESHOLD:

			case OrderSystemPackage.INVENTORY_ITEM__PRODUCT:
				return product != null;
		}
		return super.eIsSet(featureID);
	}

	/**
     * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
     */




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

package ordersystem.impl;

import ordersystem.Address;

import ordersystem.OrderSystemPackage;

import org.eclipse.emf.common.notify.Notification;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EStructuralFeature;

import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;


     * <!-- end-user-doc -->
	 * @generated
	 */
    @Override
				protected EClass eStaticClass() {
		return OrderSystemPackage.Literals.ADDRESS;
	}

	/**


	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case OrderSystemPackage.ADDRESS__NUMBER:
				return getNumber();
			case OrderSystemPackage.ADDRESS__STREET:

			case OrderSystemPackage.ADDRESS__COUNTRY:
				return getCountry();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
			case OrderSystemPackage.ADDRESS__NUMBER:
				setNumber((String)newValue);
				return;

				setCountry((String)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.ADDRESS__NUMBER:
				setNumber(NUMBER_EDEFAULT);
				return;

				setCountry(COUNTRY_EDEFAULT);
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.ADDRESS__NUMBER:
				return NUMBER_EDEFAULT == null ? number != null : !NUMBER_EDEFAULT.equals(number);
			case OrderSystemPackage.ADDRESS__STREET:

			case OrderSystemPackage.ADDRESS__COUNTRY:
				return COUNTRY_EDEFAULT == null ? country != null : !COUNTRY_EDEFAULT.equals(country);
		}
		return super.eIsSet(featureID);
	}

	/**
     * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
     */




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;

import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;

import org.eclipse.emf.ecore.util.EcoreUtil;

/**

	 * @generated
	 * @ordered
	 */
    protected Product product;

	/**
	 * <!-- begin-user-doc -->

     * <!-- end-user-doc -->
	 * @generated
	 */
    @Override
				protected EClass eStaticClass() {
		return OrderSystemPackage.Literals.LINE_ITEM;
	}

	/**

	 */
    public Order getOwner() {
		if (eContainerFeatureID != OrderSystemPackage.LINE_ITEM__OWNER) return null;
		return (Order)eContainer();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain basicSetOwner(Order newOwner, NotificationChain msgs) {
		msgs = eBasicSetContainer((InternalEObject)newOwner, OrderSystemPackage.LINE_ITEM__OWNER, msgs);
		return msgs;
	}

	/**

	 * @generated
	 */
    public void setOwner(Order newOwner) {
		if (newOwner != eInternalContainer() || (eContainerFeatureID != OrderSystemPackage.LINE_ITEM__OWNER && newOwner != null)) {
			if (EcoreUtil.isAncestor(this, newOwner))
				throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$
			NotificationChain msgs = null;
			if (eInternalContainer() != null)
				msgs = eBasicRemoveFromContainer(msgs);
			if (newOwner != null)
				msgs = ((InternalEObject)newOwner).eInverseAdd(this, OrderSystemPackage.ORDER__ITEM, Order.class, msgs);
			msgs = basicSetOwner(newOwner, msgs);
			if (msgs != null) msgs.dispatch();
		}
		else if (eNotificationRequired())

	 */
    public Product getProduct() {
		if (product != null && product.eIsProxy()) {
			InternalEObject oldProduct = (InternalEObject)product;
			product = (Product)eResolveProxy(oldProduct);
			if (product != oldProduct) {
				if (eNotificationRequired())
					eNotify(new ENotificationImpl(this, Notification.RESOLVE, OrderSystemPackage.LINE_ITEM__PRODUCT, oldProduct, product));


	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.LINE_ITEM__OWNER:
				if (eInternalContainer() != null)
					msgs = eBasicRemoveFromContainer(msgs);
				return basicSetOwner((Order)otherEnd, msgs);
				default:
					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseAdd(otherEnd, featureID, msgs);
			msgs = eBasicRemoveFromContainer(msgs);
		return eBasicSetContainer(otherEnd, featureID, msgs);
	}

				/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.LINE_ITEM__OWNER:
				return basicSetOwner(null, msgs);
				default:
					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseRemove(otherEnd, featureID, msgs);
	}

				/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
		switch (eContainerFeatureID) {
			case OrderSystemPackage.LINE_ITEM__OWNER:
				return eInternalContainer().eInverseRemove(this, OrderSystemPackage.ORDER__ITEM, Order.class, msgs);
				default:
					return eDynamicBasicRemoveFromContainer(msgs);
			}
		}
		return super.eBasicRemoveFromContainerFeature(msgs);
	}

				/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case OrderSystemPackage.LINE_ITEM__QUANTITY:
				return new Integer(getQuantity());
			case OrderSystemPackage.LINE_ITEM__DISCOUNT:

				if (resolve) return getProduct();
				return basicGetProduct();
		}
		return super.eGet(featureID, resolve, coreType);
	}

				/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
			case OrderSystemPackage.LINE_ITEM__QUANTITY:
				setQuantity(((Integer)newValue).intValue());
				return;

				setProduct((Product)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

				/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.LINE_ITEM__QUANTITY:
				setQuantity(QUANTITY_EDEFAULT);
				return;

				setProduct((Product)null);
				return;
		}
		super.eUnset(featureID);
	}

				/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.LINE_ITEM__QUANTITY:
				return quantity != QUANTITY_EDEFAULT;
			case OrderSystemPackage.LINE_ITEM__DISCOUNT:

			case OrderSystemPackage.LINE_ITEM__PRODUCT:
				return product != null;
		}
		return super.eIsSet(featureID);
	}

	/**
     * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
     */




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import ordersystem.Customer;
import ordersystem.Order;
import ordersystem.OrderSystem;

import ordersystem.OrderSystemPackage;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;

import org.eclipse.emf.common.util.EList;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;

import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;

import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.InternalEList;

	 * @generated
	 * @ordered
	 */
    protected EList<Account> account;

	/**
	 * The cached value of the '{@link #getOrder() <em>Order</em>}' containment reference list.

	 * @generated
	 * @ordered
	 */
    protected EList<Order> order;

	/**
	 * <!-- begin-user-doc -->

     * <!-- end-user-doc -->
	 * @generated
	 */
    @Override
				protected EClass eStaticClass() {
		return OrderSystemPackage.Literals.CUSTOMER;
	}

	/**

	 */
    public OrderSystem getOwner() {
		if (eContainerFeatureID != OrderSystemPackage.CUSTOMER__OWNER) return null;
		return (OrderSystem)eContainer();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain basicSetOwner(OrderSystem newOwner, NotificationChain msgs) {
		msgs = eBasicSetContainer((InternalEObject)newOwner, OrderSystemPackage.CUSTOMER__OWNER, msgs);
		return msgs;
	}

	/**

	 * @generated
	 */
    public void setOwner(OrderSystem newOwner) {
		if (newOwner != eInternalContainer() || (eContainerFeatureID != OrderSystemPackage.CUSTOMER__OWNER && newOwner != null)) {
			if (EcoreUtil.isAncestor(this, newOwner))
				throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$
			NotificationChain msgs = null;
			if (eInternalContainer() != null)
				msgs = eBasicRemoveFromContainer(msgs);
			if (newOwner != null)
				msgs = ((InternalEObject)newOwner).eInverseAdd(this, OrderSystemPackage.ORDER_SYSTEM__CUSTOMER, OrderSystem.class, msgs);
			msgs = basicSetOwner(newOwner, msgs);
			if (msgs != null) msgs.dispatch();
		}
		else if (eNotificationRequired())

     * <!-- end-user-doc -->
	 * @generated
	 */
    public EList<Account> getAccount() {
		if (account == null) {
			account = new EObjectContainmentWithInverseEList<Account>(Account.class, this, OrderSystemPackage.CUSTOMER__ACCOUNT, OrderSystemPackage.ACCOUNT__OWNER);
		}
		return account;
	}

     * <!-- end-user-doc -->
	 * @generated
	 */
    public EList<Order> getOrder() {
		if (order == null) {
			order = new EObjectContainmentWithInverseEList<Order>(Order.class, this, OrderSystemPackage.CUSTOMER__ORDER, OrderSystemPackage.ORDER__OWNER);
		}
		return order;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@SuppressWarnings("unchecked")
		@Override
	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.CUSTOMER__OWNER:
				if (eInternalContainer() != null)
					msgs = eBasicRemoveFromContainer(msgs);
				return basicSetOwner((OrderSystem)otherEnd, msgs);
			case OrderSystemPackage.CUSTOMER__ACCOUNT:
				return ((InternalEList<InternalEObject>)(InternalEList<?>)getAccount()).basicAdd(otherEnd, msgs);
			case OrderSystemPackage.CUSTOMER__ORDER:
				return ((InternalEList<InternalEObject>)(InternalEList<?>)getOrder()).basicAdd(otherEnd, msgs);
					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseAdd(otherEnd, featureID, msgs);
			msgs = eBasicRemoveFromContainer(msgs);
		return eBasicSetContainer(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.CUSTOMER__OWNER:
				return basicSetOwner(null, msgs);
			case OrderSystemPackage.CUSTOMER__ACCOUNT:
				return ((InternalEList<?>)getAccount()).basicRemove(otherEnd, msgs);
			case OrderSystemPackage.CUSTOMER__ORDER:
				return ((InternalEList<?>)getOrder()).basicRemove(otherEnd, msgs);
				default:
					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseRemove(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
		switch (eContainerFeatureID) {
			case OrderSystemPackage.CUSTOMER__OWNER:
				return eInternalContainer().eInverseRemove(this, OrderSystemPackage.ORDER_SYSTEM__CUSTOMER, OrderSystem.class, msgs);
				default:
					return eDynamicBasicRemoveFromContainer(msgs);
			}
		}
		return super.eBasicRemoveFromContainerFeature(msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case OrderSystemPackage.CUSTOMER__LAST_NAME:
				return getLastName();
			case OrderSystemPackage.CUSTOMER__FIRST_NAME:

			case OrderSystemPackage.CUSTOMER__ORDER:
				return getOrder();
		}
		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 OrderSystemPackage.CUSTOMER__LAST_NAME:
				setLastName((String)newValue);
				return;

				return;
			case OrderSystemPackage.CUSTOMER__ACCOUNT:
				getAccount().clear();
				getAccount().addAll((Collection<? extends Account>)newValue);
				return;
			case OrderSystemPackage.CUSTOMER__ORDER:
				getOrder().clear();
				getOrder().addAll((Collection<? extends Order>)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.CUSTOMER__LAST_NAME:
				setLastName(LAST_NAME_EDEFAULT);
				return;

				getOrder().clear();
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.CUSTOMER__LAST_NAME:
				return LAST_NAME_EDEFAULT == null ? lastName != null : !LAST_NAME_EDEFAULT.equals(lastName);
			case OrderSystemPackage.CUSTOMER__FIRST_NAME:

			case OrderSystemPackage.CUSTOMER__ORDER:
				return order != null && !order.isEmpty();
		}
		return super.eIsSet(featureID);
	}

	/**
     * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
     */




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;

import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;

import org.eclipse.emf.ecore.util.EcoreUtil;

/**

     * <!-- end-user-doc -->
	 * @generated
	 */
    @Override
				protected EClass eStaticClass() {
		return OrderSystemPackage.Literals.PRODUCT;
	}

	/**

	 */
    public OrderSystem getOwner() {
		if (eContainerFeatureID != OrderSystemPackage.PRODUCT__OWNER) return null;
		return (OrderSystem)eContainer();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain basicSetOwner(OrderSystem newOwner, NotificationChain msgs) {
		msgs = eBasicSetContainer((InternalEObject)newOwner, OrderSystemPackage.PRODUCT__OWNER, msgs);
		return msgs;
	}

	/**

	 * @generated
	 */
    public void setOwner(OrderSystem newOwner) {
		if (newOwner != eInternalContainer() || (eContainerFeatureID != OrderSystemPackage.PRODUCT__OWNER && newOwner != null)) {
			if (EcoreUtil.isAncestor(this, newOwner))
				throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$
			NotificationChain msgs = null;
			if (eInternalContainer() != null)
				msgs = eBasicRemoveFromContainer(msgs);
			if (newOwner != null)
				msgs = ((InternalEObject)newOwner).eInverseAdd(this, OrderSystemPackage.ORDER_SYSTEM__PRODUCT, OrderSystem.class, msgs);
			msgs = basicSetOwner(newOwner, msgs);
			if (msgs != null) msgs.dispatch();
		}
		else if (eNotificationRequired())


	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.PRODUCT__OWNER:
				if (eInternalContainer() != null)
					msgs = eBasicRemoveFromContainer(msgs);
				return basicSetOwner((OrderSystem)otherEnd, msgs);
				default:
					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseAdd(otherEnd, featureID, msgs);
			msgs = eBasicRemoveFromContainer(msgs);
		return eBasicSetContainer(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.PRODUCT__OWNER:
				return basicSetOwner(null, msgs);
				default:
					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseRemove(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
		switch (eContainerFeatureID) {
			case OrderSystemPackage.PRODUCT__OWNER:
				return eInternalContainer().eInverseRemove(this, OrderSystemPackage.ORDER_SYSTEM__PRODUCT, OrderSystem.class, msgs);
				default:
					return eDynamicBasicRemoveFromContainer(msgs);
			}
		}
		return super.eBasicRemoveFromContainerFeature(msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case OrderSystemPackage.PRODUCT__NAME:
				return getName();
			case OrderSystemPackage.PRODUCT__SKU:

			case OrderSystemPackage.PRODUCT__OWNER:
				return getOwner();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
			case OrderSystemPackage.PRODUCT__NAME:
				setName((String)newValue);
				return;

				setOwner((OrderSystem)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.PRODUCT__NAME:
				setName(NAME_EDEFAULT);
				return;

				setOwner((OrderSystem)null);
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.PRODUCT__NAME:
				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
			case OrderSystemPackage.PRODUCT__SKU:

			case OrderSystemPackage.PRODUCT__OWNER:
				return getOwner() != null;
		}
		return super.eIsSet(featureID);
	}

	/**
     * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
     */




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import ordersystem.Customer;
import ordersystem.LineItem;
import ordersystem.Order;

import ordersystem.OrderSystemPackage;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;

import org.eclipse.emf.common.util.EList;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;

import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.emf.ecore.impl.EObjectImpl;

import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.InternalEList;

	 * @generated
	 * @ordered
	 */
    protected EList<LineItem> item;

	/**
	 * <!-- begin-user-doc -->

     * <!-- end-user-doc -->
	 * @generated
	 */
    @Override
				protected EClass eStaticClass() {
		return OrderSystemPackage.Literals.ORDER;
	}

	/**

	 */
    public Customer getOwner() {
		if (eContainerFeatureID != OrderSystemPackage.ORDER__OWNER) return null;
		return (Customer)eContainer();
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain basicSetOwner(Customer newOwner, NotificationChain msgs) {
		msgs = eBasicSetContainer((InternalEObject)newOwner, OrderSystemPackage.ORDER__OWNER, msgs);
		return msgs;
	}

	/**

	 * @generated
	 */
    public void setOwner(Customer newOwner) {
		if (newOwner != eInternalContainer() || (eContainerFeatureID != OrderSystemPackage.ORDER__OWNER && newOwner != null)) {
			if (EcoreUtil.isAncestor(this, newOwner))
				throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$
			NotificationChain msgs = null;
			if (eInternalContainer() != null)
				msgs = eBasicRemoveFromContainer(msgs);
			if (newOwner != null)
				msgs = ((InternalEObject)newOwner).eInverseAdd(this, OrderSystemPackage.CUSTOMER__ORDER, Customer.class, msgs);
			msgs = basicSetOwner(newOwner, msgs);
			if (msgs != null) msgs.dispatch();
		}
		else if (eNotificationRequired())

     * <!-- end-user-doc -->
	 * @generated
	 */
    public EList<LineItem> getItem() {
		if (item == null) {
			item = new EObjectContainmentWithInverseEList<LineItem>(LineItem.class, this, OrderSystemPackage.ORDER__ITEM, OrderSystemPackage.LINE_ITEM__OWNER);
		}
		return item;
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@SuppressWarnings("unchecked")
		@Override
	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.ORDER__OWNER:
				if (eInternalContainer() != null)
					msgs = eBasicRemoveFromContainer(msgs);
				return basicSetOwner((Customer)otherEnd, msgs);
			case OrderSystemPackage.ORDER__ITEM:
				return ((InternalEList<InternalEObject>)(InternalEList<?>)getItem()).basicAdd(otherEnd, msgs);
					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseAdd(otherEnd, featureID, msgs);
			msgs = eBasicRemoveFromContainer(msgs);
		return eBasicSetContainer(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case OrderSystemPackage.ORDER__OWNER:
				return basicSetOwner(null, msgs);
			case OrderSystemPackage.ORDER__ITEM:
				return ((InternalEList<?>)getItem()).basicRemove(otherEnd, msgs);
				default:
					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
			}
		}
		return super.eInverseRemove(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
		switch (eContainerFeatureID) {
			case OrderSystemPackage.ORDER__OWNER:
				return eInternalContainer().eInverseRemove(this, OrderSystemPackage.CUSTOMER__ORDER, Customer.class, msgs);
				default:
					return eDynamicBasicRemoveFromContainer(msgs);
			}
		}
		return super.eBasicRemoveFromContainerFeature(msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case OrderSystemPackage.ORDER__PLACED_ON:
				return getPlacedOn();
			case OrderSystemPackage.ORDER__FILLED_ON:

			case OrderSystemPackage.ORDER__ITEM:
				return getItem();
		}
		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 OrderSystemPackage.ORDER__PLACED_ON:
				setPlacedOn((Date)newValue);
				return;

				return;
			case OrderSystemPackage.ORDER__ITEM:
				getItem().clear();
				getItem().addAll((Collection<? extends LineItem>)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.ORDER__PLACED_ON:
				setPlacedOn(PLACED_ON_EDEFAULT);
				return;

				getItem().clear();
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case OrderSystemPackage.ORDER__PLACED_ON:
				return PLACED_ON_EDEFAULT == null ? placedOn != null : !PLACED_ON_EDEFAULT.equals(placedOn);
			case OrderSystemPackage.ORDER__FILLED_ON:

			case OrderSystemPackage.ORDER__ITEM:
				return item != null && !item.isEmpty();
		}
		return super.eIsSet(featureID);
	}

	/**
     * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
     */

Lines 39-44 Link Here

(-)src/org/eclipse/emf/validation/tests/SetTargetConstraint.java (-1 / +2 lines)
39	public static boolean enabled = false;	39	public static boolean enabled = false;
40		40
41	// Documentation copied from the inherited specification	41	// Documentation copied from the inherited specification
		42	@Override
42	public IStatus validate(IValidationContext ctx) {	43	public IStatus validate(IValidationContext ctx) {
43	if (!enabled) {	44	if (!enabled) {
44	return ctx.createSuccessStatus();	45	return ctx.createSuccessStatus();
Lines 63-69 Link Here
63	null);	64	null);
64	}	65	}
65		66
66	Collection statuses = new java.util.ArrayList();	67	Collection<IStatus> statuses = new java.util.ArrayList<IStatus>();
67		68
68	statuses.add(ConstraintStatus.createStatus(	69	statuses.add(ConstraintStatus.createStatus(
69	ctx,	70	ctx,




 */
package org.eclipse.emf.validation.tests;

import java.util.Iterator;
import java.util.List;

import junit.framework.TestCase;

			}
		}};
	
	private final List<IStatus> logs = new java.util.ArrayList<IStatus>();
	private IStatus lastLog;
    
    /**

	 * 
	 * @return a list (possibly empty) of {@link IStatus}es
	 */
	public List<IStatus> getLogs() {
		return logs;
	}
	

	 * 
	 * @return the matching log entries
	 */
	public List<IStatus> getLogs(int statusCode) {
	    List<IStatus> result = new java.util.ArrayList<IStatus>();
	    
	    for (IStatus next : logs) {
	        IStatus next = (IStatus) iter.next();
	        
	        if (next.getCode() == statusCode) {
	            result.add(next);
	        }

Lines 44-50 Link Here

(-)src/org/eclipse/emf/validation/tests/AllTests.java (-1 / +2 lines)
44	static {	44	static {
45	// register the .ordersystem extension for loading the example XMI file	45	// register the .ordersystem extension for loading the example XMI file
46	Resource.Factory.Registry reg = Resource.Factory.Registry.INSTANCE;	46	Resource.Factory.Registry reg = Resource.Factory.Registry.INSTANCE;
47	Map m = reg.getExtensionToFactoryMap();	47	Map<String, Object> m = reg.getExtensionToFactoryMap();
48	m.put("ordersystem", new XMIResourceFactoryImpl()); //$NON-NLS-1$	48	m.put("ordersystem", new XMIResourceFactoryImpl()); //$NON-NLS-1$
49	}	49	}
50		50
Lines 80-85 Link Here
80	// this method is called if and only if unit tests are being executed	80	// this method is called if and only if unit tests are being executed
81	TestSuite suite = new TestSuite(	81	TestSuite suite = new TestSuite(
82	"Test for org.eclipse.emf.validation plug-in") { //$NON-NLS-1$	82	"Test for org.eclipse.emf.validation plug-in") { //$NON-NLS-1$
		83	@Override
83	public void run(TestResult result) {	84	public void run(TestResult result) {
84	// ensure that the tests know that they are running	85	// ensure that the tests know that they are running
85	executingUnitTests = true;	86	executingUnitTests = true;




package org.eclipse.emf.validation.tests;

import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;

import ordersystem.OrderSystem;
import ordersystem.OrderSystemFactory;
import ordersystem.special.SpecialFactory;

	 * Load the static example Order System model (<tt>test.ordersystem</tt>)
	 * on the first invocation of this method.
	 */
	@Override
	protected void setUp() throws Exception {
		if (orderSystem == null) {
			ResourceSet resourceSet = new org.eclipse.emf.ecore.resource.impl.ResourceSetImpl();


		IStatus[] status = getStatuses(batchValidator.validate(object));

		for (IStatus element : status) {
			IModelConstraint constraint = ((IConstraintStatus)element).getConstraint();
			
			if (constraint.getDescriptor().getId().equals(ID_PREFIX + "ordersystem.marker")) { //$NON-NLS-1$
				return;

		assertAllConstraintsPresent(
				"batch", //$NON-NLS-1$
				status,
				ID_PREFIX + "order.hasContents", //$NON-NLS-1$
				ID_PREFIX + "order.notFilledBeforePlacement"); //$NON-NLS-1$
						ID_PREFIX + "order.notFilledBeforePlacement", //$NON-NLS-1$
				}));
	}
	
	/**

		assertAllConstraintsPresent(
				"live", //$NON-NLS-1$
				status,
				ID_PREFIX + "order.hasName", //$NON-NLS-1$
				ID_PREFIX + "order.hasOwner"); //$NON-NLS-1$
						ID_PREFIX + "order.hasOwner", //$NON-NLS-1$
				}));
	}

	/**

		IStatus[] status = getStatuses(liveValidator.validate(
					Collections.nCopies(5, event)));

		Collection<IModelConstraint> evaluatedConstraints =
			new java.util.HashSet<IModelConstraint>();
		
		for (IStatus element : status) {
			IConstraintStatus next = (IConstraintStatus)element;
			
			evaluatedConstraints.add(next.getConstraint());
		}

		assertAllConstraintsNotPresent(
				"batch", //$NON-NLS-1$
				status,
				ID_PREFIX + "bad.constraint.xml"); //$NON-NLS-1$
						ID_PREFIX + "bad.constraint.xml", //$NON-NLS-1$
					}));
	}

	/**


		IStatus[] status = getStatuses(batchValidator.validate(object));
		
		String[] ids = new String[] {
				ID_PREFIX + "bad.constraint.disabled.java", //$NON-NLS-1$
				ID_PREFIX + "bad.constraint.disabled.ocl", //$NON-NLS-1$
				ID_PREFIX + "bad.constraint.disabled.bsh", //$NON-NLS-1$
				ID_PREFIX + "bad.constraint.disabled.runtime", //$NON-NLS-1$
			};
		
		for (String id : ids) {
			String id = (String)iter.next();
			
			IStatus nextStatus = getStatus(status, id);
			if (nextStatus != null) {
				assertTrue(nextStatus.matches(IStatus.INFO));


		IStatus[] status = getStatuses(batchValidator.validate(object));

		for (IStatus element : status) {
			IModelConstraint constraint = ((IConstraintStatus)element).getConstraint();
			assertFalse("Got constraints from ordersystem namespace prefix provider.", constraint.getDescriptor().getId().startsWith(ID_PREFIX + "ordersystem")); //$NON-NLS-1$ //$NON-NLS-2$
		}
		

		assertAllConstraintsPresent(
				"batch", //$NON-NLS-1$
				status,
				ID_PREFIX + "providertarget.batch1"); //$NON-NLS-1$
						ID_PREFIX + "providertarget.batch1", //$NON-NLS-1$
					}));

		assertAllConstraintsNotPresent(
				"batch", //$NON-NLS-1$
				status,
				ID_PREFIX + "providertarget.batch2"); //$NON-NLS-1$
						 ID_PREFIX + "providertarget.batch2", //$NON-NLS-1$
							}));
		
		// also check that the provider filter correctly excludes the
		//   Order type (the constraint otherwise would apply to all types,

		assertAllConstraintsNotPresent(
				"batch", //$NON-NLS-1$
				status,
				ID_PREFIX + "providertarget.batch1"); //$NON-NLS-1$
						ID_PREFIX + "providertarget.batch1", //$NON-NLS-1$
					}));
	}
	
	/**

		assertAllConstraintsPresent(
				"live", //$NON-NLS-1$
				status,
				ID_PREFIX + "providertarget.live2"); //$NON-NLS-1$
						ID_PREFIX + "providertarget.live2", //$NON-NLS-1$
					}));

		assertAllConstraintsNotPresent(
				"live", //$NON-NLS-1$
				status,
				ID_PREFIX + "providertarget.live1"); //$NON-NLS-1$
						ID_PREFIX + "providertarget.live1", //$NON-NLS-1$
					}));
		
		// also check that the provider filter correctly excludes the
		//   Order type (the constraint otherwise would apply to all types,

		assertAllConstraintsNotPresent(
				"live", //$NON-NLS-1$
				status,
				ID_PREFIX + "providertarget.live2"); //$NON-NLS-1$
						 ID_PREFIX + "providertarget.live2", //$NON-NLS-1$
					}));
		
		// finally, check that the provider filter correctly excludes an
		//   event type that is not "Set"

		assertAllConstraintsNotPresent(
				"live", //$NON-NLS-1$
				status,
				ID_PREFIX + "providertarget.live2"); //$NON-NLS-1$
						ID_PREFIX + "providertarget.live2", //$NON-NLS-1$
					}));
	}
	
	/**

		assertAllConstraintsPresent(
				"batch", //$NON-NLS-1$
				status,
				ID_PREFIX + "multipackage.test"); //$NON-NLS-1$
						ID_PREFIX + "multipackage.test", //$NON-NLS-1$
					}));
	}
	
	/**

		assertAllConstraintsPresent(
				"batch", //$NON-NLS-1$
				status,
				ID_PREFIX + "inheritance.test"); //$NON-NLS-1$
						ID_PREFIX + "inheritance.test", //$NON-NLS-1$
					}));
	}
	
	/**

		assertAllConstraintsPresent(
				"batch", //$NON-NLS-1$
				status,
				ID_PREFIX + "qualifiedName.test"); //$NON-NLS-1$
						ID_PREFIX + "qualifiedName.test", //$NON-NLS-1$
					}));
	}
}




/**
 * <copyright>
 *
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


package org.eclipse.emf.validation.tests;

import org.eclipse.emf.validation.model.IModelConstraint;
import org.eclipse.emf.validation.service.AbstractConstraintProvider;

import org.eclipse.emf.ecore.EClass;

public class CachedTestProvider extends AbstractConstraintProvider {
	private static CachedTestProvider instance;
	
	private final java.util.Map<EClass, Integer> hits = new java.util.HashMap<EClass, Integer>();
	
	/**
	 * Initializes me and remembers me for static access.

	}
	
	// redefines the inherited method
	@Override
	public Collection<IModelConstraint> getBatchConstraints(EObject eObject,
			Collection<IModelConstraint> constraints) {
		// I don't actually need to provide any constraints in order to
		//   register a hit.  The cache will remember that there are no
		//   constraints!

	 * @param clazz the EMF type
	 */
	private final void registerHit(EClass clazz) {
		hits.put(clazz, getHitCount(clazz) + 1);
	}
	
	/**

	 * @return the number of times that I have provided constraints
	 */
	public int getHitCount(EClass clazz) {
		Integer result = hits.get(clazz);
		
		return (result == null) ? 0 : result;
	}
}





package org.eclipse.emf.validation.tests;

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import junit.framework.TestCase;

import org.eclipse.emf.validation.model.IConstraintStatus;
import org.eclipse.emf.validation.model.IModelConstraint;
import org.eclipse.emf.validation.service.IBatchValidator;
import org.eclipse.emf.validation.service.ILiveValidator;
import org.eclipse.emf.validation.service.ITraversalStrategy;
import org.eclipse.emf.validation.service.IValidator;
import org.eclipse.emf.validation.service.ModelValidationService;

/**

	
	protected final IBatchValidator batchValidator;
	protected final IBatchValidator treeValidator;
	protected final ILiveValidator liveValidator;
	
	public TestBase(String name) {
		super(name);
		
		batchValidator = ModelValidationService.getInstance().newValidator(
			ModelValidationService.getInstance().newValidator(
				EvaluationMode.BATCH);
		batchValidator.setTraversalStrategy(new ITraversalStrategy.Flat());
		batchValidator.setReportSuccesses(true);
		
		treeValidator = ModelValidationService.getInstance().newValidator(
			ModelValidationService.getInstance().newValidator(
				EvaluationMode.BATCH);
		treeValidator.setTraversalStrategy(new ITraversalStrategy.Recursive());
		treeValidator.setReportSuccesses(true);

	protected void assertAllConstraintsNotPresent(
			String constraintType,
			IStatus[] statuses,
			String... ids) {
		
		Collection<String> found = new java.util.ArrayList<String>();
		
		for (IStatus element : statuses) {
			IModelConstraint next = ((IConstraintStatus)element).getConstraint();
			
			String id = next.getDescriptor().getId();
			
			if (Arrays.asList(ids).contains(id)) {
				found.add(id);
			}
		}

	 */
	protected void assertAllConstraintsNotPresent(
			String constraintType,
			Collection<IModelConstraint> constraints,
			String... ids) {
		
		Collection<String> found = new java.util.ArrayList<String>();
		
		for (IModelConstraint next : constraints) {
			IModelConstraint next = (IModelConstraint)iter.next();
			
			String id = next.getDescriptor().getId();
			
			if (Arrays.asList(ids).contains(id)) {
				found.add(id);
			}
		}

	protected void assertAllConstraintsPresent(
			String constraintType,
			IStatus[] statuses,
			String... ids) {
		
		Collection<String> notFound = new java.util.LinkedList<String>(Arrays.asList(ids));
		
		for (IStatus element : statuses) {
			IModelConstraint next = ((IConstraintStatus)element).getConstraint();
			
			notFound.remove(next.getDescriptor().getId());
		}

	 */
	protected void assertAllConstraintsPresent(
			String constraintType,
			Collection<IModelConstraint> constraints,
			String... ids) {
		
		Collection<String> notFound = new java.util.LinkedList<String>(Arrays.asList(ids));
		
		for (IModelConstraint next : constraints) {
			IModelConstraint next = (IModelConstraint)iter.next();
			
			notFound.remove(next.getDescriptor().getId());
		}
		

	protected void assertAllTargetsPresent(
			String constraintType,
			IStatus[] statuses,
			Collection<? extends EObject> targets) {
		
		Collection<EObject> notFound = new java.util.LinkedList<EObject>(targets);
		
		for (IStatus element : statuses) {
			IConstraintStatus next = (IConstraintStatus)element;
			
			notFound.remove(next.getTarget());
		}


	protected void assertConstraintAndTargetNotPresent(String constraintType,
			IStatus[] statuses, String constraintId, EObject target) {
		for (IStatus element : statuses) {
			IConstraintStatus status = (IConstraintStatus)element;
			IModelConstraint constraint  = ((IConstraintStatus)element).getConstraint();
			
			if (target.equals(status.getTarget()) && constraintId.equals(constraint.getDescriptor().getId())) {
				fail("Found unwanted " + constraintType + " constraint " + constraintId + " on " + target); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$


	protected void assertConstraintAndTargetPresent(String constraintType,
			IStatus[] statuses, String constraintId, EObject target) {
		for (IStatus element : statuses) {
			IConstraintStatus status = (IConstraintStatus)element;
			IModelConstraint constraint  = ((IConstraintStatus)element).getConstraint();
			
			if (target.equals(status.getTarget()) && constraintId.equals(constraint.getDescriptor().getId())) {
				return;

	protected IStatus getStatus(IStatus[] statuses, String id) {
		IStatus result = null;
		
		for (IStatus element : statuses) {
			IConstraintStatus next = (IConstraintStatus)element;
			
			if (next.getConstraint().getDescriptor().getId().equals(id)) {
				result = next;

	 * @since 1.1
	 */
	protected IStatus[] getStatuses(IStatus[] statuses, String id) {
		List<IStatus> result = new java.util.ArrayList<IStatus>();
		
		for (IStatus element : statuses) {
			IConstraintStatus next = (IConstraintStatus) element;
			
			if (next.getConstraint().getDescriptor().getId().equals(id)) {
				result.add(next);
			}
		}
		
		return result.toArray(new IStatus[result.size()]);
	}

	/**

			return new IStatus[0];
		}
		
		List<IStatus> result = new java.util.ArrayList<IStatus>();
		
		collectStatuses(status, result);
		
		return result.toArray(new IStatus[result.size()]);
	}
	
	private void collectStatuses(IStatus status, List<IStatus> statuses) {
		if (status.isMultiStatus()) {
			IStatus[] children = status.getChildren();
			
			for (IStatus element : children) {
				collectStatuses(element, statuses);
			}
		} else {
			statuses.add(status);

		System.out.println(o);
	
		final int childTabs = tabs + 1;
		for (EObject next : o.eContents()) {
			showRecursive(next, childTabs);
		}
	}





/**
 * <copyright>
 *
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

package org.eclipse.emf.validation.tests;

import java.util.Calendar;
import java.util.Iterator;
import java.util.Random;

import ordersystem.Account;

		result.setLocation(createAddress(city));

		int i = 1;
		for (Product next : os.getProduct()) {
			result.getItem().add(createInventoryItem(next, i++));
					.add(createInventoryItem((Product)iter.next(), i++));
		}

		os.getWarehouse().add(result);




/**
 * <copyright>
 *
 * Copyright (c) 2003, 2001 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EObject;

import org.eclipse.emf.validation.model.IModelConstraint;
import org.eclipse.emf.validation.service.AbstractConstraintProvider;
import org.eclipse.emf.validation.util.XmlConfig;


 * @author Christian W. Damus (cdamus)
 */
public class TestBadXmlConfigProvider extends AbstractConstraintProvider {
	private static final java.util.Map<String, TestBadXmlConfigProvider> instanceMap =
		new java.util.HashMap<String, TestBadXmlConfigProvider>();
	
	/**
	 * Always throws.
	 * 
	 * @throws RuntimeException always
	 */
	@Override
	public Collection<IModelConstraint> getLiveConstraints(
			Notification notification,
			Collection<IModelConstraint> constraints) {
		if (AllTests.isExecutingUnitTests()) {
			// only throw if we are actually executing the unit tests
			throw new RuntimeException("I am supposed to abend."); //$NON-NLS-1$

	 * 
	 * @throws RuntimeException always
	 */
	@Override
	public Collection<IModelConstraint> getBatchConstraints(
			EObject eObject,
			Collection<IModelConstraint> constraints) {
		if (AllTests.isExecutingUnitTests()) {
			// only throw if we are actually executing the unit tests
			throw new RuntimeException("I am supposed to abend."); //$NON-NLS-1$

	 * 
	 * @throws CoreException if no <tt>&lt;constraints&gt;</tt> element is found
	 */
	@Override
	public void setInitializationData(
			IConfigurationElement config,
			String propertyName,

		// put this instance into the map
		String[] uris = getNamespaceUris();
		
		for (String element : uris) {
			registerInstance(element, this);
		}
	}
	

	 * @return the corresponding instance
	 */
	public static TestBadXmlConfigProvider getInstance(String uriNsPrefix) {
		return instanceMap.get(uriNsPrefix);
	}
	
	private static synchronized void registerInstance(




/**
 * <copyright>
 *
 * Copyright (c) 2006, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	public static boolean enabled = false;
	
	// Documentation copied from the inherited specification
	@Override
	public IStatus validate(IValidationContext ctx) {
		if (!enabled) {
			return ctx.createSuccessStatus();
		}
		
		Collection<IStatus> statuses = new java.util.ArrayList<IStatus>();
		
		statuses.add(ctx.createFailureStatus(new Object[] {"Nothing to say."})); //$NON-NLS-1$
		
		// try a nested multi-status, just for fun
		Collection<IStatus> nested = new java.util.ArrayList<IStatus>();
		nested.add(ConstraintStatus.createStatus(
				ctx,
				ctx.getTarget().eContents(),





package org.eclipse.emf.validation.internal.xml.tests;

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import ordersystem.OrderSystemFactory;


import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.validation.internal.EMFModelValidationStatusCodes;

import org.eclipse.emf.validation.model.IModelConstraint;
import org.eclipse.emf.validation.service.IBatchValidator;
import org.eclipse.emf.validation.service.ITraversalStrategy;
import org.eclipse.emf.validation.service.IValidator;
import org.eclipse.emf.validation.service.ModelValidationService;
import org.eclipse.emf.validation.tests.TestBase;
import org.eclipse.emf.validation.tests.TestNotification;

		// validate an object for which the test plug-in does not define any
		//    constraints at all, to force the providers to be loaded (so
		//    that the static "fixture" instance will be initialized)
		IBatchValidator validator = ModelValidationService.getInstance().newValidator(
				EvaluationMode.BATCH);
		validator.setTraversalStrategy(new ITraversalStrategy.Flat());
			new ITraversalStrategy.Flat());
		validator.validate(OrderSystemFactory.eINSTANCE.createInventoryItem());
	}
	

		private boolean initializationDataWasSet = false;
		
		// gives the outer class access to the protected superclass method
		@Override
		protected List<IModelConstraint> getConstraints() {
			return super.getConstraints();
		}
		
		// extends the inherited method to record the fact of this being set
		@Override
		public void setInitializationData(IConfigurationElement config,
				String propertyName, Object data) throws CoreException {
			super.setInitializationData(config, propertyName, data);

	}
	
	public void test_getConstraints() {
		Collection<IModelConstraint> result = fixture.getConstraints();
		
		assertAllConstraintsPresent(
				"various", //$NON-NLS-1$
				result,
				ID_PREFIX + "product.batch1", //$NON-NLS-1$
				ID_PREFIX + "product.batch2", //$NON-NLS-1$
				ID_PREFIX + "product.live1", //$NON-NLS-1$
				ID_PREFIX + "product.live2"); //$NON-NLS-1$
						ID_PREFIX + "product.live2", //$NON-NLS-1$
					}));
		
		// check that all of the constraints are proxies
		for (IModelConstraint next : result) {
			IModelConstraint next = (IModelConstraint)iter.next();
			
			assertTrue(next.getClass().getName().endsWith("$ConstraintProxy")); //$NON-NLS-1$
		}
	}

	public void test_getBatchConstraints() {
		EObject object = OrderSystemFactory.eINSTANCE.createProduct();
		
		Collection<IModelConstraint> result = new java.util.HashSet<IModelConstraint>();
		
		fixture.getBatchConstraints(object, result);
		
		assertAllConstraintsPresent(
				"batch", //$NON-NLS-1$
				result,
				ID_PREFIX + "product.batch1", //$NON-NLS-1$
				ID_PREFIX + "product.batch2"); //$NON-NLS-1$
						ID_PREFIX + "product.batch2", //$NON-NLS-1$
					}));
	}

	public void test_getLiveConstraints() {
		EObject object = OrderSystemFactory.eINSTANCE.createProduct();
		
		Collection<IModelConstraint> result = new java.util.HashSet<IModelConstraint>();
		
		fixture.getLiveConstraints(
				new TestNotification(object, Notification.SET),

		assertAllConstraintsPresent(
				"live", //$NON-NLS-1$
				result,
				ID_PREFIX + "product.live1"); //$NON-NLS-1$
						ID_PREFIX + "product.live1", //$NON-NLS-1$
					}));
		
		assertAllConstraintsNotPresent(
				"live", //$NON-NLS-1$
				result,
				ID_PREFIX + "product.live2"); //$NON-NLS-1$
						ID_PREFIX + "product.live2", //$NON-NLS-1$
					}));
	}

	public void test_getLiveConstraintsForFeature() {
		EObject object = OrderSystemFactory.eINSTANCE.createProduct();
		
		Collection<IModelConstraint> result = new java.util.HashSet<IModelConstraint>();
		
		fixture.getLiveConstraints(
				new TestNotification(

		assertAllConstraintsPresent(
				"live", //$NON-NLS-1$
				result,
				ID_PREFIX + "product.live1", //$NON-NLS-1$
				ID_PREFIX + "product.live2"); //$NON-NLS-1$
						ID_PREFIX + "product.live2", //$NON-NLS-1$
					}));
	}
    
    public void test_duplicateConstraintsLogged_207988() {
        List<IStatus> statuses = TestPlugin.getLogCapture().getLogs(
            EMFModelValidationStatusCodes.PROVIDER_DUPLICATE_CONSTRAINT);
        assertFalse("Duplicate constraint not logged", statuses.isEmpty()); //$NON-NLS-1$
    }




/**
 * <copyright>
 *
 * Copyright (c) 2006, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 */
package org.eclipse.emf.validation.internal.service.tests;

import java.util.Arrays;
import java.util.Collections;

import ordersystem.Order;

		assertAllConstraintsPresent(
				"batch", //$NON-NLS-1$
				statuses,
				TEST_ID1);
		
		IStatus status = getStatus(statuses, TEST_ID1);
		

		assertAllConstraintsPresent(
				"batch", //$NON-NLS-1$
				statuses,
				TEST_ID2);
		
		IStatus status = getStatus(statuses, TEST_ID2);
		

		assertAllConstraintsPresent(
				"batch", //$NON-NLS-1$
				statuses,
				ID_PREFIX + "order.newParserAPI"); //$NON-NLS-1$
		
		IStatus status = getStatus(statuses, ID_PREFIX + "order.newParserAPI"); //$NON-NLS-1$
		

	public static final class JavaConstraint extends AbstractModelConstraint {
		static boolean enabled = false;

		@Override
		public IStatus validate(IValidationContext ctx) {
			assertTrue(ctx.getTarget() instanceof Order);
			

			return "Test constraint"; //$NON-NLS-1$
		}

		public EvaluationMode<?> getEvaluationMode() {
			return EvaluationMode.BATCH;
		}





import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;

import ordersystem.Address;

import org.eclipse.emf.validation.service.IBatchValidator;
import org.eclipse.emf.validation.service.IConstraintDescriptor;
import org.eclipse.emf.validation.service.IConstraintFilter;
import org.eclipse.emf.validation.service.ILiveValidator;
import org.eclipse.emf.validation.service.ITraversalStrategy;
import org.eclipse.emf.validation.service.IValidator;
import org.eclipse.emf.validation.service.ModelValidationService;
import org.eclipse.emf.validation.tests.CancelConstraint;
import org.eclipse.emf.validation.tests.MultiConstraint;

		assertAllConstraintsPresent(
				"batch", //$NON-NLS-1$
				status,
				ID_PREFIX + "order.hasContents", //$NON-NLS-1$
				ID_PREFIX + "order.notFilledBeforePlacement"); //$NON-NLS-1$
						ID_PREFIX + "order.notFilledBeforePlacement", //$NON-NLS-1$
				}));
	}

	public void test_validateBatchCollection() {
		Collection<EObject> objects = new java.util.ArrayList<EObject>();
		objects.add(OrderSystemFactory.eINSTANCE.createOrder());
		objects.add(OrderSystemFactory.eINSTANCE.createAddress());


		assertAllTargetsPresent(
				"batch", //$NON-NLS-1$
				status,
				Arrays.asList(new EObject[] {
						order,
						item,
				}));
	}

	public void test_validateSubtreeBatchCollection() {
		Collection<EObject> orders = new java.util.ArrayList<EObject>();
		
		Order order1 = OrderSystemFactory.eINSTANCE.createOrder();
		LineItem item1 = OrderSystemFactory.eINSTANCE.createLineItem();

		assertAllTargetsPresent(
				"batch", //$NON-NLS-1$
				status,
				Arrays.asList(new EObject[] {
						order1,
						item1,
						order2,

		assertAllConstraintsPresent(
				"live", //$NON-NLS-1$
				status,
				ID_PREFIX + "order.hasName", //$NON-NLS-1$
				ID_PREFIX + "order.hasOwner"); //$NON-NLS-1$
						ID_PREFIX + "order.hasOwner", //$NON-NLS-1$
				}));
	}

	public void test_validateLiveList() {
		List<Notification> events = new java.util.ArrayList<Notification>();
		Resource res = new XMIResourceImpl();
		
		Order order = OrderSystemFactory.eINSTANCE.createOrder();


		IStatus[] status = getStatuses(liveValidator.validate(events));

		List<EObject> targets = new java.util.ArrayList<EObject>(events.size());
		
		for (Notification next : events) {
			targets.add((EObject) next.getNotifier());
		}
		
		assertAllTargetsPresent(

		assertAllConstraintsPresent(
				"batch", //$NON-NLS-1$
				status,
				ID_PREFIX + "order.multiConstraint"); //$NON-NLS-1$
						ID_PREFIX + "order.multiConstraint", //$NON-NLS-1$
				}));
		
		status = getStatuses(status, ID_PREFIX + "order.multiConstraint"); //$NON-NLS-1$
		assertEquals(3, status.length);

		boolean foundFun = false;
		boolean foundSilly = false;
		
		final Set<Order> justOrder = Collections.singleton(order);
		final Set<EObject> orderAndItem = new java.util.HashSet<EObject>();
		orderAndItem.add(order);
		orderAndItem.addAll(order.getItem());
		

		assertAllConstraintsPresent(
				"batch", //$NON-NLS-1$
				status,
				ID_PREFIX + "order.setTargetConstraint"); //$NON-NLS-1$
						ID_PREFIX + "order.setTargetConstraint", //$NON-NLS-1$
				}));
		
		status = getStatuses(status, ID_PREFIX + "order.setTargetConstraint"); //$NON-NLS-1$
		assertEquals(3, status.length);

		boolean foundSilly = false;
		boolean foundSuccess = false;
		
		final Set<LineItem> justItem = Collections.singleton(item);
		final Set<EObject> orderAndItem = new java.util.HashSet<EObject>();
		orderAndItem.add(order);
		orderAndItem.addAll(order.getItem());
		

		Order order2 = OrderSystemFactory.eINSTANCE.createOrder();
		order2.setCompleted(false);
		
		EList<EObject> contents = new XMIResourceImpl().getContents();
		contents.add(order1);
		contents.add(order2);
		
		Collection<Notification> events = new ArrayList<Notification>();
		events.add(new TestNotification(order1, Notification.SET));
		events.add(new TestNotification(order2, Notification.SET));
		
		ILiveValidator validator = ModelValidationService.getInstance().newValidator(
		    EvaluationMode.LIVE);
        IConstraintFilter filter = new IConstraintFilter() {
            public boolean accept(IConstraintDescriptor constraint,
                    EObject object) {

		Order order2 = OrderSystemFactory.eINSTANCE.createOrder();
		order2.setCompleted(false);
		
		EList<EObject> contents = new XMIResourceImpl().getContents();
		contents.add(order1);
		contents.add(order2);
		
		Collection<EObject> targets = new ArrayList<EObject>();
		targets.add(order1);
		targets.add(order2);
		

        assertAllConstraintsPresent(
                "batch", //$NON-NLS-1$
                status,
                ID_PREFIX + "order.cancelConstraint"); //$NON-NLS-1$
                        ID_PREFIX + "order.cancelConstraint", //$NON-NLS-1$
                }));
        
        IStatus particular = getStatus(status, ID_PREFIX + "order.cancelConstraint"); //$NON-NLS-1$
        assertTrue("Wrong kind of constraint", particular instanceof IConstraintStatus); //$NON-NLS-1$

        EObject object = OrderSystemFactory.eINSTANCE.createOrder();
        res.getContents().add(object);    // must be in a resource

        Collection<Notification> events = new ArrayList<Notification>();
        events.add(new TestNotification(object, Notification.SET));
        IStatus[] status = getStatuses(liveValidator.validate(events));

        assertAllConstraintsPresent(
                "live", //$NON-NLS-1$
                status,
                ID_PREFIX + "order.cancelConstraint"); //$NON-NLS-1$
                        ID_PREFIX + "order.cancelConstraint", //$NON-NLS-1$
                }));
        
        IStatus particular = getStatus(status, ID_PREFIX + "order.cancelConstraint"); //$NON-NLS-1$
        assertTrue("Wrong kind of constraint", particular instanceof IConstraintStatus); //$NON-NLS-1$

        epackage.getEClassifiers().add(myOrderClass);
        
        class MyOrderImpl extends OrderImpl {
            @Override
            public EClass eClass() {
                return myOrderClass;
            }

        assertAllConstraintsPresent(
            "batch", //$NON-NLS-1$
            status,
            ID_PREFIX + "order.hasContents", //$NON-NLS-1$
            ID_PREFIX + "order.notFilledBeforePlacement"); //$NON-NLS-1$
                    ID_PREFIX + "order.notFilledBeforePlacement", //$NON-NLS-1$
            }));
    }
    
    /**

     * not repeatedly validate an element.
     */
    public void test_recursiveTraversalStrategy_207990() {
        Collection<EObject> objects = new java.util.ArrayList<EObject>();
        
        Order order1 = OrderSystemFactory.eINSTANCE.createOrder();
        LineItem item1 = OrderSystemFactory.eINSTANCE.createLineItem();

        objects.add(item1);  // child element precedes ancestor
        objects.add(order1);

        Set<EObject> visited = new java.util.HashSet<EObject>();
        ITraversalStrategy traversal = batchValidator.getDefaultTraversalStrategy();
        
        traversal.startTraversal(objects, new NullProgressMonitor());

    // Framework methods
    //
    
    @Override
    protected void tearDown()
        throws Exception {
        

            return delegate.next();
        }

        public void startTraversal(Collection<? extends EObject> traversalRoots,
                IProgressMonitor monitor) {
            synchronized (TestTraversalStrategy.class) {
                used = true;




		assertNull("Remove category for non-associated category incorrectly sent an event", listener.getLastEvent()); //$NON-NLS-1$
	}
	
	@Override
	protected void setUp() throws Exception {
		super.setUp();
		

		listener.setEnabled(true);
	}
	
	@Override
	protected void tearDown() throws Exception {
		listener.setEnabled(false);
		listener.setLastEvent(null);

			return 0;
		}
		
		public EvaluationMode<?> getEvaluationMode() {
			return EvaluationMode.NULL;
		}

		public boolean targetsTypeOf(EObject eObject) {

Lines 99-105 Link Here

(-)src/org/eclipse/emf/validation/internal/service/tests/ConstraintRegistryTest.java (-4 / +8 lines)
99	}	99	}
100		100
101	public void testGetAllDescriptors() {	101	public void testGetAllDescriptors() {
102	Collection allFound =	102	Collection<IConstraintDescriptor> allFound =
103	ConstraintRegistry.getInstance().getAllDescriptors();	103	ConstraintRegistry.getInstance().getAllDescriptors();
104		104
105	assertNotNull(allFound);	105	assertNotNull(allFound);
Lines 185-198 Link Here
185	public void test_bulkRegister() {	185	public void test_bulkRegister() {
186	ConstraintListener.getInstance().reset();	186	ConstraintListener.getInstance().reset();
187		187
188	Collection constraints = new java.util.ArrayList();	188	Collection<IModelConstraint> constraints = new java.util.ArrayList<IModelConstraint>();
189	constraints.add(new FixtureConstraint());	189	constraints.add(new FixtureConstraint());
190	constraints.add(new FixtureConstraint());	190	constraints.add(new FixtureConstraint());
191	constraints.add(new FixtureConstraint());	191	constraints.add(new FixtureConstraint());
192	constraints.add(new FixtureConstraint());	192	constraints.add(new FixtureConstraint());
193		193
194	class ProviderAccess extends AbstractConstraintProvider {	194	class ProviderAccess extends AbstractConstraintProvider {
195	public void registerConstraints(Collection constraints)	195	@Override
		196	public void registerConstraints(
		197	Collection<? extends IModelConstraint> constraints)
196	throws ConstraintExistsException {	198	throws ConstraintExistsException {
197	super.registerConstraints(constraints);	199	super.registerConstraints(constraints);
198	}}	200	}}
Lines 211-216 Link Here
211	// Test fixtures	213	// Test fixtures
212	//	214	//
213		215
		216	@Override
214	protected void setUp() throws Exception {	217	protected void setUp() throws Exception {
215	super.setUp();	218	super.setUp();
216		219
Lines 221-226 Link Here
221	listener.setEnabled(true);	224	listener.setEnabled(true);
222	}	225	}
223		226
		227	@Override
224	protected void tearDown() throws Exception {	228	protected void tearDown() throws Exception {
225	ConstraintListener listener = ConstraintListener.getInstance();	229	ConstraintListener listener = ConstraintListener.getInstance();
226		230
Lines 272-278 Link Here
272	return 0;	276	return 0;
273	}	277	}
274		278
275	public EvaluationMode getEvaluationMode() {	279	public EvaluationMode<?> getEvaluationMode() {
276	return null;	280	return null;
277	}	281	}
278		282

Lines 46-52 Link Here

(-)src/org/eclipse/emf/validation/internal/service/tests/EventTypeServiceTest.java (-1 / +2 lines)
46	}	46	}
47		47
48	public void test_getNotificationGenerators_177647() {	48	public void test_getNotificationGenerators_177647() {
49	Collection generators = EventTypeService.getInstance().getNotificationGenerators();	49	Collection<INotificationGenerator> generators =
		50	EventTypeService.getInstance().getNotificationGenerators();
50		51
51	assertEquals(generators.size(), 1);	52	assertEquals(generators.size(), 1);
52	}	53	}




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * </ul>
 * <!-- end-user-doc -->
 * @see ordersystem.special.SpecialFactory
 * @model kind="package"
 * @generated
 */
public interface SpecialPackage extends EPackage{

	int PREFERRED_CUSTOMER__SINCE = OrderSystemPackage.CUSTOMER_FEATURE_COUNT + 0;

	/**
	 * The number of structural features of the '<em>Preferred Customer</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated

	int LIMITED_EDITION_PRODUCT__AVAILABLE_UNTIL = OrderSystemPackage.PRODUCT_FEATURE_COUNT + 0;

	/**
	 * The number of structural features of the '<em>Limited Edition Product</em>' class.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated

	 */
	SpecialFactory getSpecialFactory();

	/**
	 * <!-- 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
	 */
	interface Literals {
		/**
		 * The meta object literal for the '{@link ordersystem.special.impl.PreferredCustomerImpl <em>Preferred Customer</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see ordersystem.special.impl.PreferredCustomerImpl
		 * @see ordersystem.special.impl.SpecialPackageImpl#getPreferredCustomer()
		 * @generated
		 */
		EClass PREFERRED_CUSTOMER = eINSTANCE.getPreferredCustomer();

		/**
		 * The meta object literal for the '<em><b>Since</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute PREFERRED_CUSTOMER__SINCE = eINSTANCE.getPreferredCustomer_Since();

		/**
		 * The meta object literal for the '{@link ordersystem.special.impl.LimitedEditionProductImpl <em>Limited Edition Product</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see ordersystem.special.impl.LimitedEditionProductImpl
		 * @see ordersystem.special.impl.SpecialPackageImpl#getLimitedEditionProduct()
		 * @generated
		 */
		EClass LIMITED_EDITION_PRODUCT = eINSTANCE.getLimitedEditionProduct();

		/**
		 * The meta object literal for the '<em><b>Available Until</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute LIMITED_EDITION_PRODUCT__AVAILABLE_UNTIL = eINSTANCE.getLimitedEditionProduct_AvailableUntil();

	}

} //SpecialPackage

Lines 1-7 Link Here

(-)src/ordersystem/special/PreferredCustomer.java (-2 / +2 lines)
1	/**	1	/**
2	* <copyright>	2	* <copyright>
3	*	3	*
4	* Copyright (c) 2005 IBM Corporation and others.	4	* Copyright (c) 2005, 2007 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials	5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	7	* which accompanies this distribution, and is available at
Lines 34-40 Link Here
34	* </p>	34	* </p>
35	*	35	*
36	* @see ordersystem.special.SpecialPackage#getPreferredCustomer()	36	* @see ordersystem.special.SpecialPackage#getPreferredCustomer()
37	*	37	* @model
38	* @generated	38	* @generated
39	*/	39	*/
40	public interface PreferredCustomer extends Customer {	40	public interface PreferredCustomer extends Customer {

Lines 1-7 Link Here

(-)src/ordersystem/special/LimitedEditionProduct.java (-2 / +2 lines)
1	/**	1	/**
2	* <copyright>	2	* <copyright>
3	*	3	*
4	* Copyright (c) 2005 IBM Corporation and others.	4	* Copyright (c) 2005, 2007 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials	5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	7	* which accompanies this distribution, and is available at
Lines 34-40 Link Here
34	* </p>	34	* </p>
35	*	35	*
36	* @see ordersystem.special.SpecialPackage#getLimitedEditionProduct()	36	* @see ordersystem.special.SpecialPackage#getLimitedEditionProduct()
37	*	37	* @model
38	* @generated	38	* @generated
39	*/	39	*/
40	public interface LimitedEditionProduct extends Product {	40	public interface LimitedEditionProduct extends Product {

Lines 1-7 Link Here

(-)src/ordersystem/special/SpecialFactory.java (-2 / +2 lines)
1	/**	1	/**
2	* <copyright>	2	* <copyright>
3	*	3	*
4	* Copyright (c) 2005 IBM Corporation and others.	4	* Copyright (c) 2005, 2007 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials	5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	7	* which accompanies this distribution, and is available at
Lines 34-40 Link Here
34	* <!-- end-user-doc -->	34	* <!-- end-user-doc -->
35	* @generated	35	* @generated
36	*/	36	*/
37	SpecialFactory eINSTANCE = new ordersystem.special.impl.SpecialFactoryImpl();	37	SpecialFactory eINSTANCE = ordersystem.special.impl.SpecialFactoryImpl.init();
38		38
39	/**	39	/**
40	* Returns a new object of class '<em>Preferred Customer</em>'.	40	* Returns a new object of class '<em>Preferred Customer</em>'.





import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import ordersystem.LineItem;
import ordersystem.Order;
import ordersystem.special.LimitedEditionProduct;

	 * Create special notifications for those orders who contain limited
	 * edition products
	 */ 
	public Collection<Notification> generateNotifications(Collection<? extends Notification> notifications) {
		Collection<Notification> newNotifications = new ArrayList<Notification>();
		
		for (Notification notification : notifications) {
			Notification notification = (Notification)iter.next();
			if (notification.getNotifier() instanceof Order) {
				Order order = (Order) notification.getNotifier();
				LimitedEditionProduct lep = null;
				
				for (LineItem obj : order.getItem()) {
					LineItem obj = (LineItem)itemIter.next();
					if (obj.getProduct() instanceof LimitedEditionProduct)  {
						lep = (LimitedEditionProduct)obj.getProduct();
					}




import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.util.Iterator;
import java.util.List;

import junit.framework.TestCase;

	}

	public void test_getAllInstances() {
		List<ConstraintSeverity> instances = ConstraintSeverity.getAllInstances();
		
		assertTrue(instances.contains(ConstraintSeverity.NULL));
		assertTrue(instances.contains(ConstraintSeverity.INFO));

		try {
			output = new ObjectOutputStream(stream);
			
			for (ConstraintSeverity next : ConstraintSeverity.getAllInstances()) {
				output.writeObject(next);
			}
			
			output.flush();

			input =	new ObjectInputStream(
					new ByteArrayInputStream(stream.toByteArray()));
			
			for (ConstraintSeverity next : ConstraintSeverity.getAllInstances()) {
				assertSame(next, input.readObject());
			}
		} catch (Exception e) {
			fail(e.getLocalizedMessage());




import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.util.Iterator;
import java.util.List;

import junit.framework.TestCase;

	}

	public void test_getPredefinedInstances_177647() {
		List<EMFEventType> instances = EMFEventType.getPredefinedInstances();
		
		assertTrue(instances.contains(EMFEventType.NULL));
		assertTrue(instances.contains(EMFEventType.ADD));

	}
	
	public void test_getAllInstances() {
		List<EMFEventType> instances = EMFEventType.getAllInstances();
		
		assertTrue(instances.contains(EMFEventType.NULL));
		assertTrue(instances.contains(EMFEventType.ADD));

		try {
			output = new ObjectOutputStream(stream);
			
			for (EMFEventType next : EMFEventType.getAllInstances()) {
				output.writeObject(next);
			}
			
			output.flush();

			input =	new ObjectInputStream(
					new ByteArrayInputStream(stream.toByteArray()));
			
			for (EMFEventType next : EMFEventType.getAllInstances()) {
				assertSame(next, input.readObject());
			}
		} catch (Exception e) {
			fail(e.getLocalizedMessage());




/**
 * <copyright>
 *
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.emf.validation.model.CategoryManager;

import java.util.Collection;
import java.util.Iterator;

import junit.framework.TestCase;

/**

	 * Tests the consistency of the top-level categories query.
	 */
	public void test_getTopLevelCategories() {
		Collection<Category> topLevel = mgr.getTopLevelCategories();
		
		for (Category next : topLevel) {
			assertNull(next.getParent());
		}
	}
	

	 * Tests the consistency of the mandatory categories query.
	 */
	public void test_getMandatoryCategories() {
		Collection<Category> topLevel = mgr.getMandatoryCategories();
		
		for (Category next : topLevel) {
			assertTrue(next.isMandatory());
		}
	}
	

	public void test_dumpCategories() {
		Trace.trace(">>> Testing dumpCategories"); //$NON-NLS-1$
		
		for (Category next : mgr.getTopLevelCategories()) {
			dumpCategory(next);
		}
	}
	

	private void dumpCategory(Category category) {
		Trace.trace(category.toString());
		
		for (Object next : category.getConstraints()) {
			Trace.trace("    " + next); //$NON-NLS-1$
		}
		
		for (Category child : category.getChildren()) {
			dumpCategory(child);
		}
	}
}




import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.util.Iterator;
import java.util.List;

import junit.framework.TestCase;

	}

	public void test_getAllInstances() {
		List<EvaluationMode<?>> instances = EvaluationMode.getAllInstances();
		
		assertTrue(instances.contains(EvaluationMode.BATCH));
		assertTrue(instances.contains(EvaluationMode.LIVE));

		try {
			output = new ObjectOutputStream(stream);
			
			for (EvaluationMode<?> next : EvaluationMode.getAllInstances()) {
				output.writeObject(next);
			}
			
			output.flush();

			input =	new ObjectInputStream(
					new ByteArrayInputStream(stream.toByteArray()));
			
			for (EvaluationMode<?> next : EvaluationMode.getAllInstances()) {
				assertSame(next, input.readObject());
			}
		} catch (Exception e) {
			fail(e.getLocalizedMessage());




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

				{"class", TestSelector.class.getName()}})); //$NON-NLS-1$
	}
	
	@Override
	protected void setUp() {
		// this setup effectively tests the configureBindings() method,
		//    including the ability of the system to ignore

	
	public void test_getBindings_eobject() {
		IModelConstraint constraint = new TestConstraint();
		Collection<IModelConstraint> constraints = Collections.singleton(constraint);
		
		assertTrue(mgr.getBindings(product, constraints).contains(constraint));
		assertFalse(mgr.getBindings(order, constraints).contains(constraint));

	
	public void test_getBindings_eobject_none() {
		IModelConstraint constraint = new TestConstraint();
		Collection<IModelConstraint> constraints = Collections.singleton(constraint);
		
		assertTrue(mgr.getBindings(order, constraints).isEmpty());
	}
	
	public void test_getBindings_context() {
		IModelConstraint constraint = new TestConstraint();
		Collection<IModelConstraint> constraints = Collections.singleton(constraint);
		
		assertTrue(mgr.getBindings(ctx, constraints).contains(constraint));
		assertFalse(mgr.getBindings(ctx2, constraints).contains(constraint));

	
	public void test_getBindings_contexts() {
		IModelConstraint constraint = new TestConstraint();
		Collection<IModelConstraint> constraints = Collections.singleton(constraint);
		
		assertTrue(mgr.getBindings(
			Arrays.asList(ctx, ctx2), constraints).contains(constraint));
		assertFalse(mgr.getBindings(
			Arrays.asList(ctx2, ctx2), constraints).contains(constraint));
	}
	
	public void test_defaultBindings_context() {

					return descr;
				}};
			
			Collection<IModelConstraint> constraints = Collections.singleton(constraint);
			
			IClientContext junitCtx = mgr.getClientContext(JUNIT_CLIENT);
			

					return descr;
				}};
			
			Collection<IClientContext> contexts = new java.util.ArrayList<IClientContext>();
			contexts.add(ctx);
			contexts.add(ctx2);
			
			Collection<IModelConstraint> constraints = Collections.singleton(constraint);
			
			IClientContext junitCtx = mgr.getClientContext(JUNIT_CLIENT);
			




/**
 * <copyright>
 *
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	private static final EObject TEST_TARGET =
		OrderSystemFactory.eINSTANCE.createWarehouse();
	
	private static final Set<EObject> TEST_RESULTLOCUS =
		Collections.singleton(TEST_TARGET);
	
	private static FixtureConstraint fixtureConstraint;

	private static ConstraintStatus failedFixture;
	
	private static class FixtureConstraint implements IModelConstraint {
		private final String name;
		private final String id;
		private final String pluginId;
		private final ConstraintSeverity severity;
		private final int code;

		FixtureConstraint(String name, String id, String pluginId,
				ConstraintSeverity severity, int code) {

					return null;
				}

				public EvaluationMode<?> getEvaluationMode() {
					return null;
				}


					// do nothing
				}

				public Set<Category> getCategories() {
					return Collections.emptySet();
				}

				public void addCategory(Category category) {




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * </p>
 *
 * @see ordersystem.OrderSystemPackage#getProduct()
 * @model
 * @generated
 */
public interface Product extends EObject{

	 * @return the value of the '<em>Name</em>' attribute.
	 * @see #setName(String)
	 * @see ordersystem.OrderSystemPackage#getProduct_Name()
	 * @model
	 * @generated
	 */
    String getName();

	 * @return the value of the '<em>Sku</em>' attribute.
	 * @see #setSku(String)
	 * @see ordersystem.OrderSystemPackage#getProduct_Sku()
	 * @model
	 * @generated
	 */
    String getSku();

	 * @return the value of the '<em>Price</em>' attribute.
	 * @see #setPrice(double)
	 * @see ordersystem.OrderSystemPackage#getProduct_Price()
	 * @model
	 * @generated
	 */
    double getPrice();




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * </p>
 *
 * @see ordersystem.OrderSystemPackage#getCustomer()
 * @model
 * @generated
 */
public interface Customer extends EObject{

	 * @return the value of the '<em>Last Name</em>' attribute.
	 * @see #setLastName(String)
	 * @see ordersystem.OrderSystemPackage#getCustomer_LastName()
	 * @model
	 * @generated
	 */
    String getLastName();

	 * @return the value of the '<em>First Name</em>' attribute.
	 * @see #setFirstName(String)
	 * @see ordersystem.OrderSystemPackage#getCustomer_FirstName()
	 * @model
	 * @generated
	 */
    String getFirstName();

	 * @return the value of the '<em>Account</em>' containment reference list.
	 * @see ordersystem.OrderSystemPackage#getCustomer_Account()
	 * @see ordersystem.Account#getOwner
	 * @model opposite="owner" containment="true"
	 * @generated
	 */
    EList<Account> getAccount();

	/**
	 * Returns the value of the '<em><b>Order</b></em>' containment reference list.

	 * @return the value of the '<em>Order</em>' containment reference list.
	 * @see ordersystem.OrderSystemPackage#getCustomer_Order()
	 * @see ordersystem.Order#getOwner
	 * @model opposite="owner" containment="true"
	 * @generated
	 */
    EList<Order> getOrder();

} // Customer




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * </p>
 *
 * @see ordersystem.OrderSystemPackage#getOrder()
 * @model
 * @generated
 */
public interface Order extends EObject{

	 * @return the value of the '<em>Completed</em>' attribute.
	 * @see #setCompleted(boolean)
	 * @see ordersystem.OrderSystemPackage#getOrder_Completed()
	 * @model
	 * @generated
	 */
    boolean isCompleted();

	 * @return the value of the '<em>Id</em>' attribute.
	 * @see #setId(String)
	 * @see ordersystem.OrderSystemPackage#getOrder_Id()
	 * @model
	 * @generated
	 */
    String getId();

	 * @return the value of the '<em>Item</em>' containment reference list.
	 * @see ordersystem.OrderSystemPackage#getOrder_Item()
	 * @see ordersystem.LineItem#getOwner
	 * @model opposite="owner" containment="true"
	 * @generated
	 */
    EList<LineItem> getItem();

} // Order




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * </p>
 *
 * @see ordersystem.OrderSystemPackage#getInventoryItem()
 * @model
 * @generated
 */
public interface InventoryItem extends EObject{

	 * @return the value of the '<em>In Stock</em>' attribute.
	 * @see #setInStock(int)
	 * @see ordersystem.OrderSystemPackage#getInventoryItem_InStock()
	 * @model
	 * @generated
	 */
    int getInStock();

	 * @return the value of the '<em>Restock Threshold</em>' attribute.
	 * @see #setRestockThreshold(int)
	 * @see ordersystem.OrderSystemPackage#getInventoryItem_RestockThreshold()
	 * @model
	 * @generated
	 */
    int getRestockThreshold();




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

     * <!-- end-user-doc -->
	 * @generated
	 */
    OrderSystemFactory eINSTANCE = ordersystem.impl.OrderSystemFactoryImpl.init();

	/**
	 * Returns a new object of class '<em>Order System</em>'.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @return a new object of class '<em>Order System</em>'.
	 * @generated
	 */
    OrderSystem createOrderSystem();




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * </ul>
 * <!-- end-user-doc -->
 * @see ordersystem.OrderSystemFactory
 * @model kind="package"
 * @generated
 */
public interface OrderSystemPackage extends EPackage{

    OrderSystemPackage eINSTANCE = ordersystem.impl.OrderSystemPackageImpl.init();

	/**
	 * The meta object id for the '{@link ordersystem.impl.OrderSystemImpl <em>Order System</em>}' class.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @see ordersystem.impl.OrderSystemImpl

    int ORDER__ITEM = 5;

	/**
	 * The number of structural features of the '<em>Order</em>' class.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @generated

    int PRODUCT__OWNER = 3;

	/**
	 * The number of structural features of the '<em>Product</em>' class.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @generated

    int WAREHOUSE__LOCATION = 3;

	/**
	 * The number of structural features of the '<em>Warehouse</em>' class.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @generated

    int ORDER_SYSTEM__WAREHOUSE = 3;

	/**
	 * The number of structural features of the '<em>Order System</em>' class.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @generated

    int LINE_ITEM__PRODUCT = 3;

	/**
	 * The number of structural features of the '<em>Line Item</em>' class.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @generated

    int INVENTORY_ITEM__PRODUCT = 4;

	/**
	 * The number of structural features of the '<em>Inventory Item</em>' class.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @generated

    int CUSTOMER__ORDER = 4;

	/**
	 * The number of structural features of the '<em>Customer</em>' class.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @generated

    int ADDRESS__COUNTRY = 6;

	/**
	 * The number of structural features of the '<em>Address</em>' class.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @generated

    int ACCOUNT__SHIPPING_ADDRESS = 4;

	/**
	 * The number of structural features of the '<em>Account</em>' class.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @generated



	/**
	 * Returns the meta object for class '{@link ordersystem.OrderSystem <em>Order System</em>}'.
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @return the meta object for class '<em>Order System</em>'.
	 * @see ordersystem.OrderSystem
	 * @generated
	 */

	 */
    OrderSystemFactory getOrderSystemFactory();

	/**
	 * <!-- 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
	 */
	interface Literals {
		/**
		 * The meta object literal for the '{@link ordersystem.impl.OrderImpl <em>Order</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see ordersystem.impl.OrderImpl
		 * @see ordersystem.impl.OrderSystemPackageImpl#getOrder()
		 * @generated
		 */
		EClass ORDER = eINSTANCE.getOrder();

		/**
		 * The meta object literal for the '<em><b>Placed On</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ORDER__PLACED_ON = eINSTANCE.getOrder_PlacedOn();

		/**
		 * The meta object literal for the '<em><b>Filled On</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ORDER__FILLED_ON = eINSTANCE.getOrder_FilledOn();

		/**
		 * The meta object literal for the '<em><b>Completed</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ORDER__COMPLETED = eINSTANCE.getOrder_Completed();

		/**
		 * The meta object literal for the '<em><b>Id</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ORDER__ID = eINSTANCE.getOrder_Id();

		/**
		 * The meta object literal for the '<em><b>Owner</b></em>' container reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference ORDER__OWNER = eINSTANCE.getOrder_Owner();

		/**
		 * The meta object literal for the '<em><b>Item</b></em>' containment reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference ORDER__ITEM = eINSTANCE.getOrder_Item();

		/**
		 * The meta object literal for the '{@link ordersystem.impl.ProductImpl <em>Product</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see ordersystem.impl.ProductImpl
		 * @see ordersystem.impl.OrderSystemPackageImpl#getProduct()
		 * @generated
		 */
		EClass PRODUCT = eINSTANCE.getProduct();

		/**
		 * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute PRODUCT__NAME = eINSTANCE.getProduct_Name();

		/**
		 * The meta object literal for the '<em><b>Sku</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute PRODUCT__SKU = eINSTANCE.getProduct_Sku();

		/**
		 * The meta object literal for the '<em><b>Price</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute PRODUCT__PRICE = eINSTANCE.getProduct_Price();

		/**
		 * The meta object literal for the '<em><b>Owner</b></em>' container reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference PRODUCT__OWNER = eINSTANCE.getProduct_Owner();

		/**
		 * The meta object literal for the '{@link ordersystem.impl.WarehouseImpl <em>Warehouse</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see ordersystem.impl.WarehouseImpl
		 * @see ordersystem.impl.OrderSystemPackageImpl#getWarehouse()
		 * @generated
		 */
		EClass WAREHOUSE = eINSTANCE.getWarehouse();

		/**
		 * The meta object literal for the '<em><b>Name</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute WAREHOUSE__NAME = eINSTANCE.getWarehouse_Name();

		/**
		 * The meta object literal for the '<em><b>Owner</b></em>' container reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference WAREHOUSE__OWNER = eINSTANCE.getWarehouse_Owner();

		/**
		 * The meta object literal for the '<em><b>Item</b></em>' containment reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference WAREHOUSE__ITEM = eINSTANCE.getWarehouse_Item();

		/**
		 * The meta object literal for the '<em><b>Location</b></em>' containment reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference WAREHOUSE__LOCATION = eINSTANCE.getWarehouse_Location();

		/**
		 * The meta object literal for the '{@link ordersystem.impl.OrderSystemImpl <em>Order System</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see ordersystem.impl.OrderSystemImpl
		 * @see ordersystem.impl.OrderSystemPackageImpl#getOrderSystem()
		 * @generated
		 */
		EClass ORDER_SYSTEM = eINSTANCE.getOrderSystem();

		/**
		 * The meta object literal for the '<em><b>Version</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ORDER_SYSTEM__VERSION = eINSTANCE.getOrderSystem_Version();

		/**
		 * The meta object literal for the '<em><b>Customer</b></em>' containment reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference ORDER_SYSTEM__CUSTOMER = eINSTANCE.getOrderSystem_Customer();

		/**
		 * The meta object literal for the '<em><b>Product</b></em>' containment reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference ORDER_SYSTEM__PRODUCT = eINSTANCE.getOrderSystem_Product();

		/**
		 * The meta object literal for the '<em><b>Warehouse</b></em>' containment reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference ORDER_SYSTEM__WAREHOUSE = eINSTANCE.getOrderSystem_Warehouse();

		/**
		 * The meta object literal for the '{@link ordersystem.impl.LineItemImpl <em>Line Item</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see ordersystem.impl.LineItemImpl
		 * @see ordersystem.impl.OrderSystemPackageImpl#getLineItem()
		 * @generated
		 */
		EClass LINE_ITEM = eINSTANCE.getLineItem();

		/**
		 * The meta object literal for the '<em><b>Quantity</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute LINE_ITEM__QUANTITY = eINSTANCE.getLineItem_Quantity();

		/**
		 * The meta object literal for the '<em><b>Discount</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute LINE_ITEM__DISCOUNT = eINSTANCE.getLineItem_Discount();

		/**
		 * The meta object literal for the '<em><b>Owner</b></em>' container reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference LINE_ITEM__OWNER = eINSTANCE.getLineItem_Owner();

		/**
		 * The meta object literal for the '<em><b>Product</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference LINE_ITEM__PRODUCT = eINSTANCE.getLineItem_Product();

		/**
		 * The meta object literal for the '{@link ordersystem.impl.InventoryItemImpl <em>Inventory Item</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see ordersystem.impl.InventoryItemImpl
		 * @see ordersystem.impl.OrderSystemPackageImpl#getInventoryItem()
		 * @generated
		 */
		EClass INVENTORY_ITEM = eINSTANCE.getInventoryItem();

		/**
		 * The meta object literal for the '<em><b>In Stock</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute INVENTORY_ITEM__IN_STOCK = eINSTANCE.getInventoryItem_InStock();

		/**
		 * The meta object literal for the '<em><b>Restock Threshold</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute INVENTORY_ITEM__RESTOCK_THRESHOLD = eINSTANCE.getInventoryItem_RestockThreshold();

		/**
		 * The meta object literal for the '<em><b>Next Stock Date</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute INVENTORY_ITEM__NEXT_STOCK_DATE = eINSTANCE.getInventoryItem_NextStockDate();

		/**
		 * The meta object literal for the '<em><b>Warehouse</b></em>' container reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference INVENTORY_ITEM__WAREHOUSE = eINSTANCE.getInventoryItem_Warehouse();

		/**
		 * The meta object literal for the '<em><b>Product</b></em>' reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference INVENTORY_ITEM__PRODUCT = eINSTANCE.getInventoryItem_Product();

		/**
		 * The meta object literal for the '{@link ordersystem.impl.CustomerImpl <em>Customer</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see ordersystem.impl.CustomerImpl
		 * @see ordersystem.impl.OrderSystemPackageImpl#getCustomer()
		 * @generated
		 */
		EClass CUSTOMER = eINSTANCE.getCustomer();

		/**
		 * The meta object literal for the '<em><b>Last Name</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CUSTOMER__LAST_NAME = eINSTANCE.getCustomer_LastName();

		/**
		 * The meta object literal for the '<em><b>First Name</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute CUSTOMER__FIRST_NAME = eINSTANCE.getCustomer_FirstName();

		/**
		 * The meta object literal for the '<em><b>Owner</b></em>' container reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CUSTOMER__OWNER = eINSTANCE.getCustomer_Owner();

		/**
		 * The meta object literal for the '<em><b>Account</b></em>' containment reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CUSTOMER__ACCOUNT = eINSTANCE.getCustomer_Account();

		/**
		 * The meta object literal for the '<em><b>Order</b></em>' containment reference list feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference CUSTOMER__ORDER = eINSTANCE.getCustomer_Order();

		/**
		 * The meta object literal for the '{@link ordersystem.impl.AddressImpl <em>Address</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see ordersystem.impl.AddressImpl
		 * @see ordersystem.impl.OrderSystemPackageImpl#getAddress()
		 * @generated
		 */
		EClass ADDRESS = eINSTANCE.getAddress();

		/**
		 * The meta object literal for the '<em><b>Number</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ADDRESS__NUMBER = eINSTANCE.getAddress_Number();

		/**
		 * The meta object literal for the '<em><b>Street</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ADDRESS__STREET = eINSTANCE.getAddress_Street();

		/**
		 * The meta object literal for the '<em><b>Apartment</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ADDRESS__APARTMENT = eINSTANCE.getAddress_Apartment();

		/**
		 * The meta object literal for the '<em><b>City</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ADDRESS__CITY = eINSTANCE.getAddress_City();

		/**
		 * The meta object literal for the '<em><b>Province</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ADDRESS__PROVINCE = eINSTANCE.getAddress_Province();

		/**
		 * The meta object literal for the '<em><b>Postal Code</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ADDRESS__POSTAL_CODE = eINSTANCE.getAddress_PostalCode();

		/**
		 * The meta object literal for the '<em><b>Country</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ADDRESS__COUNTRY = eINSTANCE.getAddress_Country();

		/**
		 * The meta object literal for the '{@link ordersystem.impl.AccountImpl <em>Account</em>}' class.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see ordersystem.impl.AccountImpl
		 * @see ordersystem.impl.OrderSystemPackageImpl#getAccount()
		 * @generated
		 */
		EClass ACCOUNT = eINSTANCE.getAccount();

		/**
		 * The meta object literal for the '<em><b>Payment Method</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ACCOUNT__PAYMENT_METHOD = eINSTANCE.getAccount_PaymentMethod();

		/**
		 * The meta object literal for the '<em><b>Account Number</b></em>' attribute feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EAttribute ACCOUNT__ACCOUNT_NUMBER = eINSTANCE.getAccount_AccountNumber();

		/**
		 * The meta object literal for the '<em><b>Owner</b></em>' container reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference ACCOUNT__OWNER = eINSTANCE.getAccount_Owner();

		/**
		 * The meta object literal for the '<em><b>Billing Address</b></em>' containment reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference ACCOUNT__BILLING_ADDRESS = eINSTANCE.getAccount_BillingAddress();

		/**
		 * The meta object literal for the '<em><b>Shipping Address</b></em>' containment reference feature.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @generated
		 */
		EReference ACCOUNT__SHIPPING_ADDRESS = eINSTANCE.getAccount_ShippingAddress();

		/**
		 * The meta object literal for the '<em>Java Date</em>' data type.
		 * <!-- begin-user-doc -->
		 * <!-- end-user-doc -->
		 * @see java.util.Date
		 * @see ordersystem.impl.OrderSystemPackageImpl#getJavaDate()
		 * @generated
		 */
		EDataType JAVA_DATE = eINSTANCE.getJavaDate();

	}

} //OrderSystemPackage




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * </p>
 *
 * @see ordersystem.OrderSystemPackage#getAddress()
 * @model
 * @generated
 */
public interface Address extends EObject{

	 * @return the value of the '<em>Number</em>' attribute.
	 * @see #setNumber(String)
	 * @see ordersystem.OrderSystemPackage#getAddress_Number()
	 * @model
	 * @generated
	 */
    String getNumber();

	 * @return the value of the '<em>Street</em>' attribute.
	 * @see #setStreet(String)
	 * @see ordersystem.OrderSystemPackage#getAddress_Street()
	 * @model
	 * @generated
	 */
    String getStreet();

	 * @return the value of the '<em>Apartment</em>' attribute.
	 * @see #setApartment(String)
	 * @see ordersystem.OrderSystemPackage#getAddress_Apartment()
	 * @model
	 * @generated
	 */
    String getApartment();

	 * @return the value of the '<em>City</em>' attribute.
	 * @see #setCity(String)
	 * @see ordersystem.OrderSystemPackage#getAddress_City()
	 * @model
	 * @generated
	 */
    String getCity();

	 * @return the value of the '<em>Province</em>' attribute.
	 * @see #setProvince(String)
	 * @see ordersystem.OrderSystemPackage#getAddress_Province()
	 * @model
	 * @generated
	 */
    String getProvince();

	 * @return the value of the '<em>Postal Code</em>' attribute.
	 * @see #setPostalCode(String)
	 * @see ordersystem.OrderSystemPackage#getAddress_PostalCode()
	 * @model
	 * @generated
	 */
    String getPostalCode();

	 * @return the value of the '<em>Country</em>' attribute.
	 * @see #setCountry(String)
	 * @see ordersystem.OrderSystemPackage#getAddress_Country()
	 * @model
	 * @generated
	 */
    String getCountry();




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * </p>
 *
 * @see ordersystem.OrderSystemPackage#getWarehouse()
 * @model
 * @generated
 */
public interface Warehouse extends EObject{

	 * @return the value of the '<em>Name</em>' attribute.
	 * @see #setName(String)
	 * @see ordersystem.OrderSystemPackage#getWarehouse_Name()
	 * @model
	 * @generated
	 */
    String getName();

	 * @return the value of the '<em>Item</em>' containment reference list.
	 * @see ordersystem.OrderSystemPackage#getWarehouse_Item()
	 * @see ordersystem.InventoryItem#getWarehouse
	 * @model opposite="Warehouse" containment="true"
	 * @generated
	 */
    EList<InventoryItem> getItem();

	/**
	 * Returns the value of the '<em><b>Location</b></em>' containment reference.




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * </p>
 *
 * @see ordersystem.OrderSystemPackage#getLineItem()
 * @model
 * @generated
 */
public interface LineItem extends EObject{

	 * @return the value of the '<em>Quantity</em>' attribute.
	 * @see #setQuantity(int)
	 * @see ordersystem.OrderSystemPackage#getLineItem_Quantity()
	 * @model
	 * @generated
	 */
    int getQuantity();

	 * @return the value of the '<em>Discount</em>' attribute.
	 * @see #setDiscount(double)
	 * @see ordersystem.OrderSystemPackage#getLineItem_Discount()
	 * @model
	 * @generated
	 */
    double getDiscount();

	/**
	 * <!-- begin-user-doc -->
     * <!-- end-user-doc -->
	 * @model kind="operation"
	 * @generated
	 */
    double getCost();




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * </p>
 *
 * @see ordersystem.OrderSystemPackage#getAccount()
 * @model
 * @generated
 */
public interface Account extends EObject{

	 * @return the value of the '<em>Payment Method</em>' attribute.
	 * @see #setPaymentMethod(String)
	 * @see ordersystem.OrderSystemPackage#getAccount_PaymentMethod()
	 * @model
	 * @generated
	 */
    String getPaymentMethod();

	 * @return the value of the '<em>Account Number</em>' attribute.
	 * @see #setAccountNumber(String)
	 * @see ordersystem.OrderSystemPackage#getAccount_AccountNumber()
	 * @model
	 * @generated
	 */
    String getAccountNumber();




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * </p>
 *
 * @see ordersystem.OrderSystemPackage#getOrderSystem()
 * @model
 * @generated
 */
public interface OrderSystem extends EObject{

	 * @return the value of the '<em>Version</em>' attribute.
	 * @see #setVersion(int)
	 * @see ordersystem.OrderSystemPackage#getOrderSystem_Version()
	 * @model
	 * @generated
	 */
    int getVersion();

	 * @return the value of the '<em>Customer</em>' containment reference list.
	 * @see ordersystem.OrderSystemPackage#getOrderSystem_Customer()
	 * @see ordersystem.Customer#getOwner
	 * @model opposite="owner" containment="true"
	 * @generated
	 */
    EList<Customer> getCustomer();

	/**
	 * Returns the value of the '<em><b>Product</b></em>' containment reference list.

	 * @return the value of the '<em>Product</em>' containment reference list.
	 * @see ordersystem.OrderSystemPackage#getOrderSystem_Product()
	 * @see ordersystem.Product#getOwner
	 * @model opposite="owner" containment="true"
	 * @generated
	 */
    EList<Product> getProduct();

	/**
	 * Returns the value of the '<em><b>Warehouse</b></em>' containment reference list.

	 * @return the value of the '<em>Warehouse</em>' containment reference list.
	 * @see ordersystem.OrderSystemPackage#getOrderSystem_Warehouse()
	 * @see ordersystem.Warehouse#getOwner
	 * @model opposite="owner" containment="true"
	 * @generated
	 */
    EList<Warehouse> getWarehouse();

} // OrderSystem

Lines 1-7 Link Here

(-)src/ordersystem/special/impl/SpecialFactoryImpl.java (-4 / +29 lines)
1	/**	1	/**
2	* <copyright>	2	* <copyright>
3	*	3	*
4	* Copyright (c) 2005 IBM Corporation and others.	4	* Copyright (c) 2005, 2007 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials	5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	7	* which accompanies this distribution, and is available at
Lines 17-28 Link Here
17		17
18	package ordersystem.special.impl;	18	package ordersystem.special.impl;
19		19
20	import ordersystem.special.*;	20	import ordersystem.special.LimitedEditionProduct;
		21	import ordersystem.special.PreferredCustomer;
		22	import ordersystem.special.SpecialFactory;
		23	import ordersystem.special.SpecialPackage;
21		24
22	import org.eclipse.emf.ecore.EClass;	25	import org.eclipse.emf.ecore.EClass;
23	import org.eclipse.emf.ecore.EObject;	26	import org.eclipse.emf.ecore.EObject;
24		27	import org.eclipse.emf.ecore.EPackage;
25	import org.eclipse.emf.ecore.impl.EFactoryImpl;	28	import org.eclipse.emf.ecore.impl.EFactoryImpl;
		29	import org.eclipse.emf.ecore.plugin.EcorePlugin;
26		30
27	/**	31	/**
28	* <!-- begin-user-doc -->	32	* <!-- begin-user-doc -->
Lines 32-38 Link Here
32	*/	36	*/
33	public class SpecialFactoryImpl extends EFactoryImpl implements SpecialFactory {	37	public class SpecialFactoryImpl extends EFactoryImpl implements SpecialFactory {
34	/**	38	/**
35	* Creates and instance of the factory.	39	* Creates the default factory implementation.
		40	* <!-- begin-user-doc -->
		41	* <!-- end-user-doc -->
		42	* @generated
		43	*/
		44	public static SpecialFactory init() {
		45	try {
		46	SpecialFactory theSpecialFactory = (SpecialFactory)EPackage.Registry.INSTANCE.getEFactory("http:///ordersystem/special.ecore"); //$NON-NLS-1$
		47	if (theSpecialFactory != null) {
		48	return theSpecialFactory;
		49	}
		50	}
		51	catch (Exception exception) {
		52	EcorePlugin.INSTANCE.log(exception);
		53	}
		54	return new SpecialFactoryImpl();
		55	}
		56
		57	/**
		58	* Creates an instance of the factory.
36	* <!-- begin-user-doc -->	59	* <!-- begin-user-doc -->
37	* <!-- end-user-doc -->	60	* <!-- end-user-doc -->
38	* @generated	61	* @generated
Lines 46-51 Link Here
46	* <!-- end-user-doc -->	69	* <!-- end-user-doc -->
47	* @generated	70	* @generated
48	*/	71	*/
		72	@Override
49	public EObject create(EClass eClass) {	73	public EObject create(EClass eClass) {
50	switch (eClass.getClassifierID()) {	74	switch (eClass.getClassifierID()) {
51	case SpecialPackage.PREFERRED_CUSTOMER: return createPreferredCustomer();	75	case SpecialPackage.PREFERRED_CUSTOMER: return createPreferredCustomer();
Lines 90-95 Link Here
90	* @deprecated	114	* @deprecated
91	* @generated	115	* @generated
92	*/	116	*/
		117	@Deprecated
93	public static SpecialPackage getPackage() {	118	public static SpecialPackage getPackage() {
94	return SpecialPackage.eINSTANCE;	119	return SpecialPackage.eINSTANCE;
95	}	120	}




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


package ordersystem.special.impl;

import java.util.Collection;
import java.util.Date;

import ordersystem.OrderSystem;
import ordersystem.OrderSystemPackage;

import ordersystem.impl.CustomerImpl;

import ordersystem.special.PreferredCustomer;
import ordersystem.special.SpecialPackage;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;

import org.eclipse.emf.ecore.impl.ENotificationImpl;

import org.eclipse.emf.ecore.util.InternalEList;

/**
 * <!-- begin-user-doc -->
 * An implementation of the model object '<em><b>Preferred Customer</b></em>'.

	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	protected EClass eStaticClass() {
		return SpecialPackage.Literals.PREFERRED_CUSTOMER;
	}

	/**

	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
				case SpecialPackage.PREFERRED_CUSTOMER__OWNER:
					if (eContainer != null)
						msgs = eBasicRemoveFromContainer(msgs);
					return eBasicSetContainer(otherEnd, SpecialPackage.PREFERRED_CUSTOMER__OWNER, msgs);
				case SpecialPackage.PREFERRED_CUSTOMER__ACCOUNT:
					return ((InternalEList)getAccount()).basicAdd(otherEnd, msgs);
				case SpecialPackage.PREFERRED_CUSTOMER__ORDER:
					return ((InternalEList)getOrder()).basicAdd(otherEnd, msgs);
				default:
					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
			}
		}
		if (eContainer != null)
			msgs = eBasicRemoveFromContainer(msgs);
		return eBasicSetContainer(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
		if (featureID >= 0) {
			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
				case SpecialPackage.PREFERRED_CUSTOMER__OWNER:
					return eBasicSetContainer(null, SpecialPackage.PREFERRED_CUSTOMER__OWNER, msgs);
				case SpecialPackage.PREFERRED_CUSTOMER__ACCOUNT:
					return ((InternalEList)getAccount()).basicRemove(otherEnd, msgs);
				case SpecialPackage.PREFERRED_CUSTOMER__ORDER:
					return ((InternalEList)getOrder()).basicRemove(otherEnd, msgs);
				default:
					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
			}
		}
		return eBasicSetContainer(null, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
		if (eContainerFeatureID >= 0) {
			switch (eContainerFeatureID) {
				case SpecialPackage.PREFERRED_CUSTOMER__OWNER:
					return (eContainer).eInverseRemove(this, OrderSystemPackage.ORDER_SYSTEM__CUSTOMER, OrderSystem.class, msgs);
				default:
					return eDynamicBasicRemoveFromContainer(msgs);
			}
		}
		return (eContainer).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case SpecialPackage.PREFERRED_CUSTOMER__LAST_NAME:
				return getLastName();
			case SpecialPackage.PREFERRED_CUSTOMER__FIRST_NAME:
				return getFirstName();
			case SpecialPackage.PREFERRED_CUSTOMER__OWNER:
				return getOwner();
			case SpecialPackage.PREFERRED_CUSTOMER__ACCOUNT:
				return getAccount();
			case SpecialPackage.PREFERRED_CUSTOMER__ORDER:
				return getOrder();
			case SpecialPackage.PREFERRED_CUSTOMER__SINCE:
				return getSince();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**

	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
				setLastName((String)newValue);
				return;
			case SpecialPackage.PREFERRED_CUSTOMER__FIRST_NAME:
				setFirstName((String)newValue);
				return;
			case SpecialPackage.PREFERRED_CUSTOMER__OWNER:
				setOwner((OrderSystem)newValue);
				return;
			case SpecialPackage.PREFERRED_CUSTOMER__ACCOUNT:
				getAccount().clear();
				getAccount().addAll((Collection)newValue);
				return;
			case SpecialPackage.PREFERRED_CUSTOMER__ORDER:
				getOrder().clear();
				getOrder().addAll((Collection)newValue);
				return;
			case SpecialPackage.PREFERRED_CUSTOMER__SINCE:
				setSince((Date)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**

	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
				setLastName(LAST_NAME_EDEFAULT);
				return;
			case SpecialPackage.PREFERRED_CUSTOMER__FIRST_NAME:
				setFirstName(FIRST_NAME_EDEFAULT);
				return;
			case SpecialPackage.PREFERRED_CUSTOMER__OWNER:
				setOwner((OrderSystem)null);
				return;
			case SpecialPackage.PREFERRED_CUSTOMER__ACCOUNT:
				getAccount().clear();
				return;
			case SpecialPackage.PREFERRED_CUSTOMER__ORDER:
				getOrder().clear();
				return;
			case SpecialPackage.PREFERRED_CUSTOMER__SINCE:
				setSince(SINCE_EDEFAULT);
				return;
		}
		super.eUnset(featureID);
	}

	/**

	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
				return LAST_NAME_EDEFAULT == null ? lastName != null : !LAST_NAME_EDEFAULT.equals(lastName);
			case SpecialPackage.PREFERRED_CUSTOMER__FIRST_NAME:
				return FIRST_NAME_EDEFAULT == null ? firstName != null : !FIRST_NAME_EDEFAULT.equals(firstName);
			case SpecialPackage.PREFERRED_CUSTOMER__OWNER:
				return getOwner() != null;
			case SpecialPackage.PREFERRED_CUSTOMER__ACCOUNT:
				return account != null && !account.isEmpty();
			case SpecialPackage.PREFERRED_CUSTOMER__ORDER:
				return order != null && !order.isEmpty();
			case SpecialPackage.PREFERRED_CUSTOMER__SINCE:
				return SINCE_EDEFAULT == null ? since != null : !SINCE_EDEFAULT.equals(since);
		}
		return super.eIsSet(featureID);
	}

	/**

	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public String toString() {
		if (eIsProxy()) return super.toString();





/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

package ordersystem.special.impl;

import ordersystem.OrderSystemPackage;

import ordersystem.impl.OrderSystemPackageImpl;

import ordersystem.special.LimitedEditionProduct;
import ordersystem.special.PreferredCustomer;
import ordersystem.special.SpecialFactory;

import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EPackage;

import org.eclipse.emf.ecore.impl.EPackageImpl;

/**

	 * @generated
	 */
	public static SpecialPackage init() {
		if (isInited) return (SpecialPackage)EPackage.Registry.INSTANCE.getEPackage(SpecialPackage.eNS_URI);

		// Obtain or create and register package
		SpecialPackageImpl theSpecialPackage = (SpecialPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(eNS_URI) instanceof SpecialPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(eNS_URI) : new SpecialPackageImpl());

		isInited = true;

		// Obtain or create and register interdependencies
		OrderSystemPackageImpl theOrderSystemPackage = (OrderSystemPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(OrderSystemPackage.eNS_URI) instanceof OrderSystemPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(OrderSystemPackage.eNS_URI) : OrderSystemPackage.eINSTANCE);

		// Create package meta-data objects
		theSpecialPackage.createPackageContents();
		theOrderSystemPackage.createPackageContents();

		// Initialize created meta-data
		theSpecialPackage.initializePackageContents();
		theOrderSystemPackage.initializePackageContents();

		// Mark meta-data to indicate it can't be changed
		theSpecialPackage.freeze();

		return theSpecialPackage;
	}


		setNsURI(eNS_URI);

		// Obtain other dependent packages
		OrderSystemPackage theOrderSystemPackage = (OrderSystemPackage)EPackage.Registry.INSTANCE.getEPackage(OrderSystemPackage.eNS_URI);

		// Create type parameters

		// Set bounds for type parameters

		// Add supertypes to classes
		preferredCustomerEClass.getESuperTypes().add(theOrderSystemPackage.getCustomer());
		limitedEditionProductEClass.getESuperTypes().add(theOrderSystemPackage.getProduct());

		// Initialize classes and features; add operations and parameters
		initEClass(preferredCustomerEClass, PreferredCustomer.class, "PreferredCustomer", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEAttribute(getPreferredCustomer_Since(), theOrderSystemPackage.getJavaDate(), "since", null, 0, 1, PreferredCustomer.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$

		initEClass(limitedEditionProductEClass, LimitedEditionProduct.class, "LimitedEditionProduct", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); //$NON-NLS-1$
		initEAttribute(getLimitedEditionProduct_AvailableUntil(), theOrderSystemPackage.getJavaDate(), "availableUntil", null, 0, 1, LimitedEditionProduct.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); //$NON-NLS-1$
	}
} //SpecialPackageImpl




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import java.util.Date;

import ordersystem.OrderSystem;
import ordersystem.OrderSystemPackage;

import ordersystem.impl.ProductImpl;

import ordersystem.special.LimitedEditionProduct;
import ordersystem.special.SpecialPackage;

import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;

import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;

import org.eclipse.emf.ecore.impl.ENotificationImpl;

/**

	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	protected EClass eStaticClass() {
		return SpecialPackage.Literals.LIMITED_EDITION_PRODUCT;
	}

	/**

	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
				case SpecialPackage.LIMITED_EDITION_PRODUCT__OWNER:
					if (eContainer != null)
						msgs = eBasicRemoveFromContainer(msgs);
					return eBasicSetContainer(otherEnd, SpecialPackage.LIMITED_EDITION_PRODUCT__OWNER, msgs);
				default:
					return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
			}
		}
		if (eContainer != null)
			msgs = eBasicRemoveFromContainer(msgs);
		return eBasicSetContainer(otherEnd, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
		if (featureID >= 0) {
			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
				case SpecialPackage.LIMITED_EDITION_PRODUCT__OWNER:
					return eBasicSetContainer(null, SpecialPackage.LIMITED_EDITION_PRODUCT__OWNER, msgs);
				default:
					return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
			}
		}
		return eBasicSetContainer(null, featureID, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {
		if (eContainerFeatureID >= 0) {
			switch (eContainerFeatureID) {
				case SpecialPackage.LIMITED_EDITION_PRODUCT__OWNER:
					return (eContainer).eInverseRemove(this, OrderSystemPackage.ORDER_SYSTEM__PRODUCT, OrderSystem.class, msgs);
				default:
					return eDynamicBasicRemoveFromContainer(msgs);
			}
		}
		return (eContainer).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);
	}

	/**
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @generated
	 */
	public Object eGet(EStructuralFeature eFeature, boolean resolve) {
		switch (eDerivedStructuralFeatureID(eFeature)) {
			case SpecialPackage.LIMITED_EDITION_PRODUCT__NAME:
				return getName();
			case SpecialPackage.LIMITED_EDITION_PRODUCT__SKU:
				return getSku();
			case SpecialPackage.LIMITED_EDITION_PRODUCT__PRICE:
				return new Double(getPrice());
			case SpecialPackage.LIMITED_EDITION_PRODUCT__OWNER:
				return getOwner();
			case SpecialPackage.LIMITED_EDITION_PRODUCT__AVAILABLE_UNTIL:
				return getAvailableUntil();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**

	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
				setName((String)newValue);
				return;
			case SpecialPackage.LIMITED_EDITION_PRODUCT__SKU:
				setSku((String)newValue);
				return;
			case SpecialPackage.LIMITED_EDITION_PRODUCT__PRICE:
				setPrice(((Double)newValue).doubleValue());
				return;
			case SpecialPackage.LIMITED_EDITION_PRODUCT__OWNER:
				setOwner((OrderSystem)newValue);
				return;
			case SpecialPackage.LIMITED_EDITION_PRODUCT__AVAILABLE_UNTIL:
				setAvailableUntil((Date)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**

	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
				setName(NAME_EDEFAULT);
				return;
			case SpecialPackage.LIMITED_EDITION_PRODUCT__SKU:
				setSku(SKU_EDEFAULT);
				return;
			case SpecialPackage.LIMITED_EDITION_PRODUCT__PRICE:
				setPrice(PRICE_EDEFAULT);
				return;
			case SpecialPackage.LIMITED_EDITION_PRODUCT__OWNER:
				setOwner((OrderSystem)null);
				return;
			case SpecialPackage.LIMITED_EDITION_PRODUCT__AVAILABLE_UNTIL:
				setAvailableUntil(AVAILABLE_UNTIL_EDEFAULT);
				return;
		}
		super.eUnset(featureID);
	}

	/**

	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
				return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
			case SpecialPackage.LIMITED_EDITION_PRODUCT__SKU:
				return SKU_EDEFAULT == null ? sku != null : !SKU_EDEFAULT.equals(sku);
			case SpecialPackage.LIMITED_EDITION_PRODUCT__PRICE:
				return price != PRICE_EDEFAULT;
			case SpecialPackage.LIMITED_EDITION_PRODUCT__OWNER:
				return getOwner() != null;
			case SpecialPackage.LIMITED_EDITION_PRODUCT__AVAILABLE_UNTIL:
				return AVAILABLE_UNTIL_EDEFAULT == null ? availableUntil != null : !AVAILABLE_UNTIL_EDEFAULT.equals(availableUntil);
		}
		return super.eIsSet(featureID);
	}

	/**

	 * <!-- end-user-doc -->
	 * @generated
	 */
	@Override
	public String toString() {
		if (eIsProxy()) return super.toString();


Lines 1-7 Link Here

(-).classpath (-1 / +1 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<classpath>	2	<classpath>
3	<classpathentry kind="src" path="src"/>	3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/>	4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>	5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
6	<classpathentry kind="output" path="bin"/>	6	<classpathentry kind="output" path="bin"/>
7	</classpath>	7	</classpath>

Lines 30-34 Link Here

(-)build.properties (-2 / +2 lines)
30	plugin.properties,\	30	plugin.properties,\
31	include_files/,\	31	include_files/,\
32	about.html	32	about.html
33	javacSource = 1.4	33	javacSource = 1.5
34	javacTarget = 1.4	34	javacTarget = 1.5




/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * @see ordersystem.special.SpecialPackage
 * @generated
 */
public class SpecialSwitch<T> {
	/**
	 * The cached model package
	 * <!-- begin-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);
	}


	 * @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);
		}
		else {
			List<EClass> eSuperTypes = theEClass.getESuperTypes();
			return
				eSuperTypes.isEmpty() ?
					defaultCase(theEObject) :
					doSwitch(eSuperTypes.get(0), theEObject);
		}
	}


	 * @return the first non-null result returned by a <code>caseXXX</code> call.
	 * @generated
	 */
	protected T doSwitch(int classifierID, EObject theEObject) {
		switch (classifierID) {
			case SpecialPackage.PREFERRED_CUSTOMER: {
				PreferredCustomer preferredCustomer = (PreferredCustomer)theEObject;
				T result = casePreferredCustomer(preferredCustomer);
				if (result == null) result = caseCustomer(preferredCustomer);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case SpecialPackage.LIMITED_EDITION_PRODUCT: {
				LimitedEditionProduct limitedEditionProduct = (LimitedEditionProduct)theEObject;
				T result = caseLimitedEditionProduct(limitedEditionProduct);
				if (result == null) result = caseProduct(limitedEditionProduct);
				if (result == null) result = defaultCase(theEObject);
				return result;

	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Preferred Customer</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>Preferred Customer</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
	public T casePreferredCustomer(PreferredCustomer object) {
		return null;
	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Limited Edition Product</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>Limited Edition Product</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
	public T caseLimitedEditionProduct(LimitedEditionProduct object) {
		return null;
	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Customer</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>Customer</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
	public T caseCustomer(Customer object) {
		return null;
	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Product</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>Product</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
	public T caseProduct(Product 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;
	}





/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	 * @return whether this factory is applicable for the type of the object.
	 * @generated
	 */
	@Override
	public boolean isFactoryForType(Object object) {
		if (object == modelPackage) {
			return true;

	 * <!-- end-user-doc -->
	 * @generated
	 */
	protected SpecialSwitch<Adapter> modelSwitch =
		new SpecialSwitch<Adapter>() {
			@Override
			public Adapter casePreferredCustomer(PreferredCustomer object) {
				return createPreferredCustomerAdapter();
			}
			@Override
			public Adapter caseLimitedEditionProduct(LimitedEditionProduct object) {
				return createLimitedEditionProductAdapter();
			}
			@Override
			public Adapter caseCustomer(Customer object) {
				return createCustomerAdapter();
			}
			@Override
			public Adapter caseProduct(Product object) {
				return createProductAdapter();
			}
			@Override
			public Adapter defaultCase(EObject object) {
				return createEObjectAdapter();
			}
		};

	 * @return the adapter for the <code>target</code>.
	 * @generated
	 */
	@Override
	public Adapter createAdapter(Notifier target) {
		return modelSwitch.doSwitch((EObject)target);
	}






/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * @see ordersystem.OrderSystemPackage
 * @generated
 */
public class OrderSystemSwitch<T> {
	/**
	 * The cached model package
	 * <!-- begin-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);
	}


	 * @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);
		}
		else {
			List<EClass> eSuperTypes = theEClass.getESuperTypes();
			return
				eSuperTypes.isEmpty() ?
					defaultCase(theEObject) :
					doSwitch(eSuperTypes.get(0), theEObject);
		}
	}


	 * @return the first non-null result returned by a <code>caseXXX</code> call.
	 * @generated
	 */
	protected T doSwitch(int classifierID, EObject theEObject) {
		switch (classifierID) {
			case OrderSystemPackage.ORDER: {
				Order order = (Order)theEObject;
				T result = caseOrder(order);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case OrderSystemPackage.PRODUCT: {
				Product product = (Product)theEObject;
				T result = caseProduct(product);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case OrderSystemPackage.WAREHOUSE: {
				Warehouse warehouse = (Warehouse)theEObject;
				T result = caseWarehouse(warehouse);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case OrderSystemPackage.ORDER_SYSTEM: {
				OrderSystem orderSystem = (OrderSystem)theEObject;
				T result = caseOrderSystem(orderSystem);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case OrderSystemPackage.LINE_ITEM: {
				LineItem lineItem = (LineItem)theEObject;
				T result = caseLineItem(lineItem);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case OrderSystemPackage.INVENTORY_ITEM: {
				InventoryItem inventoryItem = (InventoryItem)theEObject;
				T result = caseInventoryItem(inventoryItem);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case OrderSystemPackage.CUSTOMER: {
				Customer customer = (Customer)theEObject;
				T result = caseCustomer(customer);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case OrderSystemPackage.ADDRESS: {
				Address address = (Address)theEObject;
				T result = caseAddress(address);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case OrderSystemPackage.ACCOUNT: {
				Account account = (Account)theEObject;
				T result = caseAccount(account);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}

	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Order System</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>Order System</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
    public T caseOrderSystem(OrderSystem object) {
		return null;
	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Customer</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>Customer</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
    public T caseCustomer(Customer object) {
		return null;
	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Account</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>Account</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
    public T caseAccount(Account object) {
		return null;
	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Address</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>Address</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
    public T caseAddress(Address object) {
		return null;
	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Order</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>Order</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
    public T caseOrder(Order object) {
		return null;
	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Line Item</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>Line Item</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
    public T caseLineItem(LineItem object) {
		return null;
	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Product</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>Product</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
    public T caseProduct(Product object) {
		return null;
	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Warehouse</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>Warehouse</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
    public T caseWarehouse(Warehouse object) {
		return null;
	}

	/**
	 * Returns the result of interpreting the object as an instance of '<em>Inventory Item</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>Inventory Item</em>'.
	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
	 * @generated
	 */
    public T caseInventoryItem(InventoryItem 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;
	}





/**
 * <copyright>
 *
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	 * @return whether this factory is applicable for the type of the object.
	 * @generated
	 */
    @Override
				public boolean isFactoryForType(Object object) {
		if (object == modelPackage) {
			return true;
		}

     * <!-- end-user-doc -->
	 * @generated
	 */
    protected OrderSystemSwitch<Adapter> modelSwitch =
		new OrderSystemSwitch<Adapter>() {
			@Override
			public Adapter caseOrder(Order object) {
				return createOrderAdapter();
			}
			@Override
			public Adapter caseProduct(Product object) {
				return createProductAdapter();
			}
			@Override
			public Adapter caseWarehouse(Warehouse object) {
				return createWarehouseAdapter();
			}
			@Override
			public Adapter caseOrderSystem(OrderSystem object) {
				return createOrderSystemAdapter();
			}
			@Override
			public Adapter caseLineItem(LineItem object) {
				return createLineItemAdapter();
			}
			@Override
			public Adapter caseInventoryItem(InventoryItem object) {
				return createInventoryItemAdapter();
			}
			@Override
			public Adapter caseCustomer(Customer object) {
				return createCustomerAdapter();
			}
			@Override
			public Adapter caseAddress(Address object) {
				return createAddressAdapter();
			}
			@Override
			public Adapter caseAccount(Account object) {
				return createAccountAdapter();
			}
			@Override
			public Adapter defaultCase(EObject object) {
				return createEObjectAdapter();
			}
		};

	 * @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 ordersystem.OrderSystem <em>Order System</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.

Lines 30-33 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
30	org.eclipse.emf.validation.ui;bundle-version="1.1.100",	30	org.eclipse.emf.validation.ui;bundle-version="1.1.100",
31	org.eclipse.ui;bundle-version="[3.2.0,4.0.0)"	31	org.eclipse.ui;bundle-version="[3.2.0,4.0.0)"
32	Eclipse-LazyStart: true	32	Eclipse-LazyStart: true
33	Bundle-RequiredExecutionEnvironment: J2SE-1.4	33	Bundle-RequiredExecutionEnvironment: J2SE-1.5

Lines 4-10 Link Here

(-)model/order.genmodel (-1 / +2 lines)
4	xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" modelDirectory="/org.eclipse.emf.validation.tests/src"	4	xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" modelDirectory="/org.eclipse.emf.validation.tests/src"
5	editDirectory="/org.eclipse.emf.validation.tests.edit/src" editorDirectory="/org.eclipse.emf.validation.tests.editor/src"	5	editDirectory="/org.eclipse.emf.validation.tests.edit/src" editorDirectory="/org.eclipse.emf.validation.tests.editor/src"
6	modelPluginID="org.eclipse.emf.validation.tests" modelName="Order" editPluginClass="ordersystem.provider.OrderEditPlugin"	6	modelPluginID="org.eclipse.emf.validation.tests" modelName="Order" editPluginClass="ordersystem.provider.OrderEditPlugin"
7	editorPluginClass="ordersystem.presentation.OrderEditorPlugin" nonNLSMarkers="true">	7	editorPluginClass="ordersystem.presentation.OrderEditorPlugin" nonNLSMarkers="true"
		8	complianceLevel="5.0">
8	<foreignModel>OrderSystem.mdl</foreignModel>	9	<foreignModel>OrderSystem.mdl</foreignModel>
9	<genPackages prefix="OrderSystem" ecorePackage="OrderSystem.ecore#/">	10	<genPackages prefix="OrderSystem" ecorePackage="OrderSystem.ecore#/">
10	<genDataTypes ecoreDataType="OrderSystem.ecore#//JavaDate"/>	11	<genDataTypes ecoreDataType="OrderSystem.ecore#//JavaDate"/>




/**
 * <copyright>
 *
 * Copyright (c) 2004, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.emf.validation.EMFEventType;
import org.eclipse.emf.validation.internal.service.GetLiveConstraintsOperation;
import org.eclipse.emf.validation.model.IModelConstraint;
import org.eclipse.emf.validation.tests.TestNotification;

/**

	/* (non-Javadoc)
	 * Extends the inherited method.
	 */
	@Override
	protected void setUp() throws Exception {
		super.setUp();
		

	}
	
	public void test_execute() {
		Collection<IModelConstraint> c = getFixture().execute(new TestProvider());
		assertNotNull(c);
		assertTrue("Execution result not collection", o instanceof Collection);//$NON-NLS-1$
		
		Collection c = (Collection)o;
		assertTrue("Token not found", c.contains(LIVE_TOKEN));//$NON-NLS-1$
	}

	public void test_getConstraints() {
		getFixture().execute(new TestProvider());
		
		Collection<IModelConstraint> c = getFixture().getConstraints();
		
		// check that the token is in this collection
		assertTrue("Token not found", c.contains(LIVE_TOKEN)); //$NON-NLS-1$





package org.eclipse.emf.validation.internal.service.impl.tests;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;


import ordersystem.OrderSystemFactory;
import ordersystem.OrderSystemPackage;
import ordersystem.Product;
import ordersystem.special.SpecialFactory;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.impl.AdapterImpl;

import org.eclipse.emf.validation.internal.service.LiveValidator;
import org.eclipse.emf.validation.model.EvaluationMode;
import org.eclipse.emf.validation.service.ILiveValidator;
import org.eclipse.emf.validation.service.IValidator;
import org.eclipse.emf.validation.service.ModelValidationService;
import org.eclipse.emf.validation.tests.TestBase;
import org.eclipse.emf.validation.tests.TestNotification;

	/* (non-Javadoc)
	 * Extends the inherited method.
	 */
	@Override
	protected void setUp() throws Exception {
		super.setUp();
		

	 * Class to test for IStatus validate(Object)
	 */
	public void test_validate_object() {
		Notification target = new TestNotification(
				OrderSystemFactory.eINSTANCE.createProduct(),
				Notification.SET,
				OrderSystemPackage.PRODUCT__SKU,

		} catch (Exception e) {
			fail("Should not throw."); //$NON-NLS-1$
		}
		
		try {
			getValidator().validate("foo"); //$NON-NLS-1$
			fail("Should throw."); //$NON-NLS-1$
		} catch (Exception e) {
			// good
		}
	}

	/*

	 * Class to test for IStatus validate(Collection)
	 */
	public void test_validateCollection() {
		Notification target = new TestNotification(
				OrderSystemFactory.eINSTANCE.createProduct(),
				Notification.SET,
				OrderSystemPackage.PRODUCT__SKU,

		
		try {
			getValidator().validate(Collections.singleton(target));
			getValidator().validate(Collections.<Notification>emptySet());
		} catch (Exception e) {
			fail("Should not throw."); //$NON-NLS-1$
		}
		
		try {
			getValidator().validate(Collections.singleton("foo")); //$NON-NLS-1$
			fail("Should throw."); //$NON-NLS-1$
		} catch (Exception e) {
			// good
		}
	}
	
	private OrderSystem createOrderSystem() {

		os.getCustomer().add(c);
		
		// validate the changes, using a real validator
		ILiveValidator realValidator =
			ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE);
		realValidator.validate(ng.getNotifications());
		

		}
		
		// add a few customers, individually, to record separate notifications
		List<Customer> customers = new java.util.ArrayList<Customer>();
		Customer c = OrderSystemFactory.eINSTANCE.createCustomer();
		os.getCustomer().add(c);  // one
		customers.add(c);

		customers.add(c);
		
		// validate the changes, using a real validator
		ILiveValidator realValidator =
			ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE);
		realValidator.validate(ng.getNotifications());
		

		OrderSystem os = createOrderSystem();
		
		// add a few customers
		List<Customer> customers = new java.util.ArrayList<Customer>();
		customers.add(OrderSystemFactory.eINSTANCE.createCustomer());
		customers.add(OrderSystemFactory.eINSTANCE.createCustomer());
		customers.add(OrderSystemFactory.eINSTANCE.createCustomer());

		}
		
		// remove a customer
		Customer c = customers.get(0);
		os.getCustomer().remove(c);
		
		// validate the changes, using a real validator
		ILiveValidator realValidator =
			ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE);
		realValidator.validate(ng.getNotifications());
		

		OrderSystem os = createOrderSystem();
		
		// add a few customers
		List<Customer> customers = new java.util.ArrayList<Customer>();
		customers.add(OrderSystemFactory.eINSTANCE.createCustomer());
		customers.add(OrderSystemFactory.eINSTANCE.createCustomer());
		customers.add(OrderSystemFactory.eINSTANCE.createCustomer());

		os.getCustomer().remove(customers.get(2));  // three
		
		// validate the changes, using a real validator
		ILiveValidator realValidator =
			ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE);
		realValidator.validate(ng.getNotifications());
		

		OrderSystem os = createOrderSystem();
		
		// add a few customers
		List<Customer> customers = new java.util.ArrayList<Customer>();
		customers.add(OrderSystemFactory.eINSTANCE.createCustomer());
		customers.add(OrderSystemFactory.eINSTANCE.createCustomer());
		customers.add(OrderSystemFactory.eINSTANCE.createCustomer());

		os.getCustomer().move(0, 2);
		
		// validate the changes, using a real validator
		ILiveValidator realValidator =
			ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE);
		realValidator.validate(ng.getNotifications());
		

		OrderSystem os = createOrderSystem();
		
		// add a few customers
		List<Customer> customers = new java.util.ArrayList<Customer>();
		customers.add(OrderSystemFactory.eINSTANCE.createCustomer());
		customers.add(OrderSystemFactory.eINSTANCE.createCustomer());
		customers.add(OrderSystemFactory.eINSTANCE.createCustomer());

		os.getCustomer().move(0, 1);  // three
		
		// validate the changes, using a real validator
		ILiveValidator realValidator =
			ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE);
		realValidator.validate(ng.getNotifications());
		

		os.eAdapters().remove(ng);
		
		// validate the changes, using a real validator
		ILiveValidator realValidator =
			ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE);
		realValidator.validate(ng.getNotifications());
		

		os.eAdapters().remove(ng);  // three
		
		// validate the changes, using a real validator
		ILiveValidator realValidator =
			ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE);
		realValidator.validate(ng.getNotifications());
		

		os.setVersion(3);
		
		// validate the changes, using a real validator
		ILiveValidator realValidator =
			ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE);
		realValidator.validate(ng.getNotifications());
		

		os.setVersion(3);
		
		// validate the changes, using a real validator
		ILiveValidator realValidator =
			ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE);
		realValidator.validate(ng.getNotifications());
		

		EObject object = OrderSystemFactory.eINSTANCE.createOrder(); // Don't add to a resource
		Notification event = new TestNotification(object, Notification.SET);
		
		ILiveValidator localValidator = ModelValidationService.getInstance().newValidator(
			EvaluationMode.LIVE);
		localValidator.setReportSuccesses(true);
		IStatus[] status = getStatuses(localValidator.validate(event));
		

		assertAllConstraintsNotPresent(
				"live", //$NON-NLS-1$
				status,
				ID_PREFIX + "order.hasName", //$NON-NLS-1$
				ID_PREFIX + "order.hasOwner"); //$NON-NLS-1$
						ID_PREFIX + "order.hasOwner", //$NON-NLS-1$
				}));
	}
	
	public void test_notficationFilterCustom_177653() {
		EObject object = OrderSystemFactory.eINSTANCE.createOrder();
		Notification event = new TestNotification(object, Notification.SET);
		
		ILiveValidator localValidator = ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE);
		localValidator.setReportSuccesses(true);
		
		// Set notification filter which accepts eObjects that are not attached
		// to a resource
		localValidator.setNotificationFilter(new FilteredCollection.Filter<Notification>() {
			public boolean accept(Notification element) {
				return (element.getNotifier() instanceof EObject);
					Notification notification = (Notification)element;
					return (notification.getNotifier() instanceof EObject);
				}
                
				return false;
			}});
		
		IStatus[] status = getStatuses(localValidator.validate(event));

		assertAllConstraintsPresent(
				"live", //$NON-NLS-1$
				status,
				ID_PREFIX + "order.hasName", //$NON-NLS-1$
				ID_PREFIX + "order.hasOwner"); //$NON-NLS-1$
						ID_PREFIX + "order.hasOwner", //$NON-NLS-1$
				}));
	}
	
	public void test_notificationGenerator_177647() {
		Order order = OrderSystemFactory.eINSTANCE.createOrder();
		LineItem item = OrderSystemFactory.eINSTANCE.createLineItem();
		Product product = SpecialFactory.eINSTANCE.createLimitedEditionProduct();
		
		Resource res = new XMIResourceImpl();
		

		
		Notification event = new TestNotification(order, Notification.SET);
		
		ILiveValidator localValidator = ModelValidationService.getInstance().newValidator(EvaluationMode.LIVE);
		localValidator.setReportSuccesses(true);
		
		IStatus[] status = getStatuses(localValidator.validate(event));

		assertAllConstraintsPresent(
				"live", //$NON-NLS-1$
				status,
				ID_PREFIX + "limitedEdition.canIncludeInSpecial"); //$NON-NLS-1$
						ID_PREFIX + "limitedEdition.canIncludeInSpecial", //$NON-NLS-1$
				}));
		
		// Ensure that a constraint targeted at ALL events (eg using wildcard),
		// does not get triggered see
		// XMLConstraintDescriptor#targetsEvent(Notification)
		assertAllConstraintsNotPresent(
				"live", status, //$NON-NLS-1$
				ID_PREFIX + "limitedEdition.hasDates"); //$NON-NLS-1$
						}));
	}
	
	private static class NotificationGatherer extends AdapterImpl {
		private final List<Notification> notifications =
			new java.util.ArrayList<Notification>();
		
		/* (non-Javadoc)
		 * Redefines/Implements/Extends the inherited method.
		 */
		@Override
		public void notifyChanged(Notification msg) {
			notifications.add(msg);
		}
		
		List<Notification> getNotifications() {
			return notifications;
		}
		

		/* (non-Javadoc)
		 * Redefines/Implements/Extends the inherited method.
		 */
		@Override
		public IStatus validate(IValidationContext ctx) {
			instance = this;
			invocationCount++;




/**
 * <copyright>
 *
 * Copyright (c) 2004, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.emf.validation.internal.service.ConstraintCache;
import org.eclipse.emf.validation.internal.service.IProviderDescriptor;
import org.eclipse.emf.validation.internal.service.IProviderOperation;
import org.eclipse.emf.validation.model.IModelConstraint;
import org.eclipse.emf.validation.service.IModelConstraintProvider;
import org.eclipse.emf.validation.tests.TestNotification;


	/* (non-Javadoc)
	 * Extends the inherited method.
	 */
	@Override
	protected void setUp() throws Exception {
		super.setUp();
		

	}

	public void test_getProviders() {
		Collection<IProviderDescriptor> c = getFixture().getProviders();
		
		assertNotNull("Collection is null", c); //$NON-NLS-1$
		assertFalse("Collection is empty", c.isEmpty()); //$NON-NLS-1$
	}

	public void test_addProvider() {
		Collection<IProviderDescriptor> c = getFixture().getProviders();
		
		assertNotNull("Collection is null", c); //$NON-NLS-1$
		assertTrue("Provider not found", c.contains(provider)); //$NON-NLS-1$

	public void test_getBatchConstraints() {
		assertTrue("Hit count should be zero", batchHits == 0); //$NON-NLS-1$
		
		Collection<IModelConstraint> c = getFixture().getBatchConstraints(
				OrderSystemFactory.eINSTANCE.createProduct(),
				null);
		

	public void test_getLiveConstraints() {
		assertTrue("Hit count should be zero", liveHits == 0); //$NON-NLS-1$
		
		Collection<IModelConstraint> c = getFixture().getLiveConstraints(
				new TestNotification(
						OrderSystemFactory.eINSTANCE.createProduct(),
						Notification.SET),

	static class TestDescriptor implements IProviderDescriptor {
		private final IModelConstraintProvider testProvider = new TestProvider();
		
		public boolean provides(
				IProviderOperation<? extends Collection<? extends IModelConstraint>> operation) {
			return true;
		}


	static class TestProvider
			extends AbstractGetConstraintsOperationTest.TestProvider {
		
		@Override
		public Collection<IModelConstraint> getBatchConstraints(
			EObject eObject,
			Collection<IModelConstraint> constraints) {
			
			batchHits++;
			return super.getBatchConstraints(eObject, constraints);
		}
		
		@Override
		public Collection<IModelConstraint> getLiveConstraints(
			Notification notification,
			Collection<IModelConstraint> constraints) {
			
			liveHits++;
			return super.getLiveConstraints(notification, constraints);




/**
 * <copyright>
 *
 * Copyright (c) 2004, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.emf.validation.internal.service.IProviderOperation;
import org.eclipse.emf.validation.internal.service.IProviderOperationExecutor;
import org.eclipse.emf.validation.model.EvaluationMode;
import org.eclipse.emf.validation.model.IModelConstraint;

import junit.framework.TestCase;


	/* (non-Javadoc)
	 * Extends the inherited method.
	 */
	@Override
	protected void setUp() throws Exception {
		super.setUp();
		

	 * Class to test for IStatus validate(Object)
	 */
	public void test_validate_object() {
		EObject target = OrderSystemFactory.eINSTANCE.createProduct();
		
		try {
			getValidator().validate(target);
		} catch (Exception e) {
			fail("Should not throw."); //$NON-NLS-1$
		}
		
		try {
			getValidator().validate("foo"); //$NON-NLS-1$
			fail("Should throw."); //$NON-NLS-1$
		} catch (Exception e) {
			// good
		}
	}

	/*
	 * Class to test for IStatus validate(Collection)
	 */
	public void test_validateCollection() {
		EObject target = OrderSystemFactory.eINSTANCE.createProduct();
		
		try {
			getValidator().validate(Collections.singleton(target));
			getValidator().validate(Collections.<EObject>emptySet());
		} catch (Exception e) {
			fail("Should not throw."); //$NON-NLS-1$
		}
		
		try {
			getValidator().validate(Collections.singleton("foo")); //$NON-NLS-1$
			fail("Should throw."); //$NON-NLS-1$
		} catch (Exception e) {
			// good
		}
	}
	
	public void test_isIncludeLiveConstraints() {

	public void test_validate_Collection_IProgressMonitor() {
		TestMonitor monitor = new TestMonitor();
		
		Collection<EObject> targets = new java.util.ArrayList<EObject>();
		targets.add(OrderSystemFactory.eINSTANCE.createProduct());
		targets.add(OrderSystemFactory.eINSTANCE.createProduct());
		

		}
	}
	
	static class TestExecutor
			implements IProviderOperationExecutor<Collection<IModelConstraint>> {
		/* (non-Javadoc)
		 * Implements the inherited method.
		 */
		public void execute(IProviderOperation<? extends Collection<IModelConstraint>> op) {
			// don't need to do anything
		}
	}




/**
 * <copyright>
 *
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

package org.eclipse.emf.validation.internal.service.impl.tests;

import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.InvalidRegistryObjectException;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.validation.EMFEventType;
import org.eclipse.emf.validation.internal.util.XmlConstraintDescriptor;
import org.eclipse.emf.validation.model.Category;

	private static final String TEST_BODY = "self.name = 'Ottawa'";//$NON-NLS-1$
	private static final int TEST_CODE = 1000;
	private static final ConstraintSeverity TEST_SEVERITY = ConstraintSeverity.WARNING;
	private static final EvaluationMode<Notification> TEST_MODE = EvaluationMode.LIVE;
	private static final String TEST_NAMESPACE_URI = "http:///ordersystem.ecore"; //$NON-NLS-1$
	private static final String TEST_CLASS = "Warehouse"; //$NON-NLS-1$
	private static final String TEST_EVENT = "Set"; //$NON-NLS-1$

	 * Handy implementation of the Eclipse extension configuration element. 
	 */
	public static class FixtureElement implements IConfigurationElement {
		private final Map<String, String> attributes = new java.util.HashMap<String, String>();
		private final List<IConfigurationElement> children = new java.util.ArrayList<IConfigurationElement>();
		private Object parent;
		private final String myName;
		private String value = ""; //$NON-NLS-1$

			FixtureElement result = new FixtureElement(name);
			
			if (attributes != null) {
				for (String[] element : attributes) {
					result.putAttribute(element[0], element[1]);
				}
			}
				

		
		// implements/extends the inherited method
		public String getAttribute(String name) {
			return attributes.get(name);
		}
		
		public FixtureElement putAttribute(String name, String newValue) {


		// implements/extends the inherited method
		public String[] getAttributeNames() {
			return attributes.keySet().toArray(new String[attributes.size()]);
					new String[attributes.size()]);
		}

		// implements/extends the inherited method
		public IConfigurationElement[] getChildren() {
			return children.toArray(new IConfigurationElement[children.size()]);
					new IConfigurationElement[children.size()]);
		}

		// implements/extends the inherited method
		public IConfigurationElement[] getChildren(String name) {
			List<IConfigurationElement> result = new java.util.ArrayList<IConfigurationElement>();
			
			for (IConfigurationElement next : children) {
				IConfigurationElement next = (IConfigurationElement)iter.next();
				
				if (next.getName().equals(name)) {
					result.add(next);
				}
			}
			
			return result.toArray(new IConfigurationElement[result.size()]);
					new IConfigurationElement[result.size()]);
		}
		
		public FixtureElement addChild(IConfigurationElement child) {

		// constructor can find the plug-in ID that it needs from the
		// configuration element
		/** @deprecated */
		@Deprecated
		public IExtension getDeclaringExtension() {
			return new IExtension() {
				

	}

	public void test_getCategories() {
		Set<Category> categories = Collections.singleton(
				CategoryManager.getInstance().getDefaultCategory());
		
		assertEquals(categories, getFixture().getCategories());




/**
 * <copyright>
 *
 * Copyright (c) 2004, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * @author Christian W. Damus (cdamus)
 */
abstract class AbstractGetConstraintsOperationTest extends TestBase {
	protected static final IModelConstraint BATCH_TOKEN = newConstraint(EvaluationMode.BATCH);
	protected static final IModelConstraint LIVE_TOKEN = newConstraint(EvaluationMode.LIVE);
	
	private AbstractGetConstraintsOperation fixture;
	

		this.fixture = fixture;
	}
	
	private static TestConstraint newConstraint(EvaluationMode<?> mode) {
		ConstraintDescriptorTest.FixtureElement config =
			ConstraintDescriptorTest.newFixtureConfig();
		

		/* (non-Javadoc)
		 * Redefines/Implements/Extends the inherited method.
		 */
		public Collection<IModelConstraint> getBatchConstraints(
				EObject eObject,
				Collection<IModelConstraint> constraints) {
			return appendTo(constraints, BATCH_TOKEN);
		}

		/* (non-Javadoc)
		 * Redefines/Implements/Extends the inherited method.
		 */
		public Collection<IModelConstraint> getLiveConstraints(
				Notification notification,
				Collection<IModelConstraint> constraints) {
			return appendTo(constraints, LIVE_TOKEN);
		}
		
		private Collection<IModelConstraint> appendTo(Collection<IModelConstraint> c,
				IModelConstraint constraint) {
			
			if (c == null) {
				c = new java.util.ArrayList<IModelConstraint>(1);
			}
			
			c.add(constraint);
			
			return c;
		}




/**
 * <copyright>
 *
 * Copyright (c) 2004, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import org.eclipse.emf.ecore.EObject;

import org.eclipse.emf.validation.internal.service.GetBatchConstraintsOperation;
import org.eclipse.emf.validation.model.IModelConstraint;

/**
 * Tests for {@link GetBatchConstraintsOperation}.

	/* (non-Javadoc)
	 * Extends the inherited method.
	 */
	@Override
	protected void setUp() throws Exception {
		super.setUp();
		

	}

	public void test_execute() {
		Collection<IModelConstraint> c = getFixture().execute(new TestProvider());
		assertNotNull(c);
		assertTrue("Execution result not collection", o instanceof Collection);//$NON-NLS-1$
		
		Collection c = (Collection)o;
		assertTrue("Token not found", c.contains(BATCH_TOKEN));//$NON-NLS-1$
	}

	public void test_getConstraints() {
		getFixture().execute(new TestProvider());
		
		Collection<IModelConstraint> c = getFixture().getConstraints();
		
		// check that the token is in this collection
		assertTrue("Token not found", c.contains(BATCH_TOKEN)); //$NON-NLS-1$




/**
 * <copyright>
 *
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

import org.eclipse.emf.validation.util.FilteredCollection;

import junit.framework.Test;

 * @author Christian W. Damus (cdamus)
 */
public class FilteredCollectionTest extends TestCase {
	private class Filter implements FilteredCollection.Filter<Integer> {
		// filters out odd integers
		public boolean accept(Integer element) {
			return (element % 2) == 0;
		}
	}
	
	private final Filter filter = new Filter();
	private final Collection<Integer> original = Arrays.asList(
		new Integer[] {
			new Integer(0),
			new Integer(1),

			new Integer(4),
			new Integer(5),
			});
	private final Collection<Integer> expectedFilteredResult = Arrays.asList(
		new Integer[] {
			new Integer(0),
			new Integer(2),
			new Integer(4),
			});
	private final FilteredCollection<Integer> filteredCollection = new FilteredCollection<Integer>(
			original,
			filter);


	/** Tests for correct iteration. */
	public void test_iterator() {
		// test for contents.  Note that lists can only be compared to lists
		assertEquals(expectedFilteredResult, new ArrayList<Integer>(filteredCollection));
		
		// test for ordering
		int i = 0;
		for (Integer next : filteredCollection) {
			Integer next = (Integer)iter.next();
			
			assertEquals(i, next.intValue());
			
			i = i + 2;




/**
 * <copyright>
 *
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;


	
	public static class ValidationContext implements IValidationContext {
		private final EObject target;
		private final Set<EObject> resultLocus = new java.util.HashSet<EObject>();
		
		public ValidationContext(EObject target) {
			this.target = target;

		}

		// implements the inherited method
		public List<Notification> getAllEvents() {
			return Collections.emptyList();
		}

		// implements the inherited method

		}

		// implements the inherited method
		public void skipCurrentConstraintForAll(Collection<?> eObjects) {
			// no need to do anything in this test fixture
		}
		

		}

		// implements the inherited method
		public Set<EObject> getResultLocus() {
			return resultLocus;
		}
		

		}
		
		// implements the inherited method
		public void addResults(Collection<? extends EObject> eObjects) {
			resultLocus.addAll(eObjects);
		}

		/* (non-Javadoc)

		/* (non-Javadoc)
		 * Redefines/Implements/Extends the inherited method.
		 */
		public IStatus createFailureStatus(Object... messageArguments) {
			return new Status(
				IStatus.ERROR,
				"org.eclipse.emf.validation.tests", //$NON-NLS-1$




/**
 * <copyright>
 *
 * Copyright (c) 2003, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

 * @author Christian W. Damus (cdamus)
 */
public class ConstraintFactoryTest extends TestCase {
	private final ConstraintFactory factory = ConstraintFactory.getInstance();
	
	public void test_getInstance() {
		assertSame(factory, ConstraintFactory.getInstance());
	}

	public void test_newConstraint() {
		@SuppressWarnings("deprecation")
		IModelConstraint constraint = factory.newConstraint(
				ConstraintDescriptorTest.getFixture());
		

		try {
			XmlConstraintDescriptor desc = new XmlConstraintDescriptor(element);
			
			@SuppressWarnings("deprecation")
			IModelConstraint constraint = factory.newConstraint(desc);
			
			assertFalse(desc.isEnabled());

Lines 1-8 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-5 / +5 lines)
1	#Wed Dec 20 11:48:36 EST 2006	1	#Wed Oct 31 00:04:04 EDT 2007
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled	3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.4	4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
5	org.eclipse.jdt.core.compiler.compliance=1.4	5	org.eclipse.jdt.core.compiler.compliance=1.5
6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error	6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning	7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
8	org.eclipse.jdt.core.compiler.source=1.4	8	org.eclipse.jdt.core.compiler.source=1.5

Lines 1-8 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-5 / +5 lines)
1	#Wed Dec 20 11:49:05 EST 2006	1	#Wed Oct 31 00:02:33 EDT 2007
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled	3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.4	4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
5	org.eclipse.jdt.core.compiler.compliance=1.4	5	org.eclipse.jdt.core.compiler.compliance=1.5
6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error	6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning	7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
8	org.eclipse.jdt.core.compiler.source=1.4	8	org.eclipse.jdt.core.compiler.source=1.5




import java.util.Arrays;
import java.util.List;

import org.eclipse.emf.common.util.Enumerator;
import org.eclipse.emf.validation.ui.internal.ValidationUIPlugin;



 *
 * @author Christian W. Damus (cdamus)
 */
public enum ValidationLiveProblemsDestination implements Enumerator {
    DIALOG("Dialog"), //$NON-NLS-1$
    CONSOLE("Console"); //$NON-NLS-1$
     */
    private static int nextOrdinal = 0;
    
    private String name;
    private int ordinal;

    private String name;
    public static final ValidationLiveProblemsDestination CONSOLE = new ValidationLiveProblemsDestination("Console"); //$NON-NLS-1$

    /**
     * The list of values for this enumerated type.

     */
    private ValidationLiveProblemsDestination(String name) {
        this.name = name;
        this.ordinal = nextOrdinal++;
    }

    /**

     * 
     * @return The list of constants for this enumerated type.
     */
    protected List<ValidationLiveProblemsDestination> getValues() {
        return Arrays.asList(VALUES);
    }
    
    public int getOrdinal() {
    	return getValue();
    }
    
    public String getName() {
    	return name;
    }
    
    public int getValue() {
    	return ordinal();
    }
    
    public String getLiteral() {
    	return getName();
    }
}




import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.validation.model.Category;

	 */
	private ICategoryTreeNode delegate;
	
	private List<IConstraintNode> constraints;
	
	/**
	 * Implementation of the root node of the category selection tree.

		}
		
		// implements the inherited method to wrap the top-level categories
		@Override
        protected List<ICategoryTreeNode> createChildren() {
		    Collection<Category> topLevel = CategoryManager.getInstance().getTopLevelCategories();
			List<ICategoryTreeNode> result = new java.util.ArrayList<ICategoryTreeNode>(
					topLevel.size());
			
			for (Category next : topLevel) {
				if (!isRecursivelyEmpty(next)) {
					result.add(new CategoryTreeNode(getTree(), next, this, getFilter()));
				} else {
					iter.set(
							new CategoryTreeNode(
									getTree(),
									next,
									this,
									getFilter()));
				}
			}
			

		}
		
		// redefines the inherited method
		@Override
        public String getDescription() {
			return ""; //$NON-NLS-1$
		}
		
		// redefines the inherited method
		public List<IConstraintNode> getConstraints() {
			return Collections.emptyList();
		}
	}
	

		}
		
		// redefines the inherited method
		@Override
        protected List<ICategoryTreeNode> createChildren() {
			// delegates are leaf nodes, by definition
			return Collections.emptyList();
		}
		
		// extends the inherited method
		@Override
        public String toString() {
			String result = super.toString();
			
			StringBuffer buf = new StringBuffer(result.length() + 2);

	}
	
	// implements the inherited method
	@Override
    protected List<ICategoryTreeNode> createChildren() {
		final Category category = getCategory();
		Collection<Category> categoryChildren = category.getChildren();
		
		List<ICategoryTreeNode> result;
		
		if (!categoryChildren.isEmpty() && !getConstraints(category, getFilter()).isEmpty()) {
			// add one for the delegate child that contains my own constraints
			result = new java.util.ArrayList<ICategoryTreeNode>(categoryChildren.size() + 1);
			
			// add my delegate
			delegate = new DelegateNode(getTree(), category, this, getFilter());
			result.add(delegate);
		} else {
			result = new java.util.ArrayList<ICategoryTreeNode>(categoryChildren.size());
		}
		
		for (Category next : categoryChildren) {
			Category next = (Category) iter.next();
			
			if (!isRecursivelyEmpty(next)) {
				result.add(new CategoryTreeNode(
						getTree(),

	 */
	private void propagateToConstraints(boolean newChecked) {
		if (!hasDelegate()) {
			for (IConstraintNode next : getConstraints()) {
				IConstraintNode next = (IConstraintNode) iter.next();
				
				// my constraints update my check state as necessary
				next.setChecked(newChecked);
			}

		boolean newChecked = newValue;
		boolean newGrayed = false;
		
		for (IConstraintNode next : getConstraints()) {
			IConstraintNode next = (IConstraintNode) iter.next();
			
			if (next != constraint) {
				if (next.isChecked() != newValue) {
					newGrayed = true;

	}
	
	// extends the inherited method
	@Override
    public void applyToPreferences() {
		if (!hasDelegate()) {
			for (IConstraintNode next : getConstraints()) {
				IConstraintNode next = (IConstraintNode) iter.next();
				
				next.applyToPreferences();
			}
		}

	}
	
	// extends the inherited method
	@Override
    public void revertFromPreferences() {
		if (!hasDelegate()) {
			IConstraintNode node = null;
			
			for (Iterator<IConstraintNode> iter = getConstraints().iterator();
			        iter.hasNext();) {
			    
				node = iter.next();
				
				node.revertFromPreferences();
			}

	}
	
	// extends the inherited method
	@Override
    public void restoreDefaults() {
		if (!hasDelegate()) {
			IConstraintNode node = null;
			
			for (Iterator<IConstraintNode> iter = getConstraints().iterator();
			        iter.hasNext();) {
			    
				node = iter.next();
				
				node.restoreDefaults();
			}

	 * @return <code>null</code> if I have a delegate node; the superclass
	 *     result, otherwise
	 */
	@Override
    public Category getCategory() {
		if (hasDelegate()) {
			return null;
		} else {

	}
	
	// implements the inherited method
	public List<IConstraintNode> getConstraints() {
		if (hasDelegate()) {
			constraints = Collections.emptyList();
		} else if (constraints == null) {
		    Collection<IConstraintDescriptor> descriptors = getConstraints(
		        getCategory(), getFilter());
			constraints = new java.util.ArrayList<IConstraintNode>(
		            descriptors.size());
		    
			for (IConstraintDescriptor next : descriptors) {
				IConstraintNode node = ConstraintNode.getInstance(next);
					(IConstraintDescriptor)iter.next());
				
				node.addCategory(this);
				constraints.add(node);
			}
		}
		

	}
	
	// implements the inherited method
	@Override
    public IConstraintNode[] getSelectedConstraints() {
		List<IConstraintNode> result = new java.util.ArrayList<IConstraintNode>(
		        getConstraints().size());
		
		for (IConstraintNode next : getConstraints()) {
			IConstraintNode next = (IConstraintNode) iter.next();
			
			if (next.isChecked()) {
				result.add(next);
			}
		}
		
		return result.toArray(
			new IConstraintNode[result.size()]);
	}
	

	 * category (because my delegate has it), I return my delegate's category's
	 * name.
	 */
	@Override
    public String toString() {
		if ((getCategory() == null) && hasDelegate()) {
			return delegate.getCategory().getName();
		} else {




public class ConstraintNode
	implements IConstraintNode {

	private static final java.util.Map<String, IConstraintNode> instanceMap =
		new java.util.HashMap<String, IConstraintNode>();
	
	private final IConstraintDescriptor constraint;
	private Boolean mandatory;
	private boolean checked = false;
	
	private final java.util.Set<ICategoryTreeNode> categories =
		new java.util.HashSet<ICategoryTreeNode>();
	
	/**
	 * Initializes me with the constraint that I represent.

		IConstraintNode result = null;
		
		if (id != null) {
			result = instanceMap.get(id);
			
			if (result == null) {
				result = new ConstraintNode(constraint);

	/* (non-Javadoc)
	 * Implements the inherited method.
	 */
	public Collection<Category> getCategories() {
		return constraint.getCategories();
	}


		if (mandatory == null) {
			boolean m = false;
			
			for (Iterator<Category> iter = constraint.getCategories().iterator();
					!m && iter.hasNext();) {
				
				if (iter.next().isMandatory()) {
					m = true;
				}
			}

	 * This allows them to update theirs, to match.
	 */
	private void updateCategories() {
		for (ICategoryTreeNode next : categories) {
			ICategoryTreeNode next = (ICategoryTreeNode) iter.next();
			
			next.updateCheckState(this);
		}
	}




 */
package org.eclipse.emf.validation.ui.internal.preferences;

import java.util.Iterator;
import java.util.List;
import java.util.Set;


	 * 
	 * @return my children
	 */
	protected abstract List<ICategoryTreeNode> createChildren();
	
	/**
	 * Lazily initializes my children on first access.

	 */
	private void initChildren() {
		if (children == null) {
			List<ICategoryTreeNode> childList = createChildren();
			children = childList.toArray(new ICategoryTreeNode[childList.size()]);
					new ICategoryTreeNode[childList.size()]);
		}
	}
	

		if (result) {
			// check children, too
			
			for (Category child : cat.getChildren()) {
				result = isRecursivelyEmpty(child);
			}
		}
		

     * 
     * @since 1.1
     */
    protected static Set<IConstraintDescriptor> getConstraints(Category category, IConstraintFilter filter) {
        Set<IConstraintDescriptor> filteredConstraints =
        	new java.util.HashSet<IConstraintDescriptor>();
        
        for (IConstraintDescriptor descriptor : category.getConstraints()) {
            IConstraintDescriptor descriptor = (IConstraintDescriptor)iter.next();
            
            if (filter.accept(descriptor, null)) {
                filteredConstraints.add(descriptor);
            }

	public void applyToPreferences() {
		ICategoryTreeNode[] currentChildren = getChildren();
		
		for (ICategoryTreeNode element : currentChildren) {
			element.applyToPreferences();
		}
	}
	

	public void revertFromPreferences() {
		ICategoryTreeNode[] currentChildren = getChildren();
		
		for (ICategoryTreeNode element : currentChildren) {
			element.revertFromPreferences();
		}
	}


	public void restoreDefaults() {
		ICategoryTreeNode[] currentChildren = getChildren();
		
		for (ICategoryTreeNode element : currentChildren) {
			element.restoreDefaults();
		}
	}
	

	}
	
	// redefines the inherited method
	@Override
	public String toString() {
		return (getCategory() == null)
			? "" //$NON-NLS-1$





import java.text.MessageFormat;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.validation.model.Category;

	public static String formatConstraintDescription(
			IConstraintNode constraint,
			Category selectedCategory,
			List<? super StyleRange> styles) {
		
		String description = constraint.getDescription();
		

						   description,
						   constraint.getSeverity()});
		
		Collection<Category> categories = constraint.getCategories();
		if (categories.size() > 1) {
			// also display the other categories that contain this constraint
			text = text + getOtherCategories(selectedCategory, categories);

	 */
	private static String getOtherCategories(
			Category selected,
			Collection<? extends Category> categories) {
		
		StringBuffer result = new StringBuffer(64);
		result.append(ALSO_IN_CATEGORIES);
		
		for (Category next : categories) {
			Category next = (Category)iter.next();
			
			if (next != selected) {
				result.append(PLATFORM_NEWLINE);
				result.append(next.getQualifiedName());

	 * @param styles a list which collects the corresponding style ranges
	 * @return the original <code>text</code> minus the markup
	 */
	private static String parseStyles(String text, List<? super StyleRange> styles) {
		int pos = -1;
		int lastPos = 0;
		

Lines 19-24 Link Here

(-)src/org/eclipse/emf/validation/ui/internal/preferences/IConstraintNode.java (-1 / +2 lines)
19		19
20	import java.util.Collection;	20	import java.util.Collection;
21		21
		22	import org.eclipse.emf.validation.model.Category;
22	import org.eclipse.jface.viewers.CheckStateChangedEvent;	23	import org.eclipse.jface.viewers.CheckStateChangedEvent;
23		24
24		25
Lines 60-66 Link Here
60	*	61	*
61	* @return the categories of the constraint that I represent	62	* @return the categories of the constraint that I represent
62	*/	63	*/
63	Collection getCategories();	64	Collection<Category> getCategories();
64		65
65	/**	66	/**
66	* Obtains the evaluation mode of the constraint, to show in the GUI.	67	* Obtains the evaluation mode of the constraint, to show in the GUI.

Lines 101-107 Link Here

(-)src/org/eclipse/emf/validation/ui/internal/preferences/ICategoryTreeNode.java (-1 / +1 lines)
101	*	101	*
102	* @return my constraints, or an empty list if I am not a leaf node	102	* @return my constraints, or an empty list if I am not a leaf node
103	*/	103	*/
104	List getConstraints();	104	List<IConstraintNode> getConstraints();
105		105
106	/**	106	/**
107	* Obtains the category that I represent if I am a leaf node.	107	* Obtains the category that I represent if I am a leaf node.




        super(new ResourceLocator[] {});
    }

    @Override
	public ResourceLocator getPluginResourceLocator() {
        return plugin;
    }


    	/**
    	 * The cached debug options (for optimization).
    	 */
    	private static final Map<String, Boolean> cachedOptions =
    		new HashMap<String, Boolean>();

    	/**
    	 * Retrieves a Boolean value indicating whether tracing is enabled.

    			Boolean value = null;
    			
    			synchronized (cachedOptions) {
    				value = cachedOptions.get(option);
    	
    				if (null == value) {
    					value =

    	 */
    	public static void changing(
            String option,
            Class<?> clazz,
            String methodName,
            String valueDescription,
            Object oldValue,

    	 */
    	public static void catching(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Throwable throwable) {


    	 */
    	public static void throwing(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Throwable throwable) {


    	 */
    	public static void entering(
    		String option,
    		Class<?> clazz,
    		String methodName) {

    		if (shouldTrace(option)) {

    	 */
    	public static void entering(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Object parameter) {


    	 */
    	public static void entering(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Object[] parameters) {


    	 */
    	public static void exiting(
    		String option,
    		Class<?> clazz,
    		String methodName) {

    		if (shouldTrace(option)) {

    	 */
    	public static void exiting(
    		String option,
    		Class<?> clazz,
    		String methodName,
    		Object returnValue) {





import java.text.MessageFormat;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;


import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.emf.validation.model.EvaluationMode;
import org.eclipse.emf.validation.model.IConstraintStatus;
import org.eclipse.emf.validation.service.IValidationListener;
import org.eclipse.emf.validation.service.ValidationEvent;
import org.eclipse.emf.validation.ui.internal.console.ConsoleUtil;

	private static final String EP_UI_REGISTERED_CLIENT_CONTEXTS = "org.eclipse.emf.validation.ui.UIRegisteredClientContext"; //$NON-NLS-1$
	private static final String A_ID = "id"; //$NON-NLS-1$
	
	private static SoftReference<Set<String>> registeredClientContextIds = null;
	
    /**
     * Helper object for creating message to output view.

	 *  
	 * @return true if there is a supported client context in the collection, false otherwise
	 */
    private synchronized static boolean isSupportedClientContexts(
    		Collection<String> clientContextIds) {
		Set<String> registeredIds = registeredClientContextIds != null
			? registeredClientContextIds.get() : null;
			
    	if (registeredIds == null) {
    		registeredIds = new HashSet<String>();
			registeredClientContextIds = new SoftReference<Set<String>>(registeredIds);
			
			IExtensionPoint point = Platform.getExtensionRegistry().getExtensionPoint(EP_UI_REGISTERED_CLIENT_CONTEXTS);
			IExtension[] extensions = point.getExtensions();
			
			for (IExtension element : extensions) {
				IConfigurationElement[] elements = element.getConfigurationElements();
				
				for (IConfigurationElement element2 : elements) {
					registeredIds.add(element2.getAttribute(A_ID));
				}
			}
		}
    	
    	for (String next : clientContextIds) {
    		if (registeredIds.contains(next)) {
    			return true;
    		}
    	}

     */
    private void showProblemMessages(ValidationEvent event) {
    	// The workbench must be running in order for us to display anything to the user
    	if (!PlatformUI.isWorkbenchRunning()) {
			return;
		}
    	
        final ValidationLiveProblemsDestination destination =
        	ValidationLiveProblemsDestination.getPreferenceSetting();

					 * Redefines the inherited method to always return
					 * the more appropriate severity for the dialog.
					 */
					@Override
					public int getSeverity() {
						return dialogSeverity;
					}};

     *     first in the array if none is found
     */
    static IStatus getFirstStatus(IStatus[] statuses, int severity) {
    	for (IStatus element : statuses) {
			if (element.matches(severity)) {
				return element;
			}
		}
    	

     * @return its validation results, as a status array
     */
    private static IStatus[] toStatusArray(ValidationEvent event) {
    	List<IConstraintStatus> results = event.getValidationResults();
    	
    	return results.toArray(new IStatus[results.size()]);
    		new IStatus[results.size()]);
    }

    /**

        private void appendProblemsRecursive(
            IStatus[] statuses,
            StringBuffer output) {
            for (IStatus next : statuses) {
                IStatus next = statuses[i];

                if (!next.isOK()) {
                    final String messagePattern;


		 * @param composite The composite to parent from.
		 * @return <code>composite</code>
		 */
		@Override
		protected Control createDialogArea(Composite composite) {
			Composite result;
            


				checkbox.addSelectionListener(new SelectionAdapter() {

					@Override
					public void widgetSelected(SelectionEvent e) {
						// toggle the preference setting for display of live
						//   warnings according to user's selection

Lines 24-28 Link Here

(-)build.properties (-2 / +2 lines)
24	plugin.properties,\	24	plugin.properties,\
25	icons/,\	25	icons/,\
26	about.html	26	about.html
27	javacSource = 1.4	27	javacSource = 1.5
28	javacTarget = 1.4	28	javacTarget = 1.5

Lines 1-7 Link Here

(-).classpath (-1 / +1 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<classpath>	2	<classpath>
3	<classpathentry kind="src" path="src"/>	3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/>	4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>	5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
6	<classpathentry kind="output" path="bin"/>	6	<classpathentry kind="output" path="bin"/>
7	</classpath>	7	</classpath>




/**
 * <copyright>
 *
 * Copyright (c) 2004, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

public class ConsoleUtil {
	
	/** cache for console name to actual console object mapping*/
	private static Map<String, MessageConsole> nameToConsole =
		new HashMap<String, MessageConsole>();
	
	/** cache for 'console name' to 'default streams for error, warining and info for that console' mapping */
	private static Map<String, MessageConsoleStream> nameToDefaultStream =
		new HashMap<String, MessageConsoleStream>();
	
	
	// Strings for error, info, warning and default message types

			nameToConsole.put(name, console );
		}
		
		return nameToConsole.get( name);
	}
	
	

	 */
	public static void unregisterConsole(String name){		
		if(nameToConsole.containsKey( name)){		
			ConsolePlugin.getDefault().getConsoleManager().removeConsoles(
				new IConsole[]{nameToConsole.get(name)});
			nameToConsole.remove( name);
			nameToDefaultStream.remove(name+ERROR );
			nameToDefaultStream.remove(name+INFO );

			
		}
		
		return nameToDefaultStream.get(name+type);
		
	}
	




		 * @param constraint the constraint meta-data
		 */
		private void setDetails(IConstraintNode constraint) {
			// lots of style info
			List<StyleRange> styles = new java.util.ArrayList<StyleRange>(32);
			String text = ConstraintDetailsHelper.formatConstraintDescription(
					constraint,
					getCurrentCategorySelection(),

		
			getDetailsArea().setText(text);
			getDetailsArea().setStyleRanges(
					styles.toArray(new StyleRange[styles.size()]));
		}
	}
	

				ValidationUIPlugin.getImageDescriptor(LOCK_ICON).createImage(
						true);
			
			@Override
			public void dispose() {
				lockImage.dispose();
				super.dispose();
			}

			@Override
			public Image getImage(Object element) {
				ICategoryTreeNode node = (ICategoryTreeNode)element;
				

						true);
			
			// extends the inherited method
			@Override
			public void dispose() {
				lockImage.dispose();
				super.dispose();
			}

			// redefines the inherited method
			@Override
			public Image getImage(Object element) {
				IConstraintNode constraint = (IConstraintNode) element;
				

			}
			
			// redefines the inherited method
			@Override
			public String getText(Object element) {
				return ((IConstraintNode)element).getName();
			}});

	}
	
	private void markEnabledCategories(ICategoryTreeNode[] categories) {
		for (ICategoryTreeNode next : categories) {
			ICategoryTreeNode next = categories[i];
			
			getCategoryTree().setChecked(
				next,
				next.isChecked());




Bundle-ManifestVersion: 2
Bundle-Name: %Plugin.name
Bundle-SymbolicName: org.eclipse.emf.validation.ui; singleton:=true
Bundle-Version: 1.2.0.qualifier
Bundle-Activator: org.eclipse.emf.validation.ui.internal.ValidationUIPlugin$Implementation
Bundle-Vendor: %Plugin.providerName
Bundle-Localization: plugin

 org.eclipse.emf.validation.ui.internal.l10n;x-internal:=true,
 org.eclipse.emf.validation.ui.internal.preferences;x-internal:=true,
 org.eclipse.emf.validation.ui.preferences
Require-Bundle: org.eclipse.emf.validation;bundle-version="[1.2.0,2.0.0)",
 org.eclipse.ui;bundle-version="[3.2.0,4.0.0)",
 org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
 com.ibm.icu;bundle-version="[3.4.3,4.0.0)",
 org.eclipse.ui.console;bundle-version="[3.1.100,4.0.0)"
Eclipse-LazyStart: true
Bundle-RequiredExecutionEnvironment: J2SE-1.5




<feature
      id="org.eclipse.emf.validation.ocl"
      label="%featureName"
      version="1.2.0.qualifier"
      provider-name="%providerName"
      image="modeling32.png">


   </url>

   <requires>
      <import plugin="org.eclipse.emf.validation" version="1.0.0" match="compatible"/>
      <import plugin="org.eclipse.emf.ocl" version="1.0.0" match="compatible"/>
      <import plugin="org.eclipse.core.runtime" version="3.2.0" match="compatible"/>
      <import plugin="org.eclipse.emf.validation" version="1.2.0" match="compatible"/>
      <import plugin="org.eclipse.ocl" version="1.1.0" match="compatible"/>
      <import plugin="org.eclipse.ocl.ecore" version="1.1.0" match="compatible"/>
   </requires>

   <plugin

Lines 1-7 Link Here

(-).classpath (-1 / +1 lines)
1	<?xml version="1.0" encoding="UTF-8"?>	1	<?xml version="1.0" encoding="UTF-8"?>
2	<classpath>	2	<classpath>
3	<classpathentry kind="src" path="src"/>	3	<classpathentry kind="src" path="src"/>
4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.4"/>	4	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>	5	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
6	<classpathentry kind="output" path="bin"/>	6	<classpathentry kind="output" path="bin"/>
7	</classpath>	7	</classpath>

Lines 20-24 Link Here

(-)build.properties (-2 / +2 lines)
20	.,\	20	.,\
21	about.html	21	about.html
22	src.includes = about.html	22	src.includes = about.html
23	javacSource = 1.4	23	javacSource = 1.5
24	javacTarget = 1.4	24	javacTarget = 1.5




	/* (non-Javadoc)
	 * @see org.eclipse.emf.validation.AbstractModelConstraint#validate(org.eclipse.emf.validation.IValidationContext)
	 */
	@Override
	public IStatus validate(IValidationContext ctx) {
		EObject eObj = ctx.getTarget();
		EMFEventType eType = ctx.getEventType();

			}
			
			if (name == null || name.length() == 0) {
				return ctx.createFailureStatus(eObj.eClass().getName());
			}
		// In the case of live mode.
		} else {

			
			if (newValue == null
				|| ((String)newValue).length() == 0) {
				return ctx.createFailureStatus(eObj.eClass().getName());
			}
		}
		




import org.eclipse.core.runtime.IStatus;
import org.eclipse.emf.validation.examples.general.console.ConsoleUtil;
import org.eclipse.emf.validation.examples.general.internal.l10n.ValidationMessages;
import org.eclipse.emf.validation.model.IConstraintStatus;
import org.eclipse.emf.validation.service.IValidationListener;
import org.eclipse.emf.validation.service.ValidationEvent;
import org.eclipse.osgi.util.NLS;

	    private void appendProblemsRecursive(
	        IStatus[] statuses,
	        StringBuffer output) {
	        for (IStatus next : statuses) {
	            IStatus next = statuses[i];
	
	            if (!next.isOK()) {
	                final String messagePattern;
	

     * @return its validation results, as a status array
     */
    private static IStatus[] toStatusArray(ValidationEvent event) {
    	List<IConstraintStatus> results = event.getValidationResults();
    	
    	return results.toArray(new IStatus[results.size()]);
    		new IStatus[results.size()]);
    }    	
}




/**
 * <copyright>
 *
 * Copyright (c) 2004, 2007 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

public class ConsoleUtil {
	
	/** cache for console name to actual console object mapping*/
	private static Map<String, MessageConsole> nameToConsole =
		new HashMap<String, MessageConsole>();
	
	/** cache for 'console name' to 'default streams for error, warning and info for that console' mapping */
	private static Map<String, MessageConsoleStream> nameToDefaultStream =
		new HashMap<String, MessageConsoleStream>();
	
	
	// Strings for error, info, warning and default message types

		if(nameToConsole.get(name) == null){	
			
			MessageConsole console = new MessageConsole(name,image);
			ConsolePlugin.getDefault().getConsoleManager().addConsoles(
				new IConsole[]{console});			
			
			nameToConsole.put(name, console);
		}
		
		return nameToConsole.get(name);
	}
	
	

	 */
	public static void unregisterConsole(String name){		
		if(nameToConsole.containsKey( name)){		
			ConsolePlugin.getDefault().getConsoleManager().removeConsoles(
				new IConsole[]{nameToConsole.get(name)});
			nameToConsole.remove( name);
			nameToDefaultStream.remove(name+ERROR );
			nameToDefaultStream.remove(name+INFO );

			
		}
		
		return nameToDefaultStream.get(name+type);
		
	}
	

Lines 1-8 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-5 / +5 lines)
1	#Wed Dec 20 11:46:50 EST 2006	1	#Tue Oct 30 22:16:49 EDT 2007
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled	3	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.4	4	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
5	org.eclipse.jdt.core.compiler.compliance=1.4	5	org.eclipse.jdt.core.compiler.compliance=1.5
6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error	6	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=warning	7	org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
8	org.eclipse.jdt.core.compiler.source=1.4	8	org.eclipse.jdt.core.compiler.source=1.5




package org.eclipse.emf.validation.examples.general.actions;

import java.util.Collection;
import org.eclipse.emf.common.notify.Adapter;

import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.util.EContentAdapter;
import org.eclipse.emf.examples.extlibrary.presentation.EXTLibraryEditor;

	/**
	 * Selected EObjects
	 */
	protected Collection<Resource> selectedResources = null;

	String title = ValidationMessages.EnableLiveValidationDelegate_title;


	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction,
	 *      org.eclipse.jface.viewers.ISelection)
	 */
	@SuppressWarnings("unchecked")
	public void selectionChanged(IAction action, final ISelection selection) {
		this.selectedResources = null;
		try {
			if (selection instanceof IStructuredSelection) {
				IStructuredSelection structuredSelection = (IStructuredSelection) selection;
				
				Collection<?> selectedHunh = structuredSelection.toList();
				
				for (Object next : selectedHunh) {
					if (!(next instanceof Resource)) {
						action.setEnabled(false);
					} else if (resourceHasAdapter((Resource) next)) {
						action.setEnabled(false);
					}
				}
				
				if (action.isEnabled()) {
					this.selectedResources = (Collection<Resource>) selectedHunh;
				} else {
					this.selectedResources = null;
				}
			}
		} catch (Exception e) {
			// Exceptions are not expected
			MessageDialog.openInformation(shell, title, MESSAGE_EXCEPTION);
			throw new RuntimeException(e);
		} finally {
			action.setEnabled((null != selectedResources));
		}
		
		for (Iterator i = selectedEObjects.iterator(); i.hasNext();) {
			Object o = i.next();
			if (!(o instanceof Resource)) {
				action.setEnabled(false);
			} else if (resourceHasAdapter((Resource)o)) {
				action.setEnabled(false);
			}
		}
	}


	 * @see org.eclipse.ui.IActionDelegate#run(org.eclipse.jface.action.IAction)
	 */
	public void run(IAction action) {
		for (Resource r : selectedResources) {
			Resource r = (Resource)i.next();
			
			if (!resourceHasAdapter(r)) {
				EContentAdapter liveValidationContentAdapter = new LiveValidationContentAdapter(this);
				r.eAdapters().add(liveValidationContentAdapter);

	}
	
	private boolean resourceHasAdapter(Resource r) {
		for (Adapter next : r.eAdapters()) {
			if (next instanceof LiveValidationContentAdapter) {
			Object o = j.next();
			if (o instanceof LiveValidationContentAdapter) {
				return true;
			}
		}





import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IActionDelegate2;

	/**
	 * Selected EObjects
	 */
	protected Collection<EObject> selectedEObjects = null;

	/**
	 * The InputDialog title
	 */
	private final String title = ValidationMessages.BatchValidationDelegate_title;

	/*
	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction,
	 *      org.eclipse.jface.viewers.ISelection)
	 */
	@SuppressWarnings("unchecked")
	public void selectionChanged(IAction action, final ISelection selection) {
		this.selectedEObjects = null;
		try {
			if (selection instanceof IStructuredSelection) {
				IStructuredSelection structuredSelection = (IStructuredSelection) selection;
				
				Collection<?> selectedHunh = structuredSelection.toList();
				for (Object next : selectedHunh) {
					if (!(next instanceof EObject)) {
						action.setEnabled(false);
					}
				}
				
				if (action.isEnabled()) {
					this.selectedEObjects = (Collection<EObject>) selectedHunh;
				} else {
					this.selectedEObjects = null;
				}
			}
		} catch (Exception e) {
			// Exceptions are not expected

			action.setEnabled((null != selectedEObjects));
		}
		
		for (Iterator i = selectedEObjects.iterator(); i.hasNext();) {
			if (!(i.next() instanceof EObject)) {
				action.setEnabled(false);
			}
		}
	}

	/*

	public void run(IAction action) {
		ValidationDelegateClientSelector.running = true;
		
		IBatchValidator validator = ModelValidationService.getInstance()
			.newValidator(EvaluationMode.BATCH);
		validator.setIncludeLiveConstraints(true);
		

				}
			});
			dialog.setLabelProvider(new LabelProvider() {
				@Override
				public String getText(Object element) {
					if (element instanceof IStatus) {
						return ((IStatus)element).getMessage();

			dialog.setBlockOnOpen(true);
			dialog.setMessage(ValidationMessages.BatchValidationDelegate_errorMessage);
			
			if (Window.OK == dialog.open()) {
				Set<EObject> errorSelections = new HashSet<EObject>();
				if (!status.isMultiStatus()) {
					IConstraintStatus cstatus = (IConstraintStatus)status;
					errorSelections.add(cstatus.getTarget());
				} else {
					IStatus[] children = status.getChildren();
					for (IStatus element : children) {
						IConstraintStatus cstatus = (IConstraintStatus)element;
						errorSelections.add(cstatus.getTarget());
					}
				}




	/* (non-Javadoc)
	 * @see org.eclipse.emf.ecore.util.EContentAdapter#notifyChanged(org.eclipse.emf.common.notify.Notification)
	 */
	@Override
	public void notifyChanged(final Notification notification) {
		super.notifyChanged(notification);
		
		actionDelegate.shell.getDisplay().asyncExec(new Runnable() {
			public void run() {
				if (validator == null) {
					validator = ModelValidationService.getInstance().newValidator(
						EvaluationMode.LIVE);
				}
				
				ValidationDelegateClientSelector.running = true;




Bundle-ManifestVersion: 2
Bundle-Name: %Plugin.name
Bundle-SymbolicName: org.eclipse.emf.validation.examples.general; singleton:=true
Bundle-Version: 1.2.0.qualifier
Bundle-Activator: org.eclipse.emf.validation.examples.general.ValidationPlugin
Bundle-Vendor: %Plugin.providerName
Bundle-Localization: plugin

 org.eclipse.emf.validation.examples.general.listeners
Require-Bundle: org.eclipse.ui;bundle-version="[3.2.0,4.0.0)",
 org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
 org.eclipse.emf.validation;bundle-version="[1.2.0,2.0.0)",
 org.eclipse.emf.examples.library;bundle-version="[2.3.0,3.0.0)",
 org.eclipse.emf.examples.library.edit;bundle-version="[2.3.0,3.0.0)",
 org.eclipse.emf.examples.library.editor;bundle-version="[2.3.0,3.0.0)",
 org.eclipse.ui.console;bundle-version="[3.1.100,4.0.0)",
 org.eclipse.emf.validation.ui;bundle-version="[1.2.0,2.0.0)"
Eclipse-LazyStart: true
Bundle-RequiredExecutionEnvironment: J2SE-1.5

Lines 44-57 Link Here

(-)feature.xml (-5 / +10 lines)
44	</url>	44	</url>
45		45
46	<requires>	46	<requires>
		47	<import plugin="org.junit" version="3.8.1" match="compatible"/>
		48	<import plugin="org.eclipse.ui" version="3.2.0" match="compatible"/>
		49	<import plugin="org.eclipse.core.runtime" version="3.2.0" match="compatible"/>
47	<import plugin="org.eclipse.core.expressions" version="3.2.0" match="compatible"/>	50	<import plugin="org.eclipse.core.expressions" version="3.2.0" match="compatible"/>
48	<import plugin="org.eclipse.emf.ecore" version="2.2.0" match="compatible"/>	51	<import plugin="org.eclipse.emf.ecore" version="2.2.0" match="compatible"/>
49	<import plugin="org.junit" version="3.8.1" match="compatible"/>
50	<import plugin="org.eclipse.emf.ecore.xmi" version="2.2.0" match="compatible"/>	52	<import plugin="org.eclipse.emf.ecore.xmi" version="2.2.0" match="compatible"/>
51	<import plugin="org.eclipse.core.runtime" version="3.2.0" match="compatible"/>	53	<import plugin="org.apache.ant"/>
52	<import plugin="org.eclipse.emf.validation.ui" version="1.0.1" match="greaterOrEqual"/>	54	<import plugin="org.eclipse.ui.ide.application"/>
53	<import plugin="org.eclipse.ui" version="3.2.0" match="compatible"/>	55	<import plugin="org.eclipse.equinox.app"/>
54	<import plugin="org.eclipse.emf.validation" version="1.1.1" match="greaterOrEqual"/>	56	<import plugin="org.apache.ant" version="1.4.1" match="compatible"/>
		57	<import plugin="org.eclipse.emf.validation" version="1.2.0" match="greaterOrEqual"/>
		58	<import plugin="org.eclipse.core.resources" version="3.2.0" match="compatible"/>
		59	<import plugin="org.eclipse.emf.validation.ui" version="1.1.100" match="greaterOrEqual"/>
55	</requires>	60	</requires>
56		61
57	<plugin	62	<plugin

Return to bug 206808

Lines 18-24 Link Here

(-)feature.xml (-6 / +8 lines)
18	<feature	18	<feature
19	id="org.eclipse.emf.validation.examples"	19	id="org.eclipse.emf.validation.examples"
20	label="%featureName"	20	label="%featureName"
21	version="1.1.100.qualifier"	21	version="1.2.0.qualifier"
22	provider-name="%providerName"	22	provider-name="%providerName"
23	image="modeling32.png">	23	image="modeling32.png">
24		24
Lines 52-64 Link Here
52	<import plugin="org.eclipse.core.runtime" version="3.2.0" match="compatible"/>	52	<import plugin="org.eclipse.core.runtime" version="3.2.0" match="compatible"/>
53	<import plugin="org.eclipse.core.resources" version="3.2.0" match="compatible"/>	53	<import plugin="org.eclipse.core.resources" version="3.2.0" match="compatible"/>
54	<import plugin="org.eclipse.ui.ide" version="3.2.0" match="compatible"/>	54	<import plugin="org.eclipse.ui.ide" version="3.2.0" match="compatible"/>
55	<import plugin="org.eclipse.emf.validation" version="1.0.0" match="compatible"/>
56	<import plugin="org.eclipse.emf.examples.library" version="2.2.0" match="compatible"/>
57	<import plugin="org.eclipse.emf.examples.library.edit" version="2.2.0" match="compatible"/>
58	<import plugin="org.eclipse.emf.examples.library.editor" version="2.2.0" match="compatible"/>
59	<import plugin="org.eclipse.ui.console" version="3.1.100" match="compatible"/>	55	<import plugin="org.eclipse.ui.console" version="3.1.100" match="compatible"/>
60	<import plugin="org.eclipse.emf.validation.ui" version="1.0.0" match="compatible"/>
61	<import plugin="org.eclipse.core.expressions" version="3.2.0" match="compatible"/>	56	<import plugin="org.eclipse.core.expressions" version="3.2.0" match="compatible"/>
		57	<import plugin="org.eclipse.emf.validation" version="1.2.0" match="compatible"/>
		58	<import plugin="org.eclipse.emf.examples.library" version="2.3.0" match="compatible"/>
		59	<import plugin="org.eclipse.emf.examples.library.edit" version="2.3.0" match="compatible"/>
		60	<import plugin="org.eclipse.emf.examples.library.editor" version="2.3.0" match="compatible"/>
		61	<import plugin="org.eclipse.emf.validation.ui" version="1.2.0" match="compatible"/>
		62	<import plugin="org.eclipse.emf.validation.ocl" version="1.1.0" match="compatible"/>
		63	<import plugin="org.eclipse.ocl.ecore" version="1.1.0" match="compatible"/>
62	</requires>	64	</requires>
63		65
64	<plugin	66	<plugin

Lines 111-118 Link Here

(-)src/org/eclipse/emf/validation/ocl/AbstractOCLModelConstraint.java (-2 / +4 lines)
111	* @deprecated Override the {@link #createOCLEnvironmentFactory()} method,	111	* @deprecated Override the {@link #createOCLEnvironmentFactory()} method,
112	* instead.	112	* instead.
113	*/	113	*/
		114	@Deprecated
114	protected org.eclipse.emf.ocl.parser.EnvironmentFactory createEnvironmentFactory() {	115	protected org.eclipse.emf.ocl.parser.EnvironmentFactory createEnvironmentFactory() {
115	return org.eclipse.emf.ocl.parser.EcoreEnvironmentFactory.ECORE_INSTANCE;	116	return org.eclipse.emf.ocl.parser.EnvironmentFactory.ECORE_INSTANCE;
116	}	117	}
117		118
118		119
Lines 165-170 Link Here
165	*	166	*
166	* @deprecated Use the {@link #getConstraintCondition(EObject)} method, instead.	167	* @deprecated Use the {@link #getConstraintCondition(EObject)} method, instead.
167	*/	168	*/
		169	@Deprecated
168	public org.eclipse.emf.ocl.query.Query getCondition(EClass eClass) {	170	public org.eclipse.emf.ocl.query.Query getCondition(EClass eClass) {
169	org.eclipse.emf.ocl.query.Query result = null;	171	org.eclipse.emf.ocl.query.Query result = null;
170		172
Lines 209-215 Link Here
209	// variable and result locus, as OCL has no way to provide	211	// variable and result locus, as OCL has no way to provide
210	// additional extractions. Also, there is no way for the OCL	212	// additional extractions. Also, there is no way for the OCL
211	// to access the context object	213	// to access the context object
212	return ctx.createFailureStatus(new Object[]{target});	214	return ctx.createFailureStatus(target);
213	}	215	}
214	}	216	}
215		217

Lines 20-33 Link Here

(-)src/org/eclipse/emf/validation/internal/service/IProviderOperationExecutor.java (-2 / +4 lines)
20	* implementations in this package to execute operations	20	* implementations in this package to execute operations
21	* in the context of the object that created them.	21	* in the context of the object that created them.
22	*	22	*
		23	* @param <T> the result type of the operation that I execute
		24	*
23	* @author Christian W. Damus (cdamus)	25	* @author Christian W. Damus (cdamus)
24	*/	26	*/
25	public interface IProviderOperationExecutor {	27	public interface IProviderOperationExecutor<T> {
26	/**	28	/**
27	* Executes the specified <code>op</code>eration.	29	* Executes the specified <code>op</code>eration.
28	*	30	*
29	* @param op the operation to execute. The execution result must be	31	* @param op the operation to execute. The execution result must be
30	* obtained from it	32	* obtained from it
31	*/	33	*/
32	void execute(IProviderOperation op);	34	void execute(IProviderOperation<? extends T> op);
33	}	35	}

Lines 64-73 Link Here

(-)src/org/eclipse/emf/validation/internal/service/ConstraintCache.java (-40 / +40 lines)
64	* weak map to avoid interfering with garbage-collection of EMF metamodels	64	* weak map to avoid interfering with garbage-collection of EMF metamodels
65	* (and to clean up the cache when metamodels disappear!).	65	* (and to clean up the cache when metamodels disappear!).
66	*/	66	*/
67	private final Map buckets = new java.util.WeakHashMap();	67	private final Map<EClass, EClassBucket> buckets =
		68	new java.util.WeakHashMap<EClass, EClassBucket>();
68		69
69	/** The cacheable providers. */	70	/** The cacheable providers. */
70	private final Collection providers = new java.util.ArrayList();	71	private final Collection<IProviderDescriptor> providers =
		72	new java.util.ArrayList<IProviderDescriptor>();
71		73
72	/**	74	/**
73	* A container for the constraints provided by all cacheable providers	75	* A container for the constraints provided by all cacheable providers
Lines 76-83 Link Here
76	* @author Christian W. Damus (cdamus)	78	* @author Christian W. Damus (cdamus)
77	*/	79	*/
78	private static class EClassBucket {	80	private static class EClassBucket {
79	private Collection batchConstraints;	81	private Collection<IModelConstraint> batchConstraints;
80	private final Map liveConstraints = new java.util.HashMap();	82	private final Map<EMFEventType, Map<String, Collection<IModelConstraint>>>
		83	liveConstraints = new java.util.HashMap<EMFEventType, Map<String, Collection<IModelConstraint>>>();
81		84
82	/**	85	/**
83	* Initializes me.	86	* Initializes me.
Lines 92-98 Link Here
92	* @return my batch constraints, or <code>null</code> if they have not	95	* @return my batch constraints, or <code>null</code> if they have not
93	* yet been retrieved from my registered providers	96	* yet been retrieved from my registered providers
94	*/	97	*/
95	Collection getBatchConstraints() {	98	Collection<IModelConstraint> getBatchConstraints() {
96	return batchConstraints;	99	return batchConstraints;
97	}	100	}
98		101
Lines 101-108 Link Here
101	*	104	*
102	* @param constraints the batch constraints	105	* @param constraints the batch constraints
103	*/	106	*/
104	void cacheBatchConstraints(Collection constraints) {	107	void cacheBatchConstraints(Collection<IModelConstraint> constraints) {
105	batchConstraints = new java.util.ArrayList(constraints);	108	batchConstraints = new java.util.ArrayList<IModelConstraint>(constraints);
106	}	109	}
107		110
108	/**	111	/**
Lines 116-130 Link Here
116	* @return the corresponding constraints, or <code>null</code> if they	119	* @return the corresponding constraints, or <code>null</code> if they
117	* have not yet been retrieved from my registered providers	120	* have not yet been retrieved from my registered providers
118	*/	121	*/
119	Collection getLiveConstraints(EMFEventType eventType, String featureName) {	122	Collection<IModelConstraint> getLiveConstraints(EMFEventType eventType, String featureName) {
120	if (featureName == null) {	123	if (featureName == null) {
121	featureName = NOT_A_FEATURE_NAME;	124	featureName = NOT_A_FEATURE_NAME;
122	}	125	}
123		126
124	Map constraintMap = (Map)liveConstraints.get(eventType);	127	Map<String, Collection<IModelConstraint>> constraintMap =
		128	liveConstraints.get(eventType);
125		129
126	if (constraintMap != null) {	130	if (constraintMap != null) {
127	return (Collection)constraintMap.get(featureName);	131	return constraintMap.get(featureName);
128	} else {	132	} else {
129	return null;	133	return null;
130	}	134	}
Lines 143-164 Link Here
143	void cacheLiveConstraints(	147	void cacheLiveConstraints(
144	EMFEventType eventType,	148	EMFEventType eventType,
145	String featureName,	149	String featureName,
146	Collection constraints) {	150	Collection<IModelConstraint> constraints) {
147		151
148	if (featureName == null) {	152	if (featureName == null) {
149	featureName = NOT_A_FEATURE_NAME;	153	featureName = NOT_A_FEATURE_NAME;
150	}	154	}
151		155
152	Map constraintMap = (Map)liveConstraints.get(eventType);	156	Map<String, Collection<IModelConstraint>> constraintMap =
		157	liveConstraints.get(eventType);
153		158
154	if (constraintMap == null) {	159	if (constraintMap == null) {
155	constraintMap = new java.util.HashMap();	160	constraintMap = new java.util.HashMap<String, Collection<IModelConstraint>>();
156	liveConstraints.put(eventType, constraintMap);	161	liveConstraints.put(eventType, constraintMap);
157	}	162	}
158		163
159	constraintMap.put(	164	constraintMap.put(
160	featureName,	165	featureName,
161	new java.util.ArrayList(constraints));	166	new java.util.ArrayList<IModelConstraint>(constraints));
162	}	167	}
163		168
164	/**	169	/**
Lines 175-186 Link Here
175	}	180	}
176		181
177	// replace in the live constraints, if appropriate	182	// replace in the live constraints, if appropriate
178	for (Iterator iter = liveConstraints.values().iterator(); iter.hasNext();) {	183	for (Map<String, Collection<IModelConstraint>> next : liveConstraints.values()) {
179	Map next = (Map) iter.next();	184	for (Collection<IModelConstraint> constraints : next.values()) {
180
181	for (Iterator nested = next.values().iterator(); nested.hasNext();) {
182	Collection constraints = (Collection) nested.next();
183
184	if ((constraints != null) && constraints.remove(oldConstraint)) {	185	if ((constraints != null) && constraints.remove(oldConstraint)) {
185	constraints.add(newConstraint);	186	constraints.add(newConstraint);
186	}	187	}
Lines 204-210 Link Here
204	public IProviderDescriptor getDescriptor() {	205	public IProviderDescriptor getDescriptor() {
205	return new IProviderDescriptor() {	206	return new IProviderDescriptor() {
206	// the cache is assumed to always have an answer	207	// the cache is assumed to always have an answer
207	public boolean provides(IProviderOperation operation) {	208	public boolean provides(
		209	IProviderOperation<? extends Collection<? extends IModelConstraint>> operation) {
208	return true;	210	return true;
209	}	211	}
210		212
Lines 234-240 Link Here
234	*	236	*
235	* @return the cached providers	237	* @return the cached providers
236	*/	238	*/
237	public Collection getProviders() {	239	public Collection<IProviderDescriptor> getProviders() {
238	return providers;	240	return providers;
239	}	241	}
240		242
Lines 258-264 Link Here
258	* @return the corresponding bucket	260	* @return the corresponding bucket
259	*/	261	*/
260	private EClassBucket getBucket(EClass clazz) {	262	private EClassBucket getBucket(EClass clazz) {
261	EClassBucket result = (EClassBucket)buckets.get(clazz);	263	EClassBucket result = buckets.get(clazz);
262		264
263	if (result == null) {	265	if (result == null) {
264	result = new EClassBucket();	266	result = new EClassBucket();
Lines 274-283 Link Here
274	* @param operation the operation to execute	276	* @param operation the operation to execute
275	* @return the constraints retrieved by the operation	277	* @return the constraints retrieved by the operation
276	*/	278	*/
277	private Collection execute(AbstractGetConstraintsOperation operation) {	279	private Collection<IModelConstraint> execute(AbstractGetConstraintsOperation operation) {
278	for (Iterator iter = getProviders().iterator(); iter.hasNext(); ) {	280	for (Iterator<IProviderDescriptor> iter = getProviders().iterator(); iter.hasNext(); ) {
279	IProviderDescriptor next =	281	IProviderDescriptor next = iter.next();
280	(IProviderDescriptor)iter.next();
281		282
282	if (next.provides(operation)) {	283	if (next.provides(operation)) {
283	try {	284	try {
Lines 298-313 Link Here
298	}	299	}
299		300
300	// implements the interface method	301	// implements the interface method
301	public Collection getLiveConstraints(	302	public Collection<IModelConstraint> getLiveConstraints(
302	Notification notification,	303	Notification notification,
303	Collection constraints) {	304	Collection<IModelConstraint> constraints) {
304		305
305	assert notification != null;	306	assert notification != null;
306		307
307	Collection result = constraints;	308	Collection<IModelConstraint> result = constraints;
308		309
309	if (result == null) {	310	if (result == null) {
310	result = new java.util.ArrayList();	311	result = new java.util.ArrayList<IModelConstraint>();
311	}	312	}
312		313
313	if (notification.getNotifier() instanceof EObject) {	314	if (notification.getNotifier() instanceof EObject) {
Lines 322-328 Link Here
322	}	323	}
323		324
324	EClassBucket bucket = getBucket(eObject.eClass());	325	EClassBucket bucket = getBucket(eObject.eClass());
325	Collection cached = bucket.getLiveConstraints(eventType, featureName);	326	Collection<IModelConstraint> cached = bucket.getLiveConstraints(
		327	eventType, featureName);
326		328
327	if (cached == null) {	329	if (cached == null) {
328	if (Trace.shouldTrace(EMFModelValidationDebugOptions.CACHE)) {	330	if (Trace.shouldTrace(EMFModelValidationDebugOptions.CACHE)) {
Lines 354-371 Link Here
354	}	356	}
355		357
356	// implements the interface method	358	// implements the interface method
357	public Collection getBatchConstraints(	359	public Collection<IModelConstraint> getBatchConstraints(
358	EObject eObject,	360	EObject eObject,
359	Collection constraints) {	361	Collection<IModelConstraint> constraints) {
360		362
361	Collection result = constraints;	363	Collection<IModelConstraint> result = constraints;
362		364
363	if (result == null) {	365	if (result == null) {
364	result = new java.util.ArrayList();	366	result = new java.util.ArrayList<IModelConstraint>();
365	}	367	}
366		368
367	EClassBucket bucket = getBucket(eObject.eClass());	369	EClassBucket bucket = getBucket(eObject.eClass());
368	Collection cached = bucket.getBatchConstraints();	370	Collection<IModelConstraint> cached = bucket.getBatchConstraints();
369	if (cached == null) {	371	if (cached == null) {
370	if (Trace.shouldTrace(EMFModelValidationDebugOptions.CACHE)) {	372	if (Trace.shouldTrace(EMFModelValidationDebugOptions.CACHE)) {
371	Trace.trace(	373	Trace.trace(
Lines 440-448 Link Here
440		442
441	// ask each bucket to replace the old constraint with the new, if	443	// ask each bucket to replace the old constraint with the new, if
442	// that constraint is in that bucket	444	// that constraint is in that bucket
443	for (Iterator iter = buckets.values().iterator(); iter.hasNext();) {	445	for (EClassBucket next : buckets.values()) {
444	EClassBucket next = (EClassBucket) iter.next();
445
446	next.replace(oldConstraint, newConstraint);	446	next.replace(oldConstraint, newConstraint);
447	}	447	}
448	}	448	}

Lines 52-58 Link Here

(-)src/org/eclipse/emf/validation/internal/service/TraversalStrategyManager.java (-29 / +34 lines)
52	private static final TraversalStrategyManager INSTANCE =	52	private static final TraversalStrategyManager INSTANCE =
53	new TraversalStrategyManager();	53	new TraversalStrategyManager();
54		54
55	private final Map packageDescriptors = new java.util.HashMap();	55	private final Map<String, Descriptor> packageDescriptors =
		56	new java.util.HashMap<String, Descriptor>();
56		57
57	/**	58	/**
58	* Not instantiated by clients.	59	* Not instantiated by clients.
Lines 144-150 Link Here
144	* @return the corresponding descriptor	145	* @return the corresponding descriptor
145	*/	146	*/
146	private Descriptor getDescriptor(String nsUri) {	147	private Descriptor getDescriptor(String nsUri) {
147	Descriptor result = (Descriptor)packageDescriptors.get(nsUri);	148	Descriptor result = packageDescriptors.get(nsUri);
148		149
149	if (result == null) {	150	if (result == null) {
150	result = new Descriptor(nsUri);	151	result = new Descriptor(nsUri);
Lines 162-169 Link Here
162	*/	163	*/
163	private static class Descriptor {	164	private static class Descriptor {
164	private final String nsUri;	165	private final String nsUri;
165	private Map eclassMap = new java.util.HashMap();	166	private Map<Object, ThreadLocal<ITraversalStrategy>> eclassMap =
166	private ThreadLocalLazyStrategy packageDefaultStrategy;	167	new java.util.HashMap<Object, ThreadLocal<ITraversalStrategy>>();
		168	private ThreadLocal<ITraversalStrategy> packageDefaultStrategy;
167	private boolean isResolved;	169	private boolean isResolved;
168		170
169	/**	171	/**
Lines 188-201 Link Here
188	* Determines whether <code>other</code> is a descriptor for the	190	* Determines whether <code>other</code> is a descriptor for the
189	* same EPackage as me.	191	* same EPackage as me.
190	*/	192	*/
191	public boolean equals(Object other) {	193	@Override
		194	public boolean equals(Object other) {
192	return (other instanceof Descriptor) &&	195	return (other instanceof Descriptor) &&
193	getNamespaceUri().equals(	196	getNamespaceUri().equals(
194	((Descriptor)other).getNamespaceUri());	197	((Descriptor)other).getNamespaceUri());
195	}	198	}
196		199
197	// overrides the inherited implementation	200	// overrides the inherited implementation
198	public int hashCode() {	201	@Override
		202	public int hashCode() {
199	return getNamespaceUri().hashCode();	203	return getNamespaceUri().hashCode();
200	}	204	}
201		205
Lines 208-217 Link Here
208	*/	212	*/
209	void addTraversalStrategy(IConfigurationElement config) {	213	void addTraversalStrategy(IConfigurationElement config) {
210	IConfigurationElement[] eclasses = config.getChildren(E_ECLASS);	214	IConfigurationElement[] eclasses = config.getChildren(E_ECLASS);
		215
		216	ThreadLocal<ITraversalStrategy> strategy =
		217	new ThreadLocalLazyStrategy(config);
211		218
212	if ((eclasses.length == 0) && (packageDefaultStrategy == null)) {	219	if ((eclasses.length == 0) && (packageDefaultStrategy == null)) {
213	// can only have one wildcard strategy	220	// can only have one wildcard strategy
214	packageDefaultStrategy = new ThreadLocalLazyStrategy(config);	221	packageDefaultStrategy = strategy;
215	} else {	222	} else {
216	for (int i = 0; i < eclasses.length; i++) {	223	for (int i = 0; i < eclasses.length; i++) {
217	IConfigurationElement next = eclasses[i];	224	IConfigurationElement next = eclasses[i];
Lines 219-225 Link Here
219		226
220	if (!eclassMap.containsKey(eclassName)) {	227	if (!eclassMap.containsKey(eclassName)) {
221	// take the first one registered against a name	228	// take the first one registered against a name
222	eclassMap.put(eclassName, config);	229	eclassMap.put(eclassName, strategy);
223	}	230	}
224	}	231	}
225	}	232	}
Lines 234-249 Link Here
234	private void resolve(EPackage ePackage) {	241	private void resolve(EPackage ePackage) {
235	isResolved = true;	242	isResolved = true;
236		243
237	Map newMap = new java.util.HashMap();	244	Map<Object, ThreadLocal<ITraversalStrategy>> newMap =
		245	new java.util.HashMap<Object, ThreadLocal<ITraversalStrategy>>();
238		246
239	for (Iterator iter = eclassMap.entrySet().iterator(); iter.hasNext();) {	247	for (Map.Entry<Object, ThreadLocal<ITraversalStrategy>> next : eclassMap.entrySet()) {
240	Map.Entry next = (Map.Entry)iter.next();
241	String eclassName = (String)next.getKey();	248	String eclassName = (String)next.getKey();
242		249
243	EClassifier eclass = ePackage.getEClassifier(eclassName);	250	EClassifier eclass = ePackage.getEClassifier(eclassName);
244	if (eclass instanceof EClass) {	251	if (eclass instanceof EClass) {
245	newMap.put(eclass, new ThreadLocalLazyStrategy(	252	newMap.put(eclass, next.getValue());
246	(IConfigurationElement) next.getValue()));
247	} else {	253	} else {
248	// not a valid eclass	254	// not a valid eclass
249	Log.warningMessage(	255	Log.warningMessage(
Lines 274-287 Link Here
274	resolve(eclass.getEPackage());	280	resolve(eclass.getEPackage());
275	}	281	}
276		282
277	ThreadLocal strategy = (ThreadLocal) eclassMap.get(eclass);	283	ThreadLocal<ITraversalStrategy> strategy = eclassMap.get(eclass);
278		284
279	if (strategy == null) {	285	if (strategy == null) {
280	strategy = inheritStrategy(eclass);	286	strategy = inheritStrategy(eclass);
281	eclassMap.put(eclass, strategy);	287	eclassMap.put(eclass, strategy);
282	}	288	}
283		289
284	return (ITraversalStrategy) strategy.get();	290	return strategy.get();
285	}	291	}
286	}	292	}
287		293
Lines 295-302 Link Here
295	* @return the inherited strategy, or the package's default, if none	301	* @return the inherited strategy, or the package's default, if none
296	* better is found	302	* better is found
297	*/	303	*/
298	private ThreadLocal inheritStrategy(EClass eclass) {	304	private ThreadLocal<ITraversalStrategy> inheritStrategy(EClass eclass) {
299	ThreadLocal result = getInheritedStrategy(eclass);	305	ThreadLocal<ITraversalStrategy> result = getInheritedStrategy(eclass);
300		306
301	if (result == null) {	307	if (result == null) {
302	// use the wildcard strategy	308	// use the wildcard strategy
Lines 320-335 Link Here
320	* @return the inherited strategy, or <code>null</code> if none was	326	* @return the inherited strategy, or <code>null</code> if none was
321	* provided by any extension point	327	* provided by any extension point
322	*/	328	*/
323	private ThreadLocal getInheritedStrategy(EClass eclass) {	329	private ThreadLocal<ITraversalStrategy> getInheritedStrategy(EClass eclass) {
324	ThreadLocal result = null;	330	ThreadLocal<ITraversalStrategy> result = null;
325		331
326	for (Iterator iter = eclass.getESuperTypes().iterator();	332	for (Iterator<EClass> iter = eclass.getESuperTypes().iterator();
327	(result == null) && iter.hasNext();) {	333	(result == null) && iter.hasNext();) {
328		334
329	EClass next = (EClass)iter.next();	335	EClass next = iter.next();
330		336
331	if (eclassMap.containsKey(next)) {	337	if (eclassMap.containsKey(next)) {
332	result = (ThreadLocal) eclassMap.get(next);	338	result = eclassMap.get(next);
333	} else {	339	} else {
334	result = getInheritedStrategy(next);	340	result = getInheritedStrategy(next);
335	}	341	}
Lines 367-385 Link Here
367	// replace all ocurrences of the configuration element with the	373	// replace all ocurrences of the configuration element with the
368	// newly instantiated traversal strategy for future look-ups	374	// newly instantiated traversal strategy for future look-ups
369	if (packageDefaultStrategy != null) {	375	if (packageDefaultStrategy != null) {
370	packageDefaultStrategy.preinitialize(result, config);	376	((ThreadLocalLazyStrategy) packageDefaultStrategy).preinitialize(result, config);
371	}	377	}
372		378
373	for (Iterator iter = eclassMap.values().iterator(); iter.hasNext();) {	379	for (Object next : eclassMap.values()) {
374	ThreadLocalLazyStrategy next = (ThreadLocalLazyStrategy) iter.next();	380	((ThreadLocalLazyStrategy) next).preinitialize(result, config);
375
376	next.preinitialize(result, config);
377	}	381	}
378		382
379	return result;	383	return result;
380	}	384	}
381		385
382	private class ThreadLocalLazyStrategy extends ThreadLocal {	386	private class ThreadLocalLazyStrategy extends ThreadLocal<ITraversalStrategy> {
383	private final IConfigurationElement config;	387	private final IConfigurationElement config;
384		388
385	ThreadLocalLazyStrategy() {	389	ThreadLocalLazyStrategy() {
Lines 390-396 Link Here
390	this.config = config;	394	this.config = config;
391	}	395	}
392		396
393	protected Object initialValue() {	397	@Override
		398	protected ITraversalStrategy initialValue() {
394	return (config == null)? new ITraversalStrategy.Recursive() :	399	return (config == null)? new ITraversalStrategy.Recursive() :
395	initializeStrategy(config);	400	initializeStrategy(config);
396	}	401	}

Lines 51-60 Link Here

(-)src/org/eclipse/emf/validation/internal/service/ClientContextManager.java (-44 / +45 lines)
51		51
52	private static final ClientContextManager INSTANCE = new ClientContextManager();	52	private static final ClientContextManager INSTANCE = new ClientContextManager();
53		53
54	private final Set clientContexts = new java.util.HashSet();	54	private final Set<IClientContext> clientContexts = new java.util.HashSet<IClientContext>();
55	private final Map clientContextMap = new java.util.HashMap();	55	private final Map<String, IClientContext> clientContextMap = new java.util.HashMap<String, IClientContext>();
56		56
57	private final Set defaultContexts = new java.util.HashSet();	57	private final Set<IClientContext> defaultContexts = new java.util.HashSet<IClientContext>();
58		58
59	/**	59	/**
60	* Not instantiable by clients.	60	* Not instantiable by clients.
Lines 80-86 Link Here
80	* under this ID	80	* under this ID
81	*/	81	*/
82	public IClientContext getClientContext(String contextId) {	82	public IClientContext getClientContext(String contextId) {
83	return (IClientContext) clientContextMap.get(contextId);	83	return clientContextMap.get(contextId);
84	}	84	}
85		85
86	/**	86	/**
Lines 88-94 Link Here
88	*	88	*
89	* @return the available {@link IClientContext}s	89	* @return the available {@link IClientContext}s
90	*/	90	*/
91	public Set getClientContexts() {	91	public Set<IClientContext> getClientContexts() {
92	return clientContexts;	92	return clientContexts;
93	}	93	}
94		94
Lines 100-112 Link Here
100	* <code>eObject</code> belongs. This may be empty if no context	100	* <code>eObject</code> belongs. This may be empty if no context
101	* selector matches this element	101	* selector matches this element
102	*/	102	*/
103	public Collection getClientContextsFor(EObject eObject) {	103	public Collection<IClientContext> getClientContextsFor(EObject eObject) {
104	Collection result = new java.util.ArrayList();	104	Collection<IClientContext> result = new java.util.ArrayList<IClientContext>();
105		105
106	EvaluationContext ctx = new EvaluationContext(null, eObject);	106	EvaluationContext ctx = new EvaluationContext(null, eObject);
107		107
108	for (Iterator iter = getClientContexts().iterator(); iter.hasNext();) {	108	for (Iterator<IClientContext> iter = getClientContexts().iterator(); iter.hasNext();) {
109	IClientContext next = (IClientContext) iter.next();	109	IClientContext next = iter.next();
110	IClientSelector selector = next.getSelector();	110	IClientSelector selector = next.getSelector();
111		111
112	final Object toTest = (selector instanceof XmlExpressionSelector)	112	final Object toTest = (selector instanceof XmlExpressionSelector)
Lines 149-168 Link Here
149	* @return the {@link IModelConstraint}s from amongst the specified	149	* @return the {@link IModelConstraint}s from amongst the specified
150	* <code>constraints</code> that are bound to the <code>context</code>	150	* <code>constraints</code> that are bound to the <code>context</code>
151	*/	151	*/
152	public Collection getBindings(EObject eObject, Collection constraints) {	152	public Collection<IModelConstraint> getBindings(EObject eObject,
153	Collection result;	153	Collection<? extends IModelConstraint> constraints) {
154		154
155	Collection contexts = getClientContextsFor(eObject);	155	Collection<IModelConstraint> result;
		156
		157	Collection<IClientContext> contexts = getClientContextsFor(eObject);
156		158
157	if (contexts.isEmpty()) {	159	if (contexts.isEmpty()) {
158	// no context recognizes this object? Oh, well, then there are	160	// no context recognizes this object? Oh, well, then there are
159	// no constraints	161	// no constraints
160	result = Collections.EMPTY_LIST;	162	result = Collections.emptyList();
161	} else if (contexts.size() == 1) {	163	} else if (contexts.size() == 1) {
162	// easy when there's just one context	164	// easy when there's just one context
163	result = getBindings(	165	result = getBindings(contexts.iterator().next(), constraints);
164	(IClientContext) contexts.iterator().next(),
165	constraints);
166	} else {	166	} else {
167	// multiple contexts require more looping	167	// multiple contexts require more looping
168	result = getBindings(contexts, constraints);	168	result = getBindings(contexts, constraints);
Lines 180-191 Link Here
180	* @return the {@link IModelConstraint}s from amongst the specified	180	* @return the {@link IModelConstraint}s from amongst the specified
181	* <code>constraints</code> that are bound to the <code>context</code>	181	* <code>constraints</code> that are bound to the <code>context</code>
182	*/	182	*/
183	public Collection getBindings(IClientContext context, Collection constraints) {	183	public Collection<IModelConstraint> getBindings(IClientContext context,
184	Collection result = new java.util.ArrayList(constraints.size());	184	Collection<? extends IModelConstraint> constraints) {
185		185
186	for (Iterator iter = constraints.iterator(); iter.hasNext();) {	186	Collection<IModelConstraint> result = new java.util.ArrayList<IModelConstraint>(
187	IModelConstraint constraint = (IModelConstraint) iter.next();	187	constraints.size());
188		188
		189	for (IModelConstraint constraint : constraints) {
189	if (context.includes(constraint)) {	190	if (context.includes(constraint)) {
190	result.add(constraint);	191	result.add(constraint);
191	} else if (context.isDefault()) {	192	} else if (context.isDefault()) {
Lines 209-237 Link Here
209	* @return the {@link IModelConstraint}s from amongst the specified	210	* @return the {@link IModelConstraint}s from amongst the specified
210	* <code>constraints</code> that are bound to the <code>context</code>	211	* <code>constraints</code> that are bound to the <code>context</code>
211	*/	212	*/
212	public Collection getBindings(Collection contexts, Collection constraints) {	213	public Collection<IModelConstraint> getBindings(
213	Collection result = new java.util.ArrayList(constraints.size());	214	Collection<? extends IClientContext> contexts,
		215	Collection<? extends IModelConstraint> constraints) {
		216
		217	Collection<IModelConstraint> result = new java.util.ArrayList<IModelConstraint>(
		218	constraints.size());
214		219
215	// use an array for performance (to avoid creating so many iterators)	220	// use an array for performance (to avoid creating so many iterators)
216	IClientContext[] ctxArray = (IClientContext[]) contexts.toArray(	221	IClientContext[] ctxArray = contexts.toArray(new IClientContext[contexts.size()]);
217	new IClientContext[contexts.size()]);
218		222
219	// in case we don't find an explicit binding, we need to know whether	223	// in case we don't find an explicit binding, we need to know whether
220	// we need to look for default bindings. This will only be the case	224	// we need to look for default bindings. This will only be the case
221	// if any of the current contexts is default	225	// if any of the current contexts is default
222	boolean anyContextIsDefault = false;	226	boolean anyContextIsDefault = false;
223		227
224	for (Iterator iter = constraints.iterator(); iter.hasNext();) {	228	for (IModelConstraint constraint : constraints) {
225	IModelConstraint constraint = (IModelConstraint) iter.next();
226	boolean bound = false;	229	boolean bound = false;
227		230
228	for (int i = 0; i < ctxArray.length; i++) {	231	for (IClientContext element : ctxArray) {
229	bound = ctxArray[i].includes(constraint);	232	bound = element.includes(constraint);
230		233
231	if (bound) {	234	if (bound) {
232	result.add(constraint);	235	result.add(constraint);
233	break; // needn't look at any more contexts	236	break; // needn't look at any more contexts
234	} else if (ctxArray[i].isDefault()) {	237	} else if (element.isDefault()) {
235	// no need to check for default contexts as long as we	238	// no need to check for default contexts as long as we
236	// find explicit bindings	239	// find explicit bindings
237	anyContextIsDefault = true;	240	anyContextIsDefault = true;
Lines 270-284 Link Here
270	boolean result = true;	273	boolean result = true;
271	String id = constraint.getDescriptor().getId();	274	String id = constraint.getDescriptor().getId();
272		275
273	for (Iterator iter = clientContexts.iterator(); result && iter.hasNext();) {	276	for (Iterator<IClientContext> iter = clientContexts.iterator();
274	result = !((IClientContext) iter.next()).includes(constraint);	277	result && iter.hasNext();) {
		278
		279	result = !iter.next().includes(constraint);
275	}	280	}
276		281
277	if (result) {	282	if (result) {
278	// add the constraint to all default contexts so that we don't do	283	// add the constraint to all default contexts so that we don't do
279	// this computation again	284	// this computation again
280	for (Iterator iter = defaultContexts.iterator(); iter.hasNext();) {	285	for (IClientContext next : defaultContexts) {
281	((ClientContext) iter.next()).bindConstraint(id);	286	((ClientContext) next).bindConstraint(id);
282	}	287	}
283	}	288	}
284		289
Lines 313-321 Link Here
313	* <code>constraintBindings</code> extension point	318	* <code>constraintBindings</code> extension point
314	*/	319	*/
315	private void configureClientContexts(IConfigurationElement[] elements) {	320	private void configureClientContexts(IConfigurationElement[] elements) {
316	for (int i = 0; i < elements.length; i++) {	321	for (IConfigurationElement config : elements) {
317	IConfigurationElement config = elements[i];
318
319	if (E_CLIENT_CONTEXT.equals(config.getName())) {	322	if (E_CLIENT_CONTEXT.equals(config.getName())) {
320	try {	323	try {
321	ClientContext context = new ClientContext(config);	324	ClientContext context = new ClientContext(config);
Lines 345-353 Link Here
345	* <code>constraintBindings</code> extension point	348	* <code>constraintBindings</code> extension point
346	*/	349	*/
347	private void configureBindings(IConfigurationElement[] elements) {	350	private void configureBindings(IConfigurationElement[] elements) {
348	for (int i = 0; i < elements.length; i++) {	351	for (IConfigurationElement config : elements) {
349	IConfigurationElement config = elements[i];
350
351	if (E_BINDING.equals(config.getName())) {	352	if (E_BINDING.equals(config.getName())) {
352	String contextId = config.getAttribute(A_CONTEXT);	353	String contextId = config.getAttribute(A_CONTEXT);
353		354
Lines 396-403 Link Here
396	}	397	}
397		398
398	IConfigurationElement[] children = config.getChildren(A_CONSTRAINT);	399	IConfigurationElement[] children = config.getChildren(A_CONSTRAINT);
399	for (int i = 0; i < children.length; i++) {	400	for (IConfigurationElement element : children) {
400	final String ref = children[i].getAttribute(A_REF);	401	final String ref = element.getAttribute(A_REF);
401		402
402	if (ref == null) {	403	if (ref == null) {
403	Log.warningMessage(	404	Log.warningMessage(
Lines 412-419 Link Here
412	}	413	}
413		414
414	children = config.getChildren(A_CATEGORY);	415	children = config.getChildren(A_CATEGORY);
415	for (int i = 0; i < children.length; i++) {	416	for (IConfigurationElement element : children) {
416	final String ref = children[i].getAttribute(A_REF);	417	final String ref = element.getAttribute(A_REF);
417		418
418	if (ref == null) {	419	if (ref == null) {
419	Log.errorMessage(	420	Log.errorMessage(

Lines 55-64 Link Here

(-)src/org/eclipse/emf/validation/internal/service/ClientContext.java (-5 / +8 lines)
55	private final boolean isDefault;	55	private final boolean isDefault;
56		56
57	// set of String constraint IDs that are bound to me	57	// set of String constraint IDs that are bound to me
58	private final Set constraintBindings = new java.util.HashSet();	58	private final Set<String> constraintBindings = new java.util.HashSet<String>();
59		59
60	// set of String category IDs that are bound to me	60	// set of String category IDs that are bound to me
61	private final Set categoryBindings = new java.util.HashSet();	61	private final Set<String> categoryBindings = new java.util.HashSet<String>();
62		62
63	/**	63	/**
64	* Initializes me with my XML configuration.	64	* Initializes me with my XML configuration.
Lines 266-276 Link Here
266	* @return <code>true</code> if any of the <code>categories</code> is bound,	266	* @return <code>true</code> if any of the <code>categories</code> is bound,
267	* or if any of their ancestors is bound; <code>false</code>, otherwise	267	* or if any of their ancestors is bound; <code>false</code>, otherwise
268	*/	268	*/
269	private boolean hasCategoryBinding(Collection categories) {	269	private boolean hasCategoryBinding(Collection<Category> categories) {
270	boolean result = false;	270	boolean result = false;
271		271
272	for (Iterator iter = categories.iterator(); !result && iter.hasNext();) {	272	for (Iterator<Category> iter = categories.iterator(); !result && iter.hasNext();) {
273	Category category = (Category) iter.next();	273	Category category = iter.next();
274		274
275	result = categoryBindings.contains(category.getPath());	275	result = categoryBindings.contains(category.getPath());
276		276
Lines 316-321 Link Here
316	/**	316	/**
317	* The context ID fully determines equality.	317	* The context ID fully determines equality.
318	*/	318	*/
		319	@Override
319	public boolean equals(Object obj) {	320	public boolean equals(Object obj) {
320	return (obj instanceof ClientContext)	321	return (obj instanceof ClientContext)
321	&& ((ClientContext) obj).getId().equals(getId());	322	&& ((ClientContext) obj).getId().equals(getId());
Lines 324-333 Link Here
324	/**	325	/**
325	* The context ID fully determines equality.	326	* The context ID fully determines equality.
326	*/	327	*/
		328	@Override
327	public int hashCode() {	329	public int hashCode() {
328	return getId().hashCode();	330	return getId().hashCode();
329	}	331	}
330		332
		333	@Override
331	public String toString() {	334	public String toString() {
332	return "ClientContext[" + getId() + ']'; //$NON-NLS-1$	335	return "ClientContext[" + getId() + ']'; //$NON-NLS-1$
333	}	336	}

Lines 14-20 Link Here

(-)src/org/eclipse/emf/validation/service/AbstractConstraintProvider.java (-24 / +25 lines)
14	package org.eclipse.emf.validation.service;	14	package org.eclipse.emf.validation.service;
15		15
16	import java.util.Collection;	16	import java.util.Collection;
17	import java.util.Iterator;
18	import java.util.List;	17	import java.util.List;
19	import java.util.ListIterator;	18	import java.util.ListIterator;
20	import java.util.Set;	19	import java.util.Set;
Lines 62-68 Link Here
62	IExecutableExtension {	61	IExecutableExtension {
63		62
64	private String[] namespaceUris;	63	private String[] namespaceUris;
65	private List myConstraints = new java.util.ArrayList();	64	private final List<IModelConstraint> myConstraints = new java.util.ArrayList<IModelConstraint>();
66		65
67	/**	66	/**
68	* A proxy for a lazily instantiated implementation of the	67	* A proxy for a lazily instantiated implementation of the
Lines 137-143 Link Here
137		136
138	// replace me with my delegate in the list of constraints, to avoid	137	// replace me with my delegate in the list of constraints, to avoid
139	// the delegation in future invocations and to free some memory	138	// the delegation in future invocations and to free some memory
140	for (ListIterator iter = getConstraints().listIterator();	139	for (ListIterator<IModelConstraint> iter = getConstraints().listIterator();
141	iter.hasNext();) {	140	iter.hasNext();) {
142		141
143	if (iter.next() == this) {	142	if (iter.next() == this) {
Lines 206-212 Link Here
206	*	205	*
207	* @since 1.1	206	* @since 1.1
208	*/	207	*/
209	protected List getConstraints() {	208	protected List<IModelConstraint> getConstraints() {
210	return myConstraints;	209	return myConstraints;
211	}	210	}
212		211
Lines 232-238 Link Here
232	String propertyName,	231	String propertyName,
233	Object data) throws CoreException {	232	Object data) throws CoreException {
234		233
235	Set uris = new java.util.HashSet();	234	Set<String> uris = new java.util.HashSet<String>();
236		235
237	// backwards compatibility to the namespaceUri attribute	236	// backwards compatibility to the namespaceUri attribute
238	String uri = config.getAttribute(	237	String uri = config.getAttribute(
Lines 243-250 Link Here
243		242
244	IConfigurationElement[] pkgs = config.getChildren(XmlConfig.E_PACKAGE);	243	IConfigurationElement[] pkgs = config.getChildren(XmlConfig.E_PACKAGE);
245		244
246	for (int i = 0; i < pkgs.length; i++) {	245	for (IConfigurationElement element : pkgs) {
247	uri = pkgs[i].getAttribute(XmlConfig.A_NAMESPACE_URI);	246	uri = element.getAttribute(XmlConfig.A_NAMESPACE_URI);
248	if (uri != null) {	247	if (uri != null) {
249	uris.add(uri.trim());	248	uris.add(uri.trim());
250	}	249	}
Lines 266-280 Link Here
266	throw e;	265	throw e;
267	}	266	}
268		267
269	namespaceUris = (String[]) uris.toArray(new String[uris.size()]);	268	namespaceUris = uris.toArray(new String[uris.size()]);
270	}	269	}
271		270
272	/**	271	/**
273	* @since 1.1	272	* @since 1.1
274	*/	273	*/
275	public Collection getLiveConstraints(	274	public Collection<IModelConstraint> getLiveConstraints(
276	Notification notification,	275	Notification notification,
277	Collection constraints) {	276	Collection<IModelConstraint> constraints) {
278		277
279	assert notification != null;	278	assert notification != null;
280		279
Lines 282-298 Link Here
282	Trace.entering(getClass(), "getLiveConstraints"); //$NON-NLS-1$	281	Trace.entering(getClass(), "getLiveConstraints"); //$NON-NLS-1$
283	}	282	}
284		283
285	Collection result = constraints;	284	Collection<IModelConstraint> result = constraints;
286		285
287	if (result == null) {	286	if (result == null) {
288	result = new java.util.ArrayList();	287	result = new java.util.ArrayList<IModelConstraint>();
289	}	288	}
290		289
291	if (notification.getNotifier() instanceof EObject) {	290	if (notification.getNotifier() instanceof EObject) {
292	EObject eObject = (EObject)notification.getNotifier();	291	EObject eObject = (EObject)notification.getNotifier();
293		292
294	for (Iterator iter = getConstraints().iterator(); iter.hasNext(); ) {	293	for (IModelConstraint next : getConstraints()) {
295	IModelConstraint next = (IModelConstraint)iter.next();
296	IConstraintDescriptor desc = next.getDescriptor();	294	IConstraintDescriptor desc = next.getDescriptor();
297		295
298	if (desc.isLive() && desc.targetsTypeOf(eObject)	296	if (desc.isLive() && desc.targetsTypeOf(eObject)
Lines 313-334 Link Here
313	/**	311	/**
314	* @since 1.1	312	* @since 1.1
315	*/	313	*/
316	public Collection getBatchConstraints(	314	public Collection<IModelConstraint> getBatchConstraints(
317	EObject eObject,	315	EObject eObject,
318	Collection constraints) {	316	Collection<IModelConstraint> constraints) {
319		317
320	if (Trace.shouldTraceEntering(EMFModelValidationDebugOptions.PROVIDERS)) {	318	if (Trace.shouldTraceEntering(EMFModelValidationDebugOptions.PROVIDERS)) {
321	Trace.entering(getClass(), "getBatchConstraints"); //$NON-NLS-1$	319	Trace.entering(getClass(), "getBatchConstraints"); //$NON-NLS-1$
322	}	320	}
323		321
324	Collection result = constraints;	322	Collection<IModelConstraint> result = constraints;
325		323
326	if (result == null) {	324	if (result == null) {
327	result = new java.util.ArrayList();	325	result = new java.util.ArrayList<IModelConstraint>();
328	}	326	}
329		327
330	for (Iterator iter = getConstraints().iterator(); iter.hasNext(); ) {	328	for (IModelConstraint next : getConstraints()) {
331	IModelConstraint next = (IModelConstraint)iter.next();
332	IConstraintDescriptor desc = next.getDescriptor();	329	IConstraintDescriptor desc = next.getDescriptor();
333		330
334	if (desc.isBatch() && desc.targetsTypeOf(eObject)) {	331	if (desc.isBatch() && desc.targetsTypeOf(eObject)) {
Lines 355-366 Link Here
355	*	352	*
356	* @since 1.2	353	* @since 1.2
357	*/	354	*/
358	protected void registerConstraints(Collection constraints) throws ConstraintExistsException {	355	protected void registerConstraints(
		356	Collection<? extends IModelConstraint> constraints)
		357	throws ConstraintExistsException {
		358
359	if (!constraints.isEmpty()) {	359	if (!constraints.isEmpty()) {
360	List descriptors = new java.util.ArrayList(constraints.size());	360	List<IConstraintDescriptor> descriptors =
		361	new java.util.ArrayList<IConstraintDescriptor>(constraints.size());
361		362
362	for (Iterator iter = constraints.iterator(); iter.hasNext();) {	363	for (IModelConstraint next : constraints) {
363	descriptors.add(((IModelConstraint) iter.next()).getDescriptor());	364	descriptors.add(next.getDescriptor());
364	}	365	}
365		366
366	ConstraintRegistry.getInstance().bulkRegister(descriptors);	367	ConstraintRegistry.getInstance().bulkRegister(descriptors);

Lines 44-50 Link Here

(-)src/org/eclipse/emf/validation/service/AbstractTraversalStrategy.java (-5 / +6 lines)
44	/** Don't allow client's progress to count more steps than this number. */	44	/** Don't allow client's progress to count more steps than this number. */
45	private static final int MAX_PROGRESS_TICKS = 2048;	45	private static final int MAX_PROGRESS_TICKS = 2048;
46		46
47	private Iterator iterator;	47	private Iterator<? extends EObject> iterator;
48	private IProgressMonitor monitor;	48	private IProgressMonitor monitor;
49		49
50	/**	50	/**
Lines 62-68 Link Here
62	* updates).	62	* updates).
63	*/	63	*/
64	public void startTraversal(	64	public void startTraversal(
65	Collection traversalRoots,	65	Collection<? extends EObject> traversalRoots,
66	IProgressMonitor progressMonitor) {	66	IProgressMonitor progressMonitor) {
67		67
68	int taskSize = countElements(traversalRoots);	68	int taskSize = countElements(traversalRoots);
Lines 110-116 Link Here
110	* @return the total number of elements to be validated within these	110	* @return the total number of elements to be validated within these
111	* sub-trees	111	* sub-trees
112	*/	112	*/
113	protected abstract int countElements(Collection traversalRoots);	113	protected abstract int countElements(Collection<? extends EObject> traversalRoots);
114		114
115	/**	115	/**
116	* Implemented by subclasses to return an iterator that provides all of the	116	* Implemented by subclasses to return an iterator that provides all of the
Lines 120-126 Link Here
120	* @param traversalRoots the roots of the traversal sub-trees	120	* @param traversalRoots the roots of the traversal sub-trees
121	* @return an iterator that covers all of the elements to be validated	121	* @return an iterator that covers all of the elements to be validated
122	*/	122	*/
123	protected abstract Iterator createIterator(Collection traversalRoots);	123	protected abstract Iterator<? extends EObject> createIterator(
		124	Collection<? extends EObject> traversalRoots);
124		125
125	/**	126	/**
126	* Provides subclasses with access to the progress monitor, if they want it	127	* Provides subclasses with access to the progress monitor, if they want it
Lines 148-154 Link Here
148	* @see #createIterator	149	* @see #createIterator
149	*/	150	*/
150	public EObject next() {	151	public EObject next() {
151	return (EObject)iterator.next();	152	return iterator.next();
152	}	153	}
153		154
154	/**	155	/**

Lines 71-77 Link Here

(-)src/org/eclipse/emf/validation/service/ModelValidationService.java (-41 / +48 lines)
71	public class ModelValidationService {	71	public class ModelValidationService {
72	private static final ModelValidationService instance = new ModelValidationService();	72	private static final ModelValidationService instance = new ModelValidationService();
73		73
74	private final Collection constraintProviders = new java.util.HashSet();	74	private final Collection<IProviderDescriptor> constraintProviders =
		75	new java.util.HashSet<IProviderDescriptor>();
75		76
76	// latch to control multiple invocations of loadXmlConstraintDefinitions()	77	// latch to control multiple invocations of loadXmlConstraintDefinitions()
77	private boolean xmlConstraintDeclarationsLoaded = false;	78	private boolean xmlConstraintDeclarationsLoaded = false;
Lines 107-130 Link Here
107	* The resulting validator may be retained as long as it is needed, and	108	* The resulting validator may be retained as long as it is needed, and
108	* reused any number of times. Each validator has its own separate state.	109	* reused any number of times. Each validator has its own separate state.
109	* </p>	110	* </p>
		111	*
		112	* @param <T> the kind of validator to return
		113	*
110	* @param mode the evaluation mode for which to create a new validator.	114	* @param mode the evaluation mode for which to create a new validator.
111	* Must not be <code>null</code> or {@link EvaluationMode#NULL}	115	* Must not be <code>null</code> or {@link EvaluationMode#NULL}
		116	*
112	* @return a new validator	117	* @return a new validator
		118	*
113	* @throws IllegalArgumentException if the <code>mode</code> is not a	119	* @throws IllegalArgumentException if the <code>mode</code> is not a
114	* valid evaluation mode	120	* valid evaluation mode
115	*/	121	*/
116	public IValidator newValidator(EvaluationMode mode) {	122	@SuppressWarnings("unchecked")
		123	public <T, V extends IValidator<T>> V newValidator(EvaluationMode<T> mode) {
117	assert mode != null && !mode.isNull();	124	assert mode != null && !mode.isNull();
118		125
119	IProviderOperationExecutor executor = new IProviderOperationExecutor() {	126	IProviderOperationExecutor<Collection<IModelConstraint>> executor =
120	public void execute(IProviderOperation op) {	127	new IProviderOperationExecutor<Collection<IModelConstraint>>() {
121	ModelValidationService.this.execute(op);	128	public void execute(IProviderOperation<? extends Collection<IModelConstraint>> op) {
122	}};	129	ModelValidationService.this.execute(op);
		130	}};
123		131
124	if (mode == EvaluationMode.BATCH) {	132	if (mode == EvaluationMode.BATCH) {
125	return new BatchValidator(executor);	133	return (V) new BatchValidator(executor);
126	} else if (mode == EvaluationMode.LIVE) {	134	} else if (mode == EvaluationMode.LIVE) {
127	return new LiveValidator(executor);	135	return (V) new LiveValidator(executor);
128	} else {	136	} else {
129	throw new IllegalArgumentException();	137	throw new IllegalArgumentException();
130	}	138	}
Lines 213-233 Link Here
213	*/	221	*/
214	public void broadcastValidationEvent(ValidationEvent event) {	222	public void broadcastValidationEvent(ValidationEvent event) {
215	// Check if listeners exist	223	// Check if listeners exist
216	if (listeners == null)	224	if (listeners == null) {
217	return;	225	return;
		226	}
218		227
219	IValidationListener[] array = listeners; // copy the reference	228	IValidationListener[] array = listeners; // copy the reference
220		229
221	for (int i = 0; i < array.length; i++) {	230	for (IValidationListener element : array) {
222	try {	231	try {
223	array[i].validationOccurred(event);	232	element.validationOccurred(event);
224	} catch (Exception e) {	233	} catch (Exception e) {
225	Trace.catching(getClass(), "broadcastValidationEvent", e); //$NON-NLS-1$	234	Trace.catching(getClass(), "broadcastValidationEvent", e); //$NON-NLS-1$
226		235
227	if (Trace.shouldTrace(EMFModelValidationDebugOptions.LISTENERS)) {	236	if (Trace.shouldTrace(EMFModelValidationDebugOptions.LISTENERS)) {
228	Trace.trace(	237	Trace.trace(
229	EMFModelValidationDebugOptions.LISTENERS,	238	EMFModelValidationDebugOptions.LISTENERS,
230	"Uncaught exception in listener: " + array[i].getClass().getName()); //$NON-NLS-1$	239	"Uncaught exception in listener: " + element.getClass().getName()); //$NON-NLS-1$
231	}	240	}
232		241
233	Log.l7dWarning(	242	Log.l7dWarning(
Lines 253-262 Link Here
253	public void configureListeners(IConfigurationElement[] elements) {	262	public void configureListeners(IConfigurationElement[] elements) {
254	assert elements != null;	263	assert elements != null;
255		264
256	for (int i = 0; i < elements.length; i++) {	265	for (IConfigurationElement element : elements) {
257	if (elements[i].getName().equals("listener")) { //$NON-NLS-1$	266	if (element.getName().equals("listener")) { //$NON-NLS-1$
258	try {	267	try {
259	addValidationListener(new LazyListener(elements[i]));	268	addValidationListener(new LazyListener(element));
260	} catch (CoreException e) {	269	} catch (CoreException e) {
261	Trace.catching(getClass(), "configureListeners()", e); //$NON-NLS-1$	270	Trace.catching(getClass(), "configureListeners()", e); //$NON-NLS-1$
262		271
Lines 283-298 Link Here
283		292
284	constraintCache = new ConstraintCache();	293	constraintCache = new ConstraintCache();
285		294
286	Collection providers = getProviders();	295	Collection<IProviderDescriptor> providers = getProviders();
287		296
288	// include the cache in my collection of providers	297	// include the cache in my collection of providers
289	providers.add(constraintCache.getDescriptor());	298	providers.add(constraintCache.getDescriptor());
290		299
291	for (int i = 0; i < elements.length; i++) {	300	for (IConfigurationElement element : elements) {
292	if (elements[i].getName().equals(XmlConfig.E_CONSTRAINT_PROVIDER)) {	301	if (element.getName().equals(XmlConfig.E_CONSTRAINT_PROVIDER)) {
293	try {	302	try {
294	IProviderDescriptor descriptor =	303	IProviderDescriptor descriptor =
295	new ProviderDescriptor(elements[i]);	304	new ProviderDescriptor(element);
296		305
297	if (descriptor.isCacheEnabled()) {	306	if (descriptor.isCacheEnabled()) {
298	constraintCache.addProvider(descriptor);	307	constraintCache.addProvider(descriptor);
Lines 338-344 Link Here
338	*	347	*
339	* @return a collection of {@link ProviderDescriptor}s	348	* @return a collection of {@link ProviderDescriptor}s
340	*/	349	*/
341	private Collection getProviders() {	350	private Collection<IProviderDescriptor> getProviders() {
342	return constraintProviders;	351	return constraintProviders;
343	}	352	}
344		353
Lines 347-355 Link Here
347	*	356	*
348	* @param operation the operation to execute	357	* @param operation the operation to execute
349	*/	358	*/
350	private void execute(IProviderOperation operation) {	359	private void execute(
351	for (Iterator iter = getProviders().iterator(); iter.hasNext(); ) {	360	IProviderOperation<? extends Collection<? extends IModelConstraint>> operation) {
352	IProviderDescriptor next = (IProviderDescriptor)iter.next();	361
		362	for (Iterator<IProviderDescriptor> iter = getProviders().iterator(); iter.hasNext(); ) {
		363	IProviderDescriptor next = iter.next();
353		364
354	if (next.provides(operation)) {	365	if (next.provides(operation)) {
355	try {	366	try {
Lines 397-406 Link Here
397	*	408	*
398	* @param providers the available providers	409	* @param providers the available providers
399	*/	410	*/
400	private void loadXmlConstraintDeclarations(Collection providers) {	411	private void loadXmlConstraintDeclarations(Collection<IProviderDescriptor> providers) {
401	for (Iterator iter = providers.iterator(); iter.hasNext();) {	412	for (IProviderDescriptor next : providers) {
402	IProviderDescriptor next = (IProviderDescriptor)iter.next();
403
404	if (next.isXmlProvider()) {	413	if (next.isXmlProvider()) {
405	// the initialization of this provider is not very expensive	414	// the initialization of this provider is not very expensive
406	// and is guaranteed not to load any other plug-ins	415	// and is guaranteed not to load any other plug-ins
Lines 437-443 Link Here
437	if (epackage != null) {	446	if (epackage != null) {
438	EClassifier classifier = null;	447	EClassifier classifier = null;
439		448
440	List packageNames = parsePackageNames(className);	449	List<String> packageNames = parsePackageNames(className);
441	if (packageNames == null) {	450	if (packageNames == null) {
442	classifier = epackage.getEClassifier(className);	451	classifier = epackage.getEClassifier(className);
443	} else if (packageHasName(epackage, packageNames)) {	452	} else if (packageHasName(epackage, packageNames)) {
Lines 466-472 Link Here
466	* @see #findClass(String, String)	475	* @see #findClass(String, String)
467	*/	476	*/
468	private static EPackage findPackage(String namespaceUri) {	477	private static EPackage findPackage(String namespaceUri) {
469	Map registry = org.eclipse.emf.ecore.EPackage.Registry.INSTANCE;	478	Map<String, Object> registry = org.eclipse.emf.ecore.EPackage.Registry.INSTANCE;
470		479
471	Object result = registry.get(namespaceUri);	480	Object result = registry.get(namespaceUri);
472		481
Lines 487-498 Link Here
487	* @return the package names in right-to-left order, as a list of	496	* @return the package names in right-to-left order, as a list of
488	* strings, or <code>null</code> if the class name is not qualified	497	* strings, or <code>null</code> if the class name is not qualified
489	*/	498	*/
490	private static List parsePackageNames(String qualifiedClassName) {	499	private static List<String> parsePackageNames(String qualifiedClassName) {
491	List result = null;	500	List<String> result = null;
492	int end = qualifiedClassName.lastIndexOf('.'); // known BMP code point	501	int end = qualifiedClassName.lastIndexOf('.'); // known BMP code point
493		502
494	if (end >= 0) {	503	if (end >= 0) {
495	result = new java.util.ArrayList();	504	result = new java.util.ArrayList<String>();
496		505
497	// skip the class name part and collect other parts in	506	// skip the class name part and collect other parts in
498	// reverse order	507	// reverse order
Lines 520-529 Link Here
520	* the package from bottom to top of the containment hierarchy;	529	* the package from bottom to top of the containment hierarchy;
521	* <code>false</code>, otherwise	530	* <code>false</code>, otherwise
522	*/	531	*/
523	private static boolean packageHasName(EPackage epackage, List name) {	532	private static boolean packageHasName(EPackage epackage, List<String> name) {
524	boolean result = true;	533	boolean result = true;
525	EPackage pkg = epackage;	534	EPackage pkg = epackage;
526	Iterator iter = name.iterator();	535	Iterator<String> iter = name.iterator();
527		536
528	while (result && iter.hasNext() && (pkg != null)) {	537	while (result && iter.hasNext() && (pkg != null)) {
529	result = iter.next().equals(pkg.getName());	538	result = iter.next().equals(pkg.getName());
Lines 548-554 Link Here
548	*/	557	*/
549	private final class LazyListener implements IValidationListener {	558	private final class LazyListener implements IValidationListener {
550	private final IConfigurationElement config;	559	private final IConfigurationElement config;
551	private List registeredClientContexts = null;	560	private List<String> registeredClientContexts = null;
552	private IValidationListener validationListener = null;	561	private IValidationListener validationListener = null;
553		562
554	private static final String E_CLIENT_CONTEXT = "clientContext"; //$NON-NLS-1$	563	private static final String E_CLIENT_CONTEXT = "clientContext"; //$NON-NLS-1$
Lines 582-591 Link Here
582	IConfigurationElement[] children = config.getChildren(E_CLIENT_CONTEXT);	591	IConfigurationElement[] children = config.getChildren(E_CLIENT_CONTEXT);
583		592
584	// Probably a small number of registered client contexts.	593	// Probably a small number of registered client contexts.
585	registeredClientContexts = new ArrayList(3);	594	registeredClientContexts = new ArrayList<String>(4);
586		595
587	for (int i=0; i<children.length; i++) {	596	for (IConfigurationElement element : children) {
588	registeredClientContexts.add(children[i].getAttribute(A_CLIENT_CONTEXT_ID));	597	registeredClientContexts.add(element.getAttribute(A_CLIENT_CONTEXT_ID));
589	}	598	}
590	}	599	}
591		600
Lines 610-618 Link Here
610		619
611	// Otherwise, we will delay the loading of this listener until	620	// Otherwise, we will delay the loading of this listener until
612	// we are certain that they are interested in listening.	621	// we are certain that they are interested in listening.
613	for (Iterator i = registeredClientContexts.iterator(); i.hasNext();) {	622	for (String clientContextId : registeredClientContexts) {
614	String clientContextId = (String)i.next();
615
616	if (event.getClientContextIds().contains(clientContextId)) {	623	if (event.getClientContextIds().contains(clientContextId)) {
617	try {	624	try {
618	if (validationListener == null) {	625	if (validationListener == null) {

Lines 59-76 Link Here

(-)src/org/eclipse/emf/validation/service/IValidator.java (-5 / +7 lines)
59	* <b>Note</b> that clients are not intended to implement this interface.	59	* <b>Note</b> that clients are not intended to implement this interface.
60	* </p>	60	* </p>
61	*	61	*
		62	* @param <T> the kind of target element validated by the validator
		63	*
62	* @see ModelValidationService#newValidator(EvaluationMode)	64	* @see ModelValidationService#newValidator(EvaluationMode)
63	*	65	*
64	* @author Christian W. Damus (cdamus)	66	* @author Christian W. Damus (cdamus)
65	*/	67	*/
66	public interface IValidator {	68	public interface IValidator<T> {
67	/**	69	/**
68	* Indicates the evaluation mode that I support. This indicates the kind	70	* Indicates the evaluation mode that I support. This indicates the kind
69	* of objects expected by the <code>validate()</code> methods to process.	71	* of objects expected by the <code>validate()</code> methods to process.
70	*	72	*
71	* @return my evaluation mode	73	* @return my evaluation mode
72	*/	74	*/
73	EvaluationMode getEvaluationMode();	75	EvaluationMode<T> getEvaluationMode();
74		76
75	/**	77	/**
76	* Queries whether successful constraint evaluations are reported, in	78	* Queries whether successful constraint evaluations are reported, in
Lines 130-136 Link Here
130	* @throws ClassCastException if the <code>object</code> is not of	132	* @throws ClassCastException if the <code>object</code> is not of
131	* the correct type for this validator	133	* the correct type for this validator
132	*/	134	*/
133	IStatus validate(Object object);	135	IStatus validate(T object);
134		136
135	/**	137	/**
136	* Validates multiple objects, all in the same	138	* Validates multiple objects, all in the same
Lines 146-152 Link Here
146	* not of the correct type for this validator	148	* not of the correct type for this validator
147	* @see #validate(Object)	149	* @see #validate(Object)
148	*/	150	*/
149	IStatus validate(Collection objects);	151	IStatus validate(Collection<? extends T> objects);
150		152
151	/**	153	/**
152	* Adds a constraint filter to this validator. The validator	154	* Adds a constraint filter to this validator. The validator
Lines 183-187 Link Here
183	*	185	*
184	* @since 1.1	186	* @since 1.1
185	*/	187	*/
186	Collection getConstraintFilters();	188	Collection<IConstraintFilter> getConstraintFilters();
187	}	189	}

Lines 43-55 Link Here

(-)src/org/eclipse/emf/validation/service/EventTypeService.java (-10 / +12 lines)
43	private static final String A_FEATURE_SPECIFIC = "featureSpecific"; //$NON-NLS-1$	43	private static final String A_FEATURE_SPECIFIC = "featureSpecific"; //$NON-NLS-1$
44	private static final String A_NOTIFICATION_GENERATOR = "notificationGenerator"; //$NON-NLS-1$	44	private static final String A_NOTIFICATION_GENERATOR = "notificationGenerator"; //$NON-NLS-1$
45		45
46	private final Map notificationGenerators;	46	private final Map<String, INotificationGenerator> notificationGenerators;
47		47
48	/**	48	/**
49	* Cannot be instantiated by clients.	49	* Cannot be instantiated by clients.
50	*/	50	*/
51	private EventTypeService() {	51	private EventTypeService() {
52	notificationGenerators = new HashMap();	52	notificationGenerators = new HashMap<String, INotificationGenerator>();
53	}	53	}
54		54
55	/**	55	/**
Lines 79-96 Link Here
79	public void configureEventTypes(IConfigurationElement[] elements) {	79	public void configureEventTypes(IConfigurationElement[] elements) {
80	assert elements != null;	80	assert elements != null;
81		81
82	for (int i = 0; i < elements.length; i++) {	82	for (IConfigurationElement element : elements) {
83	if (elements[i].getName().equals("eventType")) { //$NON-NLS-1$	83	if (element.getName().equals("eventType")) { //$NON-NLS-1$
84	try {	84	try {
85	String name = elements[i].getAttribute(A_NAME);	85	String name = element.getAttribute(A_NAME);
86	if ((name != null) && (name.length() > 0)) {	86	if ((name != null) && (name.length() > 0)) {
87	EMFEventType.addEventType(name,	87	EMFEventType.addEventType(name,
88	Boolean.valueOf(elements[i].getAttribute(A_FEATURE_SPECIFIC)).booleanValue()	88	Boolean.valueOf(element.getAttribute(A_FEATURE_SPECIFIC)).booleanValue()
89	);	89	);
90		90
91	String notificationGenerator = elements[i].getAttribute(A_NOTIFICATION_GENERATOR);	91	String notificationGenerator = element.getAttribute(A_NOTIFICATION_GENERATOR);
92	if ((notificationGenerator != null) && (notificationGenerator.length() > 0)) {	92	if ((notificationGenerator != null) && (notificationGenerator.length() > 0)) {
93	notificationGenerators.put(name, elements[i].createExecutableExtension(A_NOTIFICATION_GENERATOR));	93	notificationGenerators.put(
		94	name,
		95	(INotificationGenerator) element.createExecutableExtension(A_NOTIFICATION_GENERATOR));
94	}	96	}
95	}	97	}
96	} catch (CoreException e) {	98	} catch (CoreException e) {
Lines 107-113 Link Here
107	*	109	*
108	* @return collection of notification generators	110	* @return collection of notification generators
109	*/	111	*/
110	public Collection getNotificationGenerators() {	112	public Collection<INotificationGenerator> getNotificationGenerators() {
111	return Collections.unmodifiableCollection(notificationGenerators.values());	113	return Collections.unmodifiableCollection(notificationGenerators.values());
112	}	114	}
113		115
Lines 120-125 Link Here
120	* null otherwise	122	* null otherwise
121	*/	123	*/
122	public INotificationGenerator getNotificationGenerator(String eventName) {	124	public INotificationGenerator getNotificationGenerator(String eventName) {
123	return (INotificationGenerator)notificationGenerators.get(eventName);	125	return notificationGenerators.get(eventName);
124	}	126	}
125	}	127	}

Lines 204-218 Link Here

(-)src/org/eclipse/emf/validation/util/XmlConfig.java (-9 / +9 lines)
204	IConfigurationElement constraint,	204	IConfigurationElement constraint,
205	String name) {	205	String name) {
206		206
207	List result = new java.util.ArrayList();	207	List<String> result = new java.util.ArrayList<String>();
208		208
209	IConfigurationElement[] parms = constraint.getChildren(E_PARAM);	209	IConfigurationElement[] parms = constraint.getChildren(E_PARAM);
210	for (int i = 0; i < parms.length; i++) {	210	for (IConfigurationElement element : parms) {
211	if (name.equals(parms[i].getAttribute(A_NAME))) {	211	if (name.equals(element.getAttribute(A_NAME))) {
212	String value = parms[i].getAttribute(A_VALUE);	212	String value = element.getAttribute(A_VALUE);
213		213
214	if (value == null) {	214	if (value == null) {
215	value = parms[i].getValue();	215	value = element.getValue();
216	}	216	}
217		217
218	if (value != null) {	218	if (value != null) {
Lines 221-227 Link Here
221	}	221	}
222	}	222	}
223		223
224	return (String[])result.toArray(new String[result.size()]);	224	return result.toArray(new String[result.size()]);
225	}	225	}
226		226
227	/**	227	/**
Lines 253-260 Link Here
253	String path = tokens.nextToken().trim();	253	String path = tokens.nextToken().trim();
254		254
255	if (path.length() > 0) {	255	if (path.length() > 0) {
256	for (int i = 0; i < children.length; i++) {	256	for (IConfigurationElement element : children) {
257	final String id = children[i].getAttribute(A_ID);	257	final String id = element.getAttribute(A_ID);
258		258
259	IConstraintDescriptor constraint =	259	IConstraintDescriptor constraint =
260	ConstraintRegistry.getInstance().getDescriptor(	260	ConstraintRegistry.getInstance().getDescriptor(
Lines 263-269 Link Here
263		263
264	if (constraint == null) {	264	if (constraint == null) {
265	try {	265	try {
266	constraint = new XmlConstraintDescriptor(children[i]);	266	constraint = new XmlConstraintDescriptor(element);
267	} catch (ConstraintExistsException e) {	267	} catch (ConstraintExistsException e) {
268	// shouldn't happen because I checked for existence	268	// shouldn't happen because I checked for existence
269	continue;	269	continue;

Lines 21-45 Link Here

(-)src/org/eclipse/emf/validation/util/FilteredCollection.java (-16 / +24 lines)
21	* Wrapper for a Java 2 {@link Collection} that provides a filtered view of its	21	* Wrapper for a Java 2 {@link Collection} that provides a filtered view of its
22	* contents according to a client-specified filter algorithm.	22	* contents according to a client-specified filter algorithm.
23	*	23	*
		24	* @param <E> the collection element type
		25	*
24	* @author Christian W. Damus (cdamus)	26	* @author Christian W. Damus (cdamus)
25	*/	27	*/
26	public class FilteredCollection extends AbstractCollection {	28	public class FilteredCollection<E> extends AbstractCollection<E> {
27	/**	29	/**
28	* Indicates the end of iteration. Cannot use 'null' for this purpose, as	30	* Indicates the end of iteration. Cannot use 'null' for this purpose, as
29	* it may legitimately be present in a collection.	31	* it may legitimately be present in a collection.
30	*/	32	*/
31	private static final Object END_TOKEN = new Object();	33	private static final Object END_TOKEN = new Object();
32		34
33	private final Collection filteree;	35	private final Collection<? extends E> filteree;
34	private final Filter filter;	36	private final Filter<? super E> filter;
35		37
36	/**	38	/**
37	* Interface for the algorithm that determines which elements are in and	39	* Interface for the algorithm that determines which elements are in and
38	* which are out of the filtered collection.	40	* which are out of the filtered collection.
39	*	41	*
		42	* @param <E> the collection element type to filter
		43	*
40	* @author Christian W. Damus (cdamus)	44	* @author Christian W. Damus (cdamus)
41	*/	45	*/
42	public static interface Filter {	46	public static interface Filter<E> {
43	/**	47	/**
44	* Determines whether to accept or reject the specified	48	* Determines whether to accept or reject the specified
45	* <code>element</code> from the collection.	49	* <code>element</code> from the collection.
Lines 48-54 Link Here
48	* @return <CODE>true</CODE> if the <code>element</code> should be	52	* @return <CODE>true</CODE> if the <code>element</code> should be
49	* included in the filtered view; <CODE>false</CODE>, otherwise	53	* included in the filtered view; <CODE>false</CODE>, otherwise
50	*/	54	*/
51	boolean accept(Object element);	55	boolean accept(E element);
52	}	56	}
53		57
54	/**	58	/**
Lines 65-71 Link Here
65	* @param collection the collection that I am to filter	69	* @param collection the collection that I am to filter
66	* @param filter the filter algorithm to apply	70	* @param filter the filter algorithm to apply
67	*/	71	*/
68	public FilteredCollection(Collection collection, Filter filter) {	72	public FilteredCollection(Collection<? extends E> collection, Filter<? super E> filter) {
69	this.filteree = collection;	73	this.filteree = collection;
70	this.filter = filter;	74	this.filter = filter;
71	}	75	}
Lines 77-83 Link Here
77	*	81	*
78	* @return my filter	82	* @return my filter
79	*/	83	*/
80	public final Filter getFilter() {	84	public final Filter<? super E> getFilter() {
81	return filter;	85	return filter;
82	}	86	}
83		87
Lines 87-95 Link Here
87	*	91	*
88	* @author Christian W. Damus (cdamus)	92	* @author Christian W. Damus (cdamus)
89	*/	93	*/
90	private class Iter implements Iterator {	94	@SuppressWarnings("unchecked")
91	private final Iterator filteredIterator = filteree.iterator();	95	private class Iter implements Iterator<E> {
92	private Object next = END_TOKEN;	96	private final Iterator<? extends E> filteredIterator = filteree.iterator();
		97
		98	private E next = (E) END_TOKEN;
93		99
94	/**	100	/**
95	* Queries whether I have another object that matches the	101	* Queries whether I have another object that matches the
Lines 105-111 Link Here
105	break;	111	break;
106	} else {	112	} else {
107	// try again	113	// try again
108	next = END_TOKEN;	114	next = (E) END_TOKEN;
109	}	115	}
110	}	116	}
111	}	117	}
Lines 116-129 Link Here
116	/**	122	/**
117	* Retrieves the next object that matches my {@link #getFilter filter}.	123	* Retrieves the next object that matches my {@link #getFilter filter}.
118	*/	124	*/
119	public Object next() {	125	public E next() {
120	if (!hasNext()) {	126	if (!hasNext()) {
121	throw new NoSuchElementException();	127	throw new NoSuchElementException();
122	}	128	}
123		129
124	Object result = next;	130	E result = next;
125		131
126	next = END_TOKEN;	132	next = (E) END_TOKEN;
127		133
128	return result;	134	return result;
129	}	135	}
Lines 146-152 Link Here
146	* @return an iterator the exposes only the elements of my wrapped	152	* @return an iterator the exposes only the elements of my wrapped
147	* collection that match my filter	153	* collection that match my filter
148	*/	154	*/
149	public Iterator iterator() {	155	@Override
		156	public Iterator<E> iterator() {
150	return new Iter();	157	return new Iter();
151	}	158	}
152		159
Lines 164-173 Link Here
164	* @return the number of elements in my wrapped collection that match my	171	* @return the number of elements in my wrapped collection that match my
165	* filter	172	* filter
166	*/	173	*/
		174	@Override
167	public int size() {	175	public int size() {
168	int result = 0;	176	int result = 0;
169		177
170	for (Iterator iter = iterator(); iter.hasNext(); iter.next()) {	178	for (Iterator<E> iter = iterator(); iter.hasNext(); iter.next()) {
171	result++;	179	result++;
172	}	180	}
173		181

Lines 14-20 Link Here

(-)src/org/eclipse/emf/validation/internal/util/XmlConfigurationElement.java (-25 / +21 lines)
14		14
15	import java.net.MalformedURLException;	15	import java.net.MalformedURLException;
16	import java.net.URL;	16	import java.net.URL;
17	import java.util.Iterator;
18	import java.util.List;	17	import java.util.List;
19	import java.util.Map;	18	import java.util.Map;
20		19
Lines 28-38 Link Here
28	import org.eclipse.core.runtime.Path;	27	import org.eclipse.core.runtime.Path;
29	import org.eclipse.core.runtime.Platform;	28	import org.eclipse.core.runtime.Platform;
30	import org.eclipse.core.runtime.Status;	29	import org.eclipse.core.runtime.Status;
31	import org.osgi.framework.Bundle;
32
33	import org.eclipse.emf.validation.internal.EMFModelValidationPlugin;	30	import org.eclipse.emf.validation.internal.EMFModelValidationPlugin;
34	import org.eclipse.emf.validation.internal.EMFModelValidationStatusCodes;	31	import org.eclipse.emf.validation.internal.EMFModelValidationStatusCodes;
35	import org.eclipse.emf.validation.util.XmlConfig;	32	import org.eclipse.emf.validation.util.XmlConfig;
		33	import org.osgi.framework.Bundle;
36		34
37	/**	35	/**
38	* A custom implementation of the Eclipse configuration element API which is	36	* A custom implementation of the Eclipse configuration element API which is
Lines 48-55 Link Here
48	private final URL baseUrl;	46	private final URL baseUrl;
49		47
50	private String value;	48	private String value;
51	private final Map attributes;	49	private final Map<String, String> attributes;
52	private final List children = new java.util.ArrayList();	50	private final List<IConfigurationElement> children =
		51	new java.util.ArrayList<IConfigurationElement>();
53	private Object parent;	52	private Object parent;
54		53
55	/**	54	/**
Lines 60-66 Link Here
60	* @param baseUrl the base of any relative URL of files that I load	59	* @param baseUrl the base of any relative URL of files that I load
61	*/	60	*/
62	XmlConfigurationElement(String name, IExtension extension, URL baseUrl) {	61	XmlConfigurationElement(String name, IExtension extension, URL baseUrl) {
63	this(name, new java.util.HashMap(), extension, baseUrl);	62	this(name, new java.util.HashMap<String, String>(), extension, baseUrl);
64	}	63	}
65		64
66	/**	65	/**
Lines 74-80 Link Here
74	*/	73	*/
75	XmlConfigurationElement(	74	XmlConfigurationElement(
76	String name,	75	String name,
77	Map attributes,	76	Map<String, String> attributes,
78	IExtension extension,	77	IExtension extension,
79	URL baseUrl) {	78	URL baseUrl) {
80	this.myName = name;	79	this.myName = name;
Lines 111-117 Link Here
111		110
112	// implements the interface method	111	// implements the interface method
113	public String getAttribute(String name) {	112	public String getAttribute(String name) {
114	return (String)attributes.get(name);	113	return attributes.get(name);
115	}	114	}
116		115
117	// implements the interface method	116	// implements the interface method
Lines 121-128 Link Here
121		120
122	// implements the interface method	121	// implements the interface method
123	public String[] getAttributeNames() {	122	public String[] getAttributeNames() {
124	return (String[])attributes.keySet()	123	return attributes.keySet().toArray(new String[attributes.size()]);
125	.toArray(new String[attributes.size()]);
126	}	124	}
127		125
128	/**	126	/**
Lines 137-160 Link Here
137		135
138	// implements the interface method	136	// implements the interface method
139	public IConfigurationElement[] getChildren() {	137	public IConfigurationElement[] getChildren() {
140	return (IConfigurationElement[])children.toArray(	138	return children.toArray(new IConfigurationElement[children.size()]);
141	new IConfigurationElement[children.size()]);
142	}	139	}
143		140
144	// implements the interface method	141	// implements the interface method
145	public IConfigurationElement[] getChildren(String name) {	142	public IConfigurationElement[] getChildren(String name) {
146	java.util.List result = new java.util.ArrayList(children.size());	143	java.util.List<IConfigurationElement> result =
147		144	new java.util.ArrayList<IConfigurationElement>(children.size());
148	for (Iterator iter = children.iterator(); iter.hasNext(); ) {
149	IConfigurationElement next = (IConfigurationElement)iter.next();
150		145
		146	for (IConfigurationElement next : children) {
151	if (next.getName().equals(name)) {	147	if (next.getName().equals(name)) {
152	result.add(next);	148	result.add(next);
153	}	149	}
154	}	150	}
155		151
156	return (IConfigurationElement[])result.toArray(	152	return result.toArray(new IConfigurationElement[result.size()]);
157	new IConfigurationElement[result.size()]);
158	}	153	}
159		154
160	/**	155	/**
Lines 217-225 Link Here
217	* constraintses	212	* constraintses
218	*/	213	*/
219	public void flatten(IConfigurationElement[] constraintses) throws CoreException {	214	public void flatten(IConfigurationElement[] constraintses) throws CoreException {
220	for (int i = 0; i < constraintses.length; i++) {	215	for (IConfigurationElement element : constraintses) {
221	flatten(constraintses[i]);	216	flatten(element);
222	removeChild(constraintses[i]);	217	removeChild(element);
223	}	218	}
224	}	219	}
225		220
Lines 247-254 Link Here
247	* files	242	* files
248	*/	243	*/
249	public void include(IConfigurationElement[] includes) throws CoreException {	244	public void include(IConfigurationElement[] includes) throws CoreException {
250	for (int i = 0; i < includes.length; i++) {	245	for (IConfigurationElement element : includes) {
251	include(includes[i]);	246	include(element);
252	}	247	}
253	}	248	}
254		249
Lines 322-333 Link Here
322	private void absorb(IConfigurationElement includedConstraints) {	317	private void absorb(IConfigurationElement includedConstraints) {
323	IConfigurationElement[] elements = includedConstraints.getChildren();	318	IConfigurationElement[] elements = includedConstraints.getChildren();
324		319
325	for (int i = 0; i < elements.length; i++) {	320	for (IConfigurationElement element : elements) {
326	addChild(elements[i]);	321	addChild(element);
327	}	322	}
328	}	323	}
329		324
330	// redefines the inherited method	325	// redefines the inherited method
		326	@Override
331	public String toString() {	327	public String toString() {
332	StringBuffer result = new StringBuffer(64);	328	StringBuffer result = new StringBuffer(64);
333		329

Lines 106-117 Link Here

(-)src/org/eclipse/emf/validation/internal/util/TextUtils.java (-17 / +19 lines)
106	ResourceSet resourceSet = resource.getResourceSet();	106	ResourceSet resourceSet = resource.getResourceSet();
107		107
108	if (resourceSet != null) {	108	if (resourceSet != null) {
109	List factories = resourceSet.getAdapterFactories();	109	List<AdapterFactory> factories = resourceSet.getAdapterFactories();
110		110
111	// iterate only as long as we don't find an adapter factory	111	// iterate only as long as we don't find an adapter factory
112	// that successfully adapted the eObject	112	// that successfully adapted the eObject
113	for (Iterator iter = factories.iterator(); iter.hasNext() && (result == null);) {	113	for (Iterator<AdapterFactory> iter = factories.iterator();
114	AdapterFactory next = (AdapterFactory) iter.next();	114	iter.hasNext() && (result == null);) {
		115
		116	AdapterFactory next = iter.next();
115		117
116	if (next.isFactoryForType(type)) {	118	if (next.isFactoryForType(type)) {
117	result = next.adapt(eObject, type);	119	result = next.adapt(eObject, type);
Lines 128-153 Link Here
128	* Applies the specified arguments to my message pattern.	130	* Applies the specified arguments to my message pattern.
129	*	131	*
130	* @param messagePattern the message pattern	132	* @param messagePattern the message pattern
131	* @param inputArgs the pattern arguments	133	* @param inputArg the pattern arguments
132	* @return the formatted message string	134	* @return the formatted message string
133	*	135	*
134	* @since 1.1	136	* @since 1.1
135	*/	137	*/
136	public static String formatMessage(String messagePattern, Object[] inputArgs) {	138	public static String formatMessage(String messagePattern, Object... inputArg) {
137	Object[] args = new Object[inputArgs.length];	139	Object[] args = new Object[inputArg.length];
138		140
139	for (int i = 0; i < args.length; i++) {	141	for (int i = 0; i < args.length; i++) {
140	Object inputArg = inputArgs[i];	142	Object next = inputArg[i];
141		143
142	if (inputArg instanceof Collection) {	144	if (next instanceof Collection) {
143	inputArg = formatMultiValue((Collection)inputArg);	145	next = formatMultiValue((Collection<?>) next);
144	} else if (inputArg instanceof Object[]) {	146	} else if (next instanceof Object[]) {
145	inputArg = formatMultiValue(Arrays.asList((Object[])inputArg));	147	next = formatMultiValue(Arrays.asList((Object[]) next));
146	} else {	148	} else {
147	inputArg = formatScalarValue(inputArg);	149	next = formatScalarValue(next);
148	}	150	}
149		151
150	args[i] = inputArg;	152	args[i] = next;
151	}	153	}
152		154
153	return NLS.bind(messagePattern, args);	155	return NLS.bind(messagePattern, args);
Lines 160-169 Link Here
160	* @param multiValuedArg the multiple objects	162	* @param multiValuedArg the multiple objects
161	* @return the string representation of the list	163	* @return the string representation of the list
162	*/	164	*/
163	private static String formatMultiValue(Collection multiValuedArg) {	165	private static String formatMultiValue(Collection<?> multiValuedArg) {
164	List args = new java.util.ArrayList(multiValuedArg);	166	List<Object> args = new java.util.ArrayList<Object>(multiValuedArg);
165		167
166	for (ListIterator iter = args.listIterator(); iter.hasNext(); ) {	168	for (ListIterator<Object> iter = args.listIterator(); iter.hasNext(); ) {
167	iter.set(formatScalarValue(iter.next()));	169	iter.set(formatScalarValue(iter.next()));
168	}	170	}
169		171
Lines 180-186 Link Here
180	*/	182	*/
181	private static String formatScalarValue(Object value) {	183	private static String formatScalarValue(Object value) {
182	if (value instanceof EObject) {	184	if (value instanceof EObject) {
183	return TextUtils.getText((EObject)value);	185	return TextUtils.getText((EObject) value);
184	} else {	186	} else {
185	return String.valueOf(value);	187	return String.valueOf(value);
186	}	188	}

Lines 16-22 Link Here

(-)src/org/eclipse/emf/validation/internal/util/Log.java (-4 / +3 lines)
16		16
17	import org.eclipse.core.runtime.IStatus;	17	import org.eclipse.core.runtime.IStatus;
18	import org.eclipse.core.runtime.Status;	18	import org.eclipse.core.runtime.Status;
19
20	import org.eclipse.emf.validation.internal.EMFModelValidationPlugin;	19	import org.eclipse.emf.validation.internal.EMFModelValidationPlugin;
21		20
22	/**	21	/**
Lines 487-493 Link Here
487	if (patternArgs instanceof Object[]) {	486	if (patternArgs instanceof Object[]) {
488	args = (Object[])patternArgs;	487	args = (Object[])patternArgs;
489	} else if (patternArgs instanceof Collection) {	488	} else if (patternArgs instanceof Collection) {
490	Collection argsCollection = (Collection)patternArgs;	489	Collection<?> argsCollection = (Collection<?>) patternArgs;
491		490
492	args = argsCollection.toArray(new Object[argsCollection.size()]);	491	args = argsCollection.toArray(new Object[argsCollection.size()]);
493	} else {	492	} else {
Lines 555-561 Link Here
555		554
556	log(severity,	555	log(severity,
557	code,	556	code,
558	EMFModelValidationPlugin.getMessage(messagePattern, patternArgKeys),	557	EMFModelValidationPlugin.getMessage(messagePattern,
559	exception);	558	(Object[]) patternArgKeys), exception);
560	}	559	}
561	}	560	}

Lines 124-130 Link Here

(-)src/org/eclipse/emf/validation/internal/util/Trace.java (-12 / +12 lines)
124	* @param methodName The name of method that is being entered.	124	* @param methodName The name of method that is being entered.
125	*/	125	*/
126	public static void entering(	126	public static void entering(
127	Class clazz,	127	Class<?> clazz,
128	String methodName) {	128	String methodName) {
129		129
130	EMFModelValidationPlugin.Tracing.entering(	130	EMFModelValidationPlugin.Tracing.entering(
Lines 142-148 Link Here
142	* @param parameter The parameter to the method being entered.	142	* @param parameter The parameter to the method being entered.
143	*/	143	*/
144	public static void entering(	144	public static void entering(
145	Class clazz,	145	Class<?> clazz,
146	String methodName,	146	String methodName,
147	Object parameter) {	147	Object parameter) {
148		148
Lines 162-168 Link Here
162	* @param parameters The parameters to the method being entered.	162	* @param parameters The parameters to the method being entered.
163	*/	163	*/
164	public static void entering(	164	public static void entering(
165	Class clazz,	165	Class<?> clazz,
166	String methodName,	166	String methodName,
167	Object[] parameters) {	167	Object[] parameters) {
168		168
Lines 183-189 Link Here
183	*/	183	*/
184	public static void entering(	184	public static void entering(
185	String option,	185	String option,
186	Class clazz,	186	Class<?> clazz,
187	String methodName) {	187	String methodName) {
188		188
189	if (shouldTraceEntering()) {	189	if (shouldTraceEntering()) {
Lines 206-212 Link Here
206	*/	206	*/
207	public static void entering(	207	public static void entering(
208	String option,	208	String option,
209	Class clazz,	209	Class<?> clazz,
210	String methodName,	210	String methodName,
211	Object parameter) {	211	Object parameter) {
212		212
Lines 231-237 Link Here
231	*/	231	*/
232	public static void entering(	232	public static void entering(
233	String option,	233	String option,
234	Class clazz,	234	Class<?> clazz,
235	String methodName,	235	String methodName,
236	Object[] parameters) {	236	Object[] parameters) {
237		237
Lines 251-257 Link Here
251	* @param methodName The name of method that is being exited.	251	* @param methodName The name of method that is being exited.
252	*/	252	*/
253	public static void exiting(	253	public static void exiting(
254	Class clazz,	254	Class<?> clazz,
255	String methodName) {	255	String methodName) {
256		256
257	EMFModelValidationPlugin.Tracing.exiting(	257	EMFModelValidationPlugin.Tracing.exiting(
Lines 269-275 Link Here
269	* @param returnValue The return value of the method being exited.	269	* @param returnValue The return value of the method being exited.
270	*/	270	*/
271	public static void exiting(	271	public static void exiting(
272	Class clazz,	272	Class<?> clazz,
273	String methodName,	273	String methodName,
274	Object returnValue) {	274	Object returnValue) {
275		275
Lines 290-296 Link Here
290	*/	290	*/
291	public static void exiting(	291	public static void exiting(
292	String option,	292	String option,
293	Class clazz,	293	Class<?> clazz,
294	String methodName) {	294	String methodName) {
295		295
296	if (shouldTraceExiting()) {	296	if (shouldTraceExiting()) {
Lines 313-319 Link Here
313	*/	313	*/
314	public static void exiting(	314	public static void exiting(
315	String option,	315	String option,
316	Class clazz,	316	Class<?> clazz,
317	String methodName,	317	String methodName,
318	Object returnValue) {	318	Object returnValue) {
319		319
Lines 336-342 Link Here
336	* @param throwable The throwable that is being caught.	336	* @param throwable The throwable that is being caught.
337	*/	337	*/
338	public static void catching(	338	public static void catching(
339	Class clazz,	339	Class<?> clazz,
340	String methodName,	340	String methodName,
341	Throwable throwable) {	341	Throwable throwable) {
342		342
Lines 357-363 Link Here
357	* @param throwable The throwable that is being thrown.	357	* @param throwable The throwable that is being thrown.
358	*/	358	*/
359	public static void throwing(	359	public static void throwing(
360	Class clazz,	360	Class<?> clazz,
361	String methodName,	361	String methodName,
362	Throwable throwable) {	362	Throwable throwable) {
363		363

Lines 49-55 Link Here

(-)src/org/eclipse/emf/validation/internal/util/JavaConstraintParser.java (-3 / +5 lines)
49	* the single-instance model of {@link AbstractModelConstraint} any class	49	* the single-instance model of {@link AbstractModelConstraint} any class
50	* implementing one or more ad hoc validation method signatures.	50	* implementing one or more ad hoc validation method signatures.
51	*/	51	*/
52	private static final Map constraintImplementationMap = new java.util.HashMap();	52	private static final Map<Class<?>, Object> constraintImplementationMap =
		53	new java.util.HashMap<Class<?>, Object>();
53		54
54	/**	55	/**
55	* Adapts instances of {@link AbstractModelConstraint} to the internal	56	* Adapts instances of {@link AbstractModelConstraint} to the internal
Lines 112-117 Link Here
112	descriptor);	113	descriptor);
113	}	114	}
114		115
		116	@SuppressWarnings("deprecation")
115	public IModelConstraint parseConstraint(IXmlConstraintDescriptor descriptor)	117	public IModelConstraint parseConstraint(IXmlConstraintDescriptor descriptor)
116	throws ConstraintParserException {	118	throws ConstraintParserException {
117		119
Lines 155-161 Link Here
155	Bundle bundle = Platform.getBundle(bundleName);	157	Bundle bundle = Platform.getBundle(bundleName);
156		158
157	try {	159	try {
158	Class resultType = bundle.loadClass(className);	160	Class<?> resultType = bundle.loadClass(className);
159		161
160	if (AbstractModelConstraint.class.isAssignableFrom(resultType)) {	162	if (AbstractModelConstraint.class.isAssignableFrom(resultType)) {
161	// instantiate the class extending AbstractModelConstraint	163	// instantiate the class extending AbstractModelConstraint
Lines 212-218 Link Here
212	* @throws IllegalAccessException if the instance needs to be created	214	* @throws IllegalAccessException if the instance needs to be created
213	* and the default constructor is not accessible	215	* and the default constructor is not accessible
214	*/	216	*/
215	static Object getInstance(Class constraintClass)	217	static Object getInstance(Class<?> constraintClass)
216	throws InstantiationException, IllegalAccessException {	218	throws InstantiationException, IllegalAccessException {
217		219
218	Object result = constraintImplementationMap.get(constraintClass);	220	Object result = constraintImplementationMap.get(constraintClass);

Lines 13-19 Link Here

(-)src/org/eclipse/emf/validation/model/CategoryManager.java (-16 / +15 lines)
13	package org.eclipse.emf.validation.model;	13	package org.eclipse.emf.validation.model;
14		14
15	import java.util.Collection;	15	import java.util.Collection;
16	import java.util.Iterator;
17	import java.util.SortedSet;	16	import java.util.SortedSet;
18		17
19	import org.eclipse.core.runtime.IConfigurationElement;	18	import org.eclipse.core.runtime.IConfigurationElement;
Lines 76-82 Link Here
76	* @return an unmodifiable set of {@link Category}s, sorted by their	75	* @return an unmodifiable set of {@link Category}s, sorted by their
77	* names	76	* names
78	*/	77	*/
79	public SortedSet getTopLevelCategories() {	78	public SortedSet<Category> getTopLevelCategories() {
80	return globalCategory.getChildren();	79	return globalCategory.getChildren();
81	}	80	}
82		81
Lines 174-190 Link Here
174	}	173	}
175		174
176	// first, recursively remove the child categories	175	// first, recursively remove the child categories
177	Collection children = new java.util.ArrayList(category.getChildren());	176	Collection<Category> children = category.getChildren();
178	for (Iterator iter = children.iterator(); iter.hasNext();) {	177	Category[] childrenArray = children.toArray(new Category[children.size()]);
179	removeCategory((Category)iter.next());	178	for (Category child : childrenArray) {
		179	removeCategory(child);
180	}	180	}
181		181
182	// purge the constraints from this category, so that they know they	182	// purge the constraints from this category, so that they know they
183	// are no longer in it	183	// are no longer in it
184	Collection constraints = new java.util.ArrayList(	184	Collection<IConstraintDescriptor> constraints = category.getConstraints();
185	category.getConstraints());	185	IConstraintDescriptor[] constraintsArray = constraints.toArray(
186	for (Iterator iter = constraints.iterator(); iter.hasNext();) {	186	new IConstraintDescriptor[constraints.size()]);
187	category.removeConstraint((IConstraintDescriptor)iter.next());	187	for (IConstraintDescriptor constraint : constraintsArray) {
		188	category.removeConstraint(constraint);
188	}	189	}
189		190
190	// finally, remove the category from its parent	191	// finally, remove the category from its parent
Lines 234-242 Link Here
234	EMFModelValidationPlugin.CONSTRAINT_PROVIDERS_EXT_P_NAME)	235	EMFModelValidationPlugin.CONSTRAINT_PROVIDERS_EXT_P_NAME)
235	.getConfigurationElements();	236	.getConfigurationElements();
236		237
237	for (int i = 0; i < elements.length; i++) {	238	for (IConfigurationElement next : elements) {
238	IConfigurationElement next = elements[i];
239
240	if (next.getName().equals(XmlConfig.E_CATEGORY)) {	239	if (next.getName().equals(XmlConfig.E_CATEGORY)) {
241	loadCategories(globalCategory, next);	240	loadCategories(globalCategory, next);
242	}	241	}
Lines 272-280 Link Here
272	IConfigurationElement[] subcategories = element.getChildren(	271	IConfigurationElement[] subcategories = element.getChildren(
273	XmlConfig.E_CATEGORY);	272	XmlConfig.E_CATEGORY);
274		273
275	for (int i = 0; i < subcategories.length; i++) {	274	for (IConfigurationElement element2 : subcategories) {
276	// recursively load the child categories, if any	275	// recursively load the child categories, if any
277	loadCategories(category, subcategories[i]);	276	loadCategories(category, element2);
278	}	277	}
279	} else {	278	} else {
280	Trace.trace(	279	Trace.trace(
Lines 289-296 Link Here
289	*	288	*
290	* @return the mandatory categories	289	* @return the mandatory categories
291	*/	290	*/
292	public Collection getMandatoryCategories() {	291	public Collection<Category> getMandatoryCategories() {
293	Collection result = new java.util.ArrayList();	292	Collection<Category> result = new java.util.ArrayList<Category>();
294		293
295	globalCategory.getMandatoryCategories(result);	294	globalCategory.getMandatoryCategories(result);
296		295

Lines 60-66 Link Here

(-)src/org/eclipse/emf/validation/model/ConstraintStatus.java (-29 / +30 lines)
60	private final IModelConstraint constraint;	60	private final IModelConstraint constraint;
61	private EObject target;	61	private EObject target;
62		62
63	private Set resultLocus;	63	private Set<EObject> resultLocus;
64		64
65	/**	65	/**
66	* Initializes me as a failure of the specified <code>constraint</code>	66	* Initializes me as a failure of the specified <code>constraint</code>
Lines 76-82 Link Here
76	public ConstraintStatus(IModelConstraint constraint,	76	public ConstraintStatus(IModelConstraint constraint,
77	EObject target,	77	EObject target,
78	String message,	78	String message,
79	Set resultLocus) {	79	Set<? extends EObject> resultLocus) {
80	this(	80	this(
81	constraint,	81	constraint,
82	target,	82	target,
Lines 123-129 Link Here
123	int severity,	123	int severity,
124	int code,	124	int code,
125	String message,	125	String message,
126	Set resultLocus) {	126	Set<? extends EObject> resultLocus) {
127	super(severity, constraint.getDescriptor().getPluginId(), code, message, null);	127	super(severity, constraint.getDescriptor().getPluginId(), code, message, null);
128		128
129	assert constraint != null;	129	assert constraint != null;
Lines 135-142 Link Here
135		135
136	// unmodifiable defensive copy	136	// unmodifiable defensive copy
137	this.resultLocus = (resultLocus != null)	137	this.resultLocus = (resultLocus != null)
138	? Collections.unmodifiableSet(new java.util.HashSet(resultLocus))	138	? Collections.unmodifiableSet(new java.util.HashSet<EObject>(resultLocus))
139	: Collections.EMPTY_SET;	139	: Collections.<EObject>emptySet();
140	}	140	}
141		141
142	/**	142	/**
Lines 174-182 Link Here
174	public static ConstraintStatus createStatus(	174	public static ConstraintStatus createStatus(
175	IValidationContext ctx,	175	IValidationContext ctx,
176	EObject target,	176	EObject target,
177	Collection resultLocus,	177	Collection<? extends EObject> resultLocus,
178	String messagePattern,	178	String messagePattern,
179	Object[] messageArguments) {	179	Object... messageArguments) {
180		180
181	IConstraintDescriptor desc = ConstraintRegistry.getInstance().getDescriptor(	181	IConstraintDescriptor desc = ConstraintRegistry.getInstance().getDescriptor(
182	ctx.getCurrentConstraintId());	182	ctx.getCurrentConstraintId());
Lines 224-248 Link Here
224	public static ConstraintStatus createStatus(	224	public static ConstraintStatus createStatus(
225	IValidationContext ctx,	225	IValidationContext ctx,
226	EObject target,	226	EObject target,
227	Collection resultLocus,	227	Collection<? extends EObject> resultLocus,
228	int severity,	228	int severity,
229	int errorCode,	229	int errorCode,
230	String messagePattern,	230	String messagePattern,
231	Object[] messageArguments) {	231	Object... messageArguments) {
232		232
233	// need a prototype status to get certain critical information, such	233	// need a prototype status to get certain critical information, such
234	// as the constraint object and target	234	// as the constraint object and target
235	ConstraintStatus result = (ConstraintStatus) ctx.createFailureStatus(null);	235	ConstraintStatus result = (ConstraintStatus) ctx.createFailureStatus();
236		236
237	if (target != null) {	237	if (target != null) {
238	result.target = target;	238	result.target = target;
239	}	239	}
240		240
241	Set results;	241	Set<EObject> results;
242	if (resultLocus == null) {	242	if (resultLocus == null) {
243	results = Collections.singleton(result.getTarget());	243	results = Collections.singleton(result.getTarget());
244	} else {	244	} else {
245	results = new java.util.HashSet(resultLocus);	245	results = new java.util.HashSet<EObject>(resultLocus);
246	if (!results.contains(result.getTarget())) {	246	if (!results.contains(result.getTarget())) {
247	results.add(result.getTarget());	247	results.add(result.getTarget());
248	}	248	}
Lines 293-301 Link Here
293	*/	293	*/
294	public static ConstraintStatus createStatus(	294	public static ConstraintStatus createStatus(
295	IValidationContext ctx,	295	IValidationContext ctx,
296	Collection resultLocus,	296	Collection<? extends EObject> resultLocus,
297	String messagePattern,	297	String messagePattern,
298	Object[] messageArguments) {	298	Object... messageArguments) {
299		299
300	IConstraintDescriptor desc = ConstraintRegistry.getInstance().getDescriptor(	300	IConstraintDescriptor desc = ConstraintRegistry.getInstance().getDescriptor(
301	ctx.getCurrentConstraintId());	301	ctx.getCurrentConstraintId());
Lines 341-351 Link Here
341	*/	341	*/
342	public static ConstraintStatus createStatus(	342	public static ConstraintStatus createStatus(
343	IValidationContext ctx,	343	IValidationContext ctx,
344	Collection resultLocus,	344	Collection<? extends EObject> resultLocus,
345	int severity,	345	int severity,
346	int errorCode,	346	int errorCode,
347	String messagePattern,	347	String messagePattern,
348	Object[] messageArguments) {	348	Object... messageArguments) {
349	return createStatus(ctx, null, resultLocus,	349	return createStatus(ctx, null, resultLocus,
350	severity, errorCode,	350	severity, errorCode,
351	messagePattern, messageArguments);	351	messagePattern, messageArguments);
Lines 382-399 Link Here
382	public static IStatus createSuccessStatus(	382	public static IStatus createSuccessStatus(
383	IValidationContext ctx,	383	IValidationContext ctx,
384	EObject target,	384	EObject target,
385	Collection resultLocus) {	385	Collection<? extends EObject> resultLocus) {
386	IStatus status = ctx.createSuccessStatus();	386	IStatus status = ctx.createSuccessStatus();
387		387
388	if (status instanceof IConstraintStatus) {	388	if (status instanceof IConstraintStatus) {
389	IConstraintStatus successStatus = (IConstraintStatus)status;	389	IConstraintStatus successStatus = (IConstraintStatus)status;
390	ConstraintStatus constraintStatus = new ConstraintStatus(successStatus.getConstraint(), target);	390	ConstraintStatus constraintStatus = new ConstraintStatus(successStatus.getConstraint(), target);
391		391
392	Set results;	392	Set<EObject> results;
393	if (resultLocus == null) {	393	if (resultLocus == null) {
394	results = Collections.singleton(target);	394	results = Collections.singleton(target);
395	} else {	395	} else {
396	results = new java.util.HashSet(resultLocus);	396	results = new java.util.HashSet<EObject>(resultLocus);
397	if (!results.contains(target)) {	397	if (!results.contains(target)) {
398	results.add(target);	398	results.add(target);
399	}	399	}
Lines 430-436 Link Here
430	*	430	*
431	* @see #createMultiStatus(IValidationContext, String, Object[], Collection)	431	* @see #createMultiStatus(IValidationContext, String, Object[], Collection)
432	*/	432	*/
433	public static IStatus createMultiStatus(IValidationContext ctx, Collection statuses) {	433	public static IStatus createMultiStatus(IValidationContext ctx,
		434	Collection<? extends IStatus> statuses) {
434	return createMultiStatus(	435	return createMultiStatus(
435	ctx,	436	ctx,
436	ValidationMessages.eval_some_fail_WARN_, null,	437	ValidationMessages.eval_some_fail_WARN_, null,
Lines 470-481 Link Here
470	public static IStatus createMultiStatus(	471	public static IStatus createMultiStatus(
471	IValidationContext ctx,	472	IValidationContext ctx,
472	String messagePattern, Object[] messageArguments,	473	String messagePattern, Object[] messageArguments,
473	Collection statuses) {	474	Collection<? extends IStatus> statuses) {
474	if (statuses == null \|\| statuses.isEmpty()) {	475	if (statuses == null \|\| statuses.isEmpty()) {
475	throw new IllegalArgumentException("no statuses to aggregate"); //$NON-NLS-1$	476	throw new IllegalArgumentException("no statuses to aggregate"); //$NON-NLS-1$
476	}	477	}
477		478
478	IStatus[] children = (IStatus[]) statuses.toArray(new IStatus[statuses.size()]);	479	IStatus[] children = statuses.toArray(new IStatus[statuses.size()]);
479		480
480	IConstraintDescriptor desc = ConstraintRegistry.getInstance().getDescriptor(	481	IConstraintDescriptor desc = ConstraintRegistry.getInstance().getDescriptor(
481	ctx.getCurrentConstraintId());	482	ctx.getCurrentConstraintId());
Lines 518-524 Link Here
518	* successful validation, the result is an empty collection. The result	519	* successful validation, the result is an empty collection. The result
519	* is never <code>null</code>	520	* is never <code>null</code>
520	*/	521	*/
521	public final Set getResultLocus() {	522	public final Set<EObject> getResultLocus() {
522	return resultLocus;	523	return resultLocus;
523	}	524	}
524		525
Lines 527-542 Link Here
527	implements IConstraintStatus {	528	implements IConstraintStatus {
528	private final IModelConstraint constraint;	529	private final IModelConstraint constraint;
529	private final EObject target;	530	private final EObject target;
530	private final Set resultLocus;	531	private final Set<EObject> resultLocus;
531		532
532	Multi(String pluginId, int code, IStatus[] children, String message) {	533	Multi(String pluginId, int code, IStatus[] children, String message) {
533	super(pluginId, code, children, message, null);	534	super(pluginId, code, children, message, null);
534		535
535	IConstraintStatus prototype = null;	536	IConstraintStatus prototype = null;
536		537
537	for (int i = 0; i < children.length; i++) {	538	for (IStatus element : children) {
538	if (children[i] instanceof IConstraintStatus) {	539	if (element instanceof IConstraintStatus) {
539	prototype = (IConstraintStatus) children[i];	540	prototype = (IConstraintStatus) element;
540	break;	541	break;
541	}	542	}
542	}	543	}
Lines 544-550 Link Here
544	if (prototype == null) {	545	if (prototype == null) {
545	constraint = null;	546	constraint = null;
546	target = null;	547	target = null;
547	resultLocus = Collections.EMPTY_SET;	548	resultLocus = Collections.emptySet();
548	} else {	549	} else {
549	constraint = prototype.getConstraint();	550	constraint = prototype.getConstraint();
550	target = prototype.getTarget();	551	target = prototype.getTarget();
Lines 560-566 Link Here
560	return target;	561	return target;
561	}	562	}
562		563
563	public Set getResultLocus() {	564	public Set<EObject> getResultLocus() {
564	return resultLocus;	565	return resultLocus;
565	}	566	}
566	}	567	}

Lines 54-60 Link Here

(-)src/org/eclipse/emf/validation/internal/emfadapter/EMFConstraintAdapter.java (-10 / +10 lines)
54	* since the EMF APIs have no access to it and there is nothing else in	54	* since the EMF APIs have no access to it and there is nothing else in
55	* this adapter layer maintains a reference to it.	55	* this adapter layer maintains a reference to it.
56	*/	56	*/
57	private static final Map contextMapCache = new java.util.WeakHashMap();	57	private static final Map<IValidationContext, Map<Object, Object>> contextMapCache =
		58	new java.util.WeakHashMap<IValidationContext, Map<Object,Object>>();
58		59
59	private final IConstraintDescriptor descriptor;	60	private final IConstraintDescriptor descriptor;
60	private final Method validationMethod;	61	private final Method validationMethod;
Lines 88-94 Link Here
88	(EMFValidationContextAdapter)validationArgs[0];	89	(EMFValidationContextAdapter)validationArgs[0];
89		90
90	ctxAdapter.setAdaptedContext(ctx);	91	ctxAdapter.setAdaptedContext(ctx);
91	validationArgs[1] = getEmfContextFor(ctx);	92	validationArgs[1] = getEMFContextFor(ctx);
92		93
93	try {	94	try {
94	boolean success = ((Boolean)validationMethod.invoke(	95	boolean success = ((Boolean)validationMethod.invoke(
Lines 131-137 Link Here
131	private IStatus fail(EMFValidationContextAdapter ctxAdapter) {	132	private IStatus fail(EMFValidationContextAdapter ctxAdapter) {
132	final IValidationContext ctx = ctxAdapter.getAdaptedContext();	133	final IValidationContext ctx = ctxAdapter.getAdaptedContext();
133		134
134	List resultLocus = new java.util.ArrayList(ctx.getResultLocus());	135	List<EObject> resultLocus = new java.util.ArrayList<EObject>(ctx.getResultLocus());
135	resultLocus.remove(ctx.getTarget());	136	resultLocus.remove(ctx.getTarget());
136		137
137	Diagnostic status = ctxAdapter.getLastStatus();	138	Diagnostic status = ctxAdapter.getLastStatus();
Lines 142-150 Link Here
142	// 1 - the result locus minus the target(as a collection of	143	// 1 - the result locus minus the target(as a collection of
143	// model elements)	144	// model elements)
144	return ctx.createFailureStatus(	145	return ctx.createFailureStatus(
145	new Object[] {
146	(status == null) ? null : status.getMessage(),	146	(status == null) ? null : status.getMessage(),
147	resultLocus});	147	resultLocus);
148	}	148	}
149		149
150	/**	150	/**
Lines 164-171 Link Here
164	getDescriptor().getStatusCode(),	164	getDescriptor().getStatusCode(),
165	EMFModelValidationPlugin.getMessage(	165	EMFModelValidationPlugin.getMessage(
166	ValidationMessages.emfadapter_disabled_WARN_,	166	ValidationMessages.emfadapter_disabled_WARN_,
167	new Object[] {getDescriptor().getName()}),	167	getDescriptor().getName()),
168	Collections.EMPTY_SET);	168	Collections.<EObject>emptySet());
169		169
170	EMFModelValidationPlugin.getPlugin().getLog().log(	170	EMFModelValidationPlugin.getPlugin().getLog().log(
171	new Status(	171	new Status(
Lines 185-195 Link Here
185	* @param ctx our validation context	185	* @param ctx our validation context
186	* @return the corresponding EMF validation context	186	* @return the corresponding EMF validation context
187	*/	187	*/
188	private static Map getEmfContextFor(IValidationContext ctx) {	188	private static Map<Object, Object> getEMFContextFor(IValidationContext ctx) {
189	Map result = (Map) contextMapCache.get(ctx);	189	Map<Object, Object> result = contextMapCache.get(ctx);
190		190
191	if (result == null) {	191	if (result == null) {
192	result = new java.util.HashMap();	192	result = new java.util.HashMap<Object, Object>();
193		193
194	// add a substitution label provider for good measure	194	// add a substitution label provider for good measure
195	result.put(	195	result.put(

Lines 16-22 Link Here

(-)src/org/eclipse/emf/validation/EMFEventType.java (-12 / +10 lines)
16	import java.util.ArrayList;	16	import java.util.ArrayList;
17	import java.util.Arrays;	17	import java.util.Arrays;
18	import java.util.Collections;	18	import java.util.Collections;
19	import java.util.Iterator;
20	import java.util.List;	19	import java.util.List;
21	import java.util.Map;	20	import java.util.Map;
22		21
Lines 47-53 Link Here
47		46
48	private static int nextNotificationTypeCode = 0;	47	private static int nextNotificationTypeCode = 0;
49		48
50	private static final Map nameToInstance = new java.util.HashMap();	49	private static final Map<String, EMFEventType> nameToInstance =
		50	new java.util.HashMap<String, EMFEventType>();
51		51
52	/**	52	/**
53	* The EMF "Add" event (corresponds to {@link Notification#ADD}).	53	* The EMF "Add" event (corresponds to {@link Notification#ADD}).
Lines 142-148 Link Here
142	-1);	142	-1);
143		143
144	/** All of my values. */	144	/** All of my values. */
145	private static final List predefinedInstances = Collections.unmodifiableList(	145	private static final List<EMFEventType> predefinedInstances = Collections.unmodifiableList(
146	Arrays.asList(new EMFEventType[]{	146	Arrays.asList(new EMFEventType[]{
147	ADD,	147	ADD,
148	ADD_MANY,	148	ADD_MANY,
Lines 157-163 Link Here
157	NULL,	157	NULL,
158	}));	158	}));
159		159
160	private static final List instances = new ArrayList(predefinedInstances);	160	private static final List<EMFEventType> instances = new ArrayList<EMFEventType>(
		161	predefinedInstances);
161		162
162	private final String name;	163	private final String name;
163	private final boolean featureSpecific;	164	private final boolean featureSpecific;
Lines 224-232 Link Here
224	public static EMFEventType getInstance(String name) {	225	public static EMFEventType getInstance(String name) {
225	EMFEventType result = NULL;	226	EMFEventType result = NULL;
226		227
227	for (Iterator iter = instances.iterator(); iter.hasNext(); ) {	228	for (EMFEventType next : instances) {
228	EMFEventType next = (EMFEventType)iter.next();
229
230	if (next.getName().equalsIgnoreCase(name)) {	229	if (next.getName().equalsIgnoreCase(name)) {
231	result = next;	230	result = next;
232	break;	231	break;
Lines 247-255 Link Here
247	public static EMFEventType getInstance(int code) {	246	public static EMFEventType getInstance(int code) {
248	EMFEventType result = NULL;	247	EMFEventType result = NULL;
249		248
250	for (Iterator iter = instances.iterator(); iter.hasNext(); ) {	249	for (EMFEventType next : instances) {
251	EMFEventType next = (EMFEventType)iter.next();
252
253	if (next.toNotificationType() == code) {	250	if (next.toNotificationType() == code) {
254	result = next;	251	result = next;
255	break;	252	break;
Lines 264-270 Link Here
264	*	261	*
265	* @return all values	262	* @return all values
266	*/	263	*/
267	public static final List getAllInstances() {	264	public static final List<EMFEventType> getAllInstances() {
268	return instances;	265	return instances;
269	}	266	}
270		267
Lines 276-282 Link Here
276	*	273	*
277	* @return all predefined values	274	* @return all predefined values
278	*/	275	*/
279	public static final List getPredefinedInstances() {	276	public static final List<EMFEventType> getPredefinedInstances() {
280	return predefinedInstances;	277	return predefinedInstances;
281	}	278	}
282		279
Lines 337-342 Link Here
337	}	334	}
338		335
339	// re-implements the inherited method	336	// re-implements the inherited method
		337	@Override
340	public String toString() {	338	public String toString() {
341	return getName();	339	return getName();
342	}	340	}

Lines 1-5 Link Here

(-)src/org/eclipse/emf/validation/IValidationContext.java (-7 / +8 lines)
1	/******************************************************************************	1	/******************************************************************************
2	* Copyright (c) 2003, 2006 IBM Corporation and others.	2	* Copyright (c) 2003, 2007 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 17-22 Link Here
17	import java.util.Set;	17	import java.util.Set;
18		18
19	import org.eclipse.core.runtime.IStatus;	19	import org.eclipse.core.runtime.IStatus;
		20	import org.eclipse.emf.common.notify.Notification;
20	import org.eclipse.emf.ecore.EObject;	21	import org.eclipse.emf.ecore.EObject;
21	import org.eclipse.emf.ecore.EStructuralFeature;	22	import org.eclipse.emf.ecore.EStructuralFeature;
22	import org.eclipse.emf.validation.model.ConstraintStatus;	23	import org.eclipse.emf.validation.model.ConstraintStatus;
Lines 90-96 Link Here
90	* @return the raw {@link org.eclipse.emf.common.notify.Notification}s being validated, or an empty	91	* @return the raw {@link org.eclipse.emf.common.notify.Notification}s being validated, or an empty
91	* list if this is a batch validation. This list is not modifiable	92	* list if this is a batch validation. This list is not modifiable
92	*/	93	*/
93	List getAllEvents();	94	List<Notification> getAllEvents();
94		95
95	/**	96	/**
96	* In the case of a live constraint evaluation, obtains the particular	97	* In the case of a live constraint evaluation, obtains the particular
Lines 174-180 Link Here
174	*	175	*
175	* @see #skipCurrentConstraintFor(EObject)	176	* @see #skipCurrentConstraintFor(EObject)
176	*/	177	*/
177	void skipCurrentConstraintForAll(Collection eObjects);	178	void skipCurrentConstraintForAll(Collection<?> eObjects);
178		179
179	/**	180	/**
180	* <p>	181	* <p>
Lines 234-240 Link Here
234	*	235	*
235	* @see #addResult(EObject)	236	* @see #addResult(EObject)
236	*/	237	*/
237	Set getResultLocus();	238	Set<EObject> getResultLocus();
238		239
239	/**	240	/**
240	* Adds a result to the result locus of the current constraint. The result	241	* Adds a result to the result locus of the current constraint. The result
Lines 257-263 Link Here
257	*	258	*
258	* @see #addResult(EObject)	259	* @see #addResult(EObject)
259	*/	260	*/
260	void addResults(Collection eObjects);	261	void addResults(Collection<? extends EObject> eObjects);
261		262
262	/**	263	/**
263	* Creates a status object indicating successful evaluation of the	264	* Creates a status object indicating successful evaluation of the
Lines 273-282 Link Here
273	* the severity, error code, and message defined in the constraint meta-data	274	* the severity, error code, and message defined in the constraint meta-data
274	* in the XML.	275	* in the XML.
275	*	276	*
276	* @param messageArguments the positional {0}, {1}, etc. arguments to	277	* @param messageArgument the positional {0}, {1}, etc. arguments to
277	* replace in the message pattern (may by <code>null</code> if none	278	* replace in the message pattern (may by <code>null</code> if none
278	* are needed)	279	* are needed)
279	* @return the status indicating a constraint violation	280	* @return the status indicating a constraint violation
280	*/	281	*/
281	IStatus createFailureStatus(Object[] messageArguments);	282	IStatus createFailureStatus(Object... messageArgument);
282	}	283	}

Lines 91-103 Link Here

(-)src/org/eclipse/emf/validation/marker/MarkerUtil.java (-6 / +7 lines)
91	public void run(IProgressMonitor m)	91	public void run(IProgressMonitor m)
92	throws CoreException {	92	throws CoreException {
93		93
94	final Map visitedResources = new HashMap();	94	final Map<URI, IFile> visitedResources = new HashMap<URI, IFile>();
95		95
96	if (validationStatus.isMultiStatus()) {	96	if (validationStatus.isMultiStatus()) {
97	IStatus[] children = validationStatus.getChildren();	97	IStatus[] children = validationStatus.getChildren();
98	for (int i=0; i<children.length ;i++) {	98	for (IStatus element : children) {
99	if (children[i] instanceof IConstraintStatus) {	99	if (element instanceof IConstraintStatus) {
100	createMarker((IConstraintStatus)children[i], markerType, configurator, visitedResources);	100	createMarker((IConstraintStatus)element, markerType, configurator, visitedResources);
101	}	101	}
102	}	102	}
103	} else if (validationStatus instanceof IConstraintStatus) {	103	} else if (validationStatus instanceof IConstraintStatus) {
Lines 110-116 Link Here
110	}	110	}
111		111
112	private static void createMarker(IConstraintStatus status,	112	private static void createMarker(IConstraintStatus status,
113	String markerType, IMarkerConfigurator configurator, Map visitedResources) throws CoreException {	113	String markerType, IMarkerConfigurator configurator,
		114	Map<URI, IFile> visitedResources) throws CoreException {
114		115
115	Resource r = status.getTarget().eResource();	116	Resource r = status.getTarget().eResource();
116	URI uri = r.getURI();	117	URI uri = r.getURI();
Lines 118-124 Link Here
118	// Normalize the URI to something that we can deal with like file or platform scheme	119	// Normalize the URI to something that we can deal with like file or platform scheme
119	uri = r.getResourceSet().getURIConverter().normalize(uri);	120	uri = r.getResourceSet().getURIConverter().normalize(uri);
120		121
121	IFile file = (IFile)visitedResources.get(uri);	122	IFile file = visitedResources.get(uri);
122		123
123	if (file == null) {	124	if (file == null) {
124	if (PLATFORM_SCHEME.equals(uri.scheme()) && uri.segmentCount() > 1	125	if (PLATFORM_SCHEME.equals(uri.scheme()) && uri.segmentCount() > 1

Lines 85-90 Link Here

(-)src/org/eclipse/emf/validation/xml/XmlConstraintProvider.java (-4 / +6 lines)
85	* @throws CoreException if the superclass implementation of this	85	* @throws CoreException if the superclass implementation of this
86	* method throws or on an error in accessing the <code>config</code>	86	* method throws or on an error in accessing the <code>config</code>
87	*/	87	*/
		88	@Override
88	public void setInitializationData(	89	public void setInitializationData(
89	IConfigurationElement config,	90	IConfigurationElement config,
90	String propertyName,	91	String propertyName,
Lines 95-108 Link Here
95	IConfigurationElement[] constraintses = config.getChildren(	96	IConfigurationElement[] constraintses = config.getChildren(
96	XmlConfig.E_CONSTRAINTS);	97	XmlConfig.E_CONSTRAINTS);
97		98
98	for (int i = 0; i < constraintses.length; i++) {	99	for (IConfigurationElement element : constraintses) {
99	IConfigurationElement next =	100	IConfigurationElement next =
100	XmlConfig.parseConstraintsWithIncludes(constraintses[i]);	101	XmlConfig.parseConstraintsWithIncludes(element);
101		102
102	IConfigurationElement[] configs = next.getChildren();	103	IConfigurationElement[] configs = next.getChildren();
103		104
104	for (int j = 0; j < configs.length; j++) {	105	for (IConfigurationElement element2 : configs) {
105	addConstraint(configs[j]);	106	addConstraint(element2);
106	}	107	}
107	}	108	}
108		109
Lines 115-120 Link Here
115	*	116	*
116	* @param config the <TT><constraint></TT> element	117	* @param config the <TT><constraint></TT> element
117	*/	118	*/
		119	@SuppressWarnings("deprecation")
118	private void addConstraint(IConfigurationElement config) {	120	private void addConstraint(IConfigurationElement config) {
119	final String contributorId = config	121	final String contributorId = config
120	.getDeclaringExtension()	122	.getDeclaringExtension()

Lines 1-7 Link Here

(-)src/ordersystem/impl/OrderSystemFactoryImpl.java (-8 / +42 lines)
1	/**	1	/**
2	* <copyright>	2	* <copyright>
3	*	3	*
4	* Copyright (c) 2005 IBM Corporation and others.	4	* Copyright (c) 2005, 2007 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials	5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	7	* which accompanies this distribution, and is available at
Lines 19-31 Link Here
19		19
20	import java.util.Date;	20	import java.util.Date;
21		21
22	import ordersystem.*;	22	import ordersystem.Account;
		23	import ordersystem.Address;
		24	import ordersystem.Customer;
		25	import ordersystem.InventoryItem;
		26	import ordersystem.LineItem;
		27	import ordersystem.Order;
		28	import ordersystem.OrderSystem;
		29	import ordersystem.OrderSystemFactory;
		30	import ordersystem.OrderSystemPackage;
		31	import ordersystem.Product;
		32	import ordersystem.Warehouse;
23		33
24	import org.eclipse.emf.ecore.EClass;	34	import org.eclipse.emf.ecore.EClass;
25	import org.eclipse.emf.ecore.EDataType;	35	import org.eclipse.emf.ecore.EDataType;
26	import org.eclipse.emf.ecore.EObject;	36	import org.eclipse.emf.ecore.EObject;
27		37	import org.eclipse.emf.ecore.EPackage;
28	import org.eclipse.emf.ecore.impl.EFactoryImpl;	38	import org.eclipse.emf.ecore.impl.EFactoryImpl;
		39	import org.eclipse.emf.ecore.plugin.EcorePlugin;
29		40
30	/**	41	/**
31	* <!-- begin-user-doc -->	42	* <!-- begin-user-doc -->
Lines 35-41 Link Here
35	*/	46	*/
36	public class OrderSystemFactoryImpl extends EFactoryImpl implements OrderSystemFactory {	47	public class OrderSystemFactoryImpl extends EFactoryImpl implements OrderSystemFactory {
37	/**	48	/**
38	* Creates and instance of the factory.	49	* Creates the default factory implementation.
		50	* <!-- begin-user-doc -->
		51	* <!-- end-user-doc -->
		52	* @generated
		53	*/
		54	public static OrderSystemFactory init() {
		55	try {
		56	OrderSystemFactory theOrderSystemFactory = (OrderSystemFactory)EPackage.Registry.INSTANCE.getEFactory("http:///ordersystem.ecore"); //$NON-NLS-1$
		57	if (theOrderSystemFactory != null) {
		58	return theOrderSystemFactory;
		59	}
		60	}
		61	catch (Exception exception) {
		62	EcorePlugin.INSTANCE.log(exception);
		63	}
		64	return new OrderSystemFactoryImpl();
		65	}
		66
		67	/**
		68	* Creates an instance of the factory.
39	* <!-- begin-user-doc -->	69	* <!-- begin-user-doc -->
40	* <!-- end-user-doc -->	70	* <!-- end-user-doc -->
41	* @generated	71	* @generated
Lines 49-55 Link Here
49	* <!-- end-user-doc -->	79	* <!-- end-user-doc -->
50	* @generated	80	* @generated
51	*/	81	*/
52	public EObject create(EClass eClass) {	82	@Override
		83	public EObject create(EClass eClass) {
53	switch (eClass.getClassifierID()) {	84	switch (eClass.getClassifierID()) {
54	case OrderSystemPackage.ORDER: return createOrder();	85	case OrderSystemPackage.ORDER: return createOrder();
55	case OrderSystemPackage.PRODUCT: return createProduct();	86	case OrderSystemPackage.PRODUCT: return createProduct();
Lines 70-76 Link Here
70	* <!-- end-user-doc -->	101	* <!-- end-user-doc -->
71	* @generated	102	* @generated
72	*/	103	*/
73	public Object createFromString(EDataType eDataType, String initialValue) {	104	@Override
		105	public Object createFromString(EDataType eDataType, String initialValue) {
74	switch (eDataType.getClassifierID()) {	106	switch (eDataType.getClassifierID()) {
75	case OrderSystemPackage.JAVA_DATE:	107	case OrderSystemPackage.JAVA_DATE:
76	return createJavaDateFromString(eDataType, initialValue);	108	return createJavaDateFromString(eDataType, initialValue);
Lines 84-90 Link Here
84	* <!-- end-user-doc -->	116	* <!-- end-user-doc -->
85	* @generated	117	* @generated
86	*/	118	*/
87	public String convertToString(EDataType eDataType, Object instanceValue) {	119	@Override
		120	public String convertToString(EDataType eDataType, Object instanceValue) {
88	switch (eDataType.getClassifierID()) {	121	switch (eDataType.getClassifierID()) {
89	case OrderSystemPackage.JAVA_DATE:	122	case OrderSystemPackage.JAVA_DATE:
90	return convertJavaDateToString(eDataType, instanceValue);	123	return convertJavaDateToString(eDataType, instanceValue);
Lines 222-228 Link Here
222	* @deprecated	255	* @deprecated
223	* @generated	256	* @generated
224	*/	257	*/
225	public static OrderSystemPackage getPackage() {	258	@Deprecated
		259	public static OrderSystemPackage getPackage() {
226	return OrderSystemPackage.eINSTANCE;	260	return OrderSystemPackage.eINSTANCE;
227	}	261	}
228	} //OrderSystemFactoryImpl	262	} //OrderSystemFactoryImpl

Lines 1-7 Link Here

(-)src/ordersystem/impl/OrderSystemImpl.java (-67 / +61 lines)
1	/**	1	/**
2	* <copyright>	2	* <copyright>
3	*	3	*
4	* Copyright (c) 2005 IBM Corporation and others.	4	* Copyright (c) 2005, 2007 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials	5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	7	* which accompanies this distribution, and is available at
Lines 27-42 Link Here
27		27
28	import org.eclipse.emf.common.notify.Notification;	28	import org.eclipse.emf.common.notify.Notification;
29	import org.eclipse.emf.common.notify.NotificationChain;	29	import org.eclipse.emf.common.notify.NotificationChain;
30
31	import org.eclipse.emf.common.util.EList;	30	import org.eclipse.emf.common.util.EList;
32
33	import org.eclipse.emf.ecore.EClass;	31	import org.eclipse.emf.ecore.EClass;
34	import org.eclipse.emf.ecore.EStructuralFeature;
35	import org.eclipse.emf.ecore.InternalEObject;	32	import org.eclipse.emf.ecore.InternalEObject;
36
37	import org.eclipse.emf.ecore.impl.ENotificationImpl;	33	import org.eclipse.emf.ecore.impl.ENotificationImpl;
38	import org.eclipse.emf.ecore.impl.EObjectImpl;	34	import org.eclipse.emf.ecore.impl.EObjectImpl;
39
40	import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;	35	import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
41	import org.eclipse.emf.ecore.util.InternalEList;	36	import org.eclipse.emf.ecore.util.InternalEList;
42		37
Lines 85-91 Link Here
85	* @generated	80	* @generated
86	* @ordered	81	* @ordered
87	*/	82	*/
88	protected EList customer = null;	83	protected EList<Customer> customer;
89		84
90	/**	85	/**
91	* The cached value of the '{@link #getProduct() <em>Product</em>}' containment reference list.	86	* The cached value of the '{@link #getProduct() <em>Product</em>}' containment reference list.
Lines 95-101 Link Here
95	* @generated	90	* @generated
96	* @ordered	91	* @ordered
97	*/	92	*/
98	protected EList product = null;	93	protected EList<Product> product;
99		94
100	/**	95	/**
101	* The cached value of the '{@link #getWarehouse() <em>Warehouse</em>}' containment reference list.	96	* The cached value of the '{@link #getWarehouse() <em>Warehouse</em>}' containment reference list.
Lines 105-111 Link Here
105	* @generated	100	* @generated
106	* @ordered	101	* @ordered
107	*/	102	*/
108	protected EList warehouse = null;	103	protected EList<Warehouse> warehouse;
109		104
110	/**	105	/**
111	* <!-- begin-user-doc -->	106	* <!-- begin-user-doc -->
Lines 121-128 Link Here
121	* <!-- end-user-doc -->	116	* <!-- end-user-doc -->
122	* @generated	117	* @generated
123	*/	118	*/
124	protected EClass eStaticClass() {	119	@Override
125	return OrderSystemPackage.eINSTANCE.getOrderSystem();	120	protected EClass eStaticClass() {
		121	return OrderSystemPackage.Literals.ORDER_SYSTEM;
126	}	122	}
127		123
128	/**	124	/**
Lines 151-159 Link Here
151	* <!-- end-user-doc -->	147	* <!-- end-user-doc -->
152	* @generated	148	* @generated
153	*/	149	*/
154	public EList getCustomer() {	150	public EList<Customer> getCustomer() {
155	if (customer == null) {	151	if (customer == null) {
156	customer = new EObjectContainmentWithInverseEList(Customer.class, this, OrderSystemPackage.ORDER_SYSTEM__CUSTOMER, OrderSystemPackage.CUSTOMER__OWNER);	152	customer = new EObjectContainmentWithInverseEList<Customer>(Customer.class, this, OrderSystemPackage.ORDER_SYSTEM__CUSTOMER, OrderSystemPackage.CUSTOMER__OWNER);
157	}	153	}
158	return customer;	154	return customer;
159	}	155	}
Lines 163-171 Link Here
163	* <!-- end-user-doc -->	159	* <!-- end-user-doc -->
164	* @generated	160	* @generated
165	*/	161	*/
166	public EList getProduct() {	162	public EList<Product> getProduct() {
167	if (product == null) {	163	if (product == null) {
168	product = new EObjectContainmentWithInverseEList(Product.class, this, OrderSystemPackage.ORDER_SYSTEM__PRODUCT, OrderSystemPackage.PRODUCT__OWNER);	164	product = new EObjectContainmentWithInverseEList<Product>(Product.class, this, OrderSystemPackage.ORDER_SYSTEM__PRODUCT, OrderSystemPackage.PRODUCT__OWNER);
169	}	165	}
170	return product;	166	return product;
171	}	167	}
Lines 175-238 Link Here
175	* <!-- end-user-doc -->	171	* <!-- end-user-doc -->
176	* @generated	172	* @generated
177	*/	173	*/
178	public EList getWarehouse() {	174	public EList<Warehouse> getWarehouse() {
179	if (warehouse == null) {	175	if (warehouse == null) {
180	warehouse = new EObjectContainmentWithInverseEList(Warehouse.class, this, OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE, OrderSystemPackage.WAREHOUSE__OWNER);	176	warehouse = new EObjectContainmentWithInverseEList<Warehouse>(Warehouse.class, this, OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE, OrderSystemPackage.WAREHOUSE__OWNER);
181	}	177	}
182	return warehouse;	178	return warehouse;
183	}	179	}
184		180
185	/**	181	/**
186	* <!-- begin-user-doc -->	182	* <!-- begin-user-doc -->
187	* <!-- end-user-doc -->	183	* <!-- end-user-doc -->
188	* @generated	184	* @generated
189	*/	185	*/
190	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {	186	@SuppressWarnings("unchecked")
191	if (featureID >= 0) {	187	@Override
192	switch (eDerivedStructuralFeatureID(featureID, baseClass)) {	188	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
193	case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:	189	switch (featureID) {
194	return ((InternalEList)getCustomer()).basicAdd(otherEnd, msgs);	190	case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:
195	case OrderSystemPackage.ORDER_SYSTEM__PRODUCT:	191	return ((InternalEList<InternalEObject>)(InternalEList<?>)getCustomer()).basicAdd(otherEnd, msgs);
196	return ((InternalEList)getProduct()).basicAdd(otherEnd, msgs);	192	case OrderSystemPackage.ORDER_SYSTEM__PRODUCT:
197	case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:	193	return ((InternalEList<InternalEObject>)(InternalEList<?>)getProduct()).basicAdd(otherEnd, msgs);
198	return ((InternalEList)getWarehouse()).basicAdd(otherEnd, msgs);	194	case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:
199	default:	195	return ((InternalEList<InternalEObject>)(InternalEList<?>)getWarehouse()).basicAdd(otherEnd, msgs);
200	return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
201	}
202	}	196	}
203	if (eContainer != null)	197	return super.eInverseAdd(otherEnd, featureID, msgs);
204	msgs = eBasicRemoveFromContainer(msgs);
205	return eBasicSetContainer(otherEnd, featureID, msgs);
206	}	198	}
207		199
208	/**	200	/**
209	* <!-- begin-user-doc -->	201	* <!-- begin-user-doc -->
210	* <!-- end-user-doc -->	202	* <!-- end-user-doc -->
211	* @generated	203	* @generated
212	*/	204	*/
213	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {	205	@Override
214	if (featureID >= 0) {	206	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
215	switch (eDerivedStructuralFeatureID(featureID, baseClass)) {	207	switch (featureID) {
216	case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:	208	case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:
217	return ((InternalEList)getCustomer()).basicRemove(otherEnd, msgs);	209	return ((InternalEList<?>)getCustomer()).basicRemove(otherEnd, msgs);
218	case OrderSystemPackage.ORDER_SYSTEM__PRODUCT:	210	case OrderSystemPackage.ORDER_SYSTEM__PRODUCT:
219	return ((InternalEList)getProduct()).basicRemove(otherEnd, msgs);	211	return ((InternalEList<?>)getProduct()).basicRemove(otherEnd, msgs);
220	case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:	212	case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:
221	return ((InternalEList)getWarehouse()).basicRemove(otherEnd, msgs);	213	return ((InternalEList<?>)getWarehouse()).basicRemove(otherEnd, msgs);
222	default:
223	return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
224	}
225	}	214	}
226	return eBasicSetContainer(null, featureID, msgs);	215	return super.eInverseRemove(otherEnd, featureID, msgs);
227	}	216	}
228		217
229	/**	218	/**
230	* <!-- begin-user-doc -->	219	* <!-- begin-user-doc -->
231	* <!-- end-user-doc -->	220	* <!-- end-user-doc -->
232	* @generated	221	* @generated
233	*/	222	*/
234	public Object eGet(EStructuralFeature eFeature, boolean resolve) {	223	@Override
235	switch (eDerivedStructuralFeatureID(eFeature)) {	224	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		225	switch (featureID) {
236	case OrderSystemPackage.ORDER_SYSTEM__VERSION:	226	case OrderSystemPackage.ORDER_SYSTEM__VERSION:
237	return new Integer(getVersion());	227	return new Integer(getVersion());
238	case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:	228	case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:
Lines 242-283 Link Here
242	case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:	232	case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:
243	return getWarehouse();	233	return getWarehouse();
244	}	234	}
245	return eDynamicGet(eFeature, resolve);	235	return super.eGet(featureID, resolve, coreType);
246	}	236	}
247		237
248	/**	238	/**
249	* <!-- begin-user-doc -->	239	* <!-- begin-user-doc -->
250	* <!-- end-user-doc -->	240	* <!-- end-user-doc -->
251	* @generated	241	* @generated
252	*/	242	*/
253	public void eSet(EStructuralFeature eFeature, Object newValue) {	243	@SuppressWarnings("unchecked")
254	switch (eDerivedStructuralFeatureID(eFeature)) {	244	@Override
		245	public void eSet(int featureID, Object newValue) {
		246	switch (featureID) {
255	case OrderSystemPackage.ORDER_SYSTEM__VERSION:	247	case OrderSystemPackage.ORDER_SYSTEM__VERSION:
256	setVersion(((Integer)newValue).intValue());	248	setVersion(((Integer)newValue).intValue());
257	return;	249	return;
258	case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:	250	case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:
259	getCustomer().clear();	251	getCustomer().clear();
260	getCustomer().addAll((Collection)newValue);	252	getCustomer().addAll((Collection<? extends Customer>)newValue);
261	return;	253	return;
262	case OrderSystemPackage.ORDER_SYSTEM__PRODUCT:	254	case OrderSystemPackage.ORDER_SYSTEM__PRODUCT:
263	getProduct().clear();	255	getProduct().clear();
264	getProduct().addAll((Collection)newValue);	256	getProduct().addAll((Collection<? extends Product>)newValue);
265	return;	257	return;
266	case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:	258	case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:
267	getWarehouse().clear();	259	getWarehouse().clear();
268	getWarehouse().addAll((Collection)newValue);	260	getWarehouse().addAll((Collection<? extends Warehouse>)newValue);
269	return;	261	return;
270	}	262	}
271	eDynamicSet(eFeature, newValue);	263	super.eSet(featureID, newValue);
272	}	264	}
273		265
274	/**	266	/**
275	* <!-- begin-user-doc -->	267	* <!-- begin-user-doc -->
276	* <!-- end-user-doc -->	268	* <!-- end-user-doc -->
277	* @generated	269	* @generated
278	*/	270	*/
279	public void eUnset(EStructuralFeature eFeature) {	271	@Override
280	switch (eDerivedStructuralFeatureID(eFeature)) {	272	public void eUnset(int featureID) {
		273	switch (featureID) {
281	case OrderSystemPackage.ORDER_SYSTEM__VERSION:	274	case OrderSystemPackage.ORDER_SYSTEM__VERSION:
282	setVersion(VERSION_EDEFAULT);	275	setVersion(VERSION_EDEFAULT);
283	return;	276	return;
Lines 291-306 Link Here
291	getWarehouse().clear();	284	getWarehouse().clear();
292	return;	285	return;
293	}	286	}
294	eDynamicUnset(eFeature);	287	super.eUnset(featureID);
295	}	288	}
296		289
297	/**	290	/**
298	* <!-- begin-user-doc -->	291	* <!-- begin-user-doc -->
299	* <!-- end-user-doc -->	292	* <!-- end-user-doc -->
300	* @generated	293	* @generated
301	*/	294	*/
302	public boolean eIsSet(EStructuralFeature eFeature) {	295	@Override
303	switch (eDerivedStructuralFeatureID(eFeature)) {	296	public boolean eIsSet(int featureID) {
		297	switch (featureID) {
304	case OrderSystemPackage.ORDER_SYSTEM__VERSION:	298	case OrderSystemPackage.ORDER_SYSTEM__VERSION:
305	return version != VERSION_EDEFAULT;	299	return version != VERSION_EDEFAULT;
306	case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:	300	case OrderSystemPackage.ORDER_SYSTEM__CUSTOMER:
Lines 310-319 Link Here
310	case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:	304	case OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE:
311	return warehouse != null && !warehouse.isEmpty();	305	return warehouse != null && !warehouse.isEmpty();
312	}	306	}
313	return eDynamicIsSet(eFeature);	307	return super.eIsSet(featureID);
314	}	308	}
315		309
316	/**	310	/**
317	* <!-- begin-user-doc -->	311	* <!-- begin-user-doc -->
318	* <!-- end-user-doc -->	312	* <!-- end-user-doc -->
319	*/	313	*/

Lines 1-7 Link Here

(-)src/ordersystem/impl/WarehouseImpl.java (-74 / +75 lines)
1	/**	1	/**
2	* <copyright>	2	* <copyright>
3	*	3	*
4	* Copyright (c) 2005 IBM Corporation and others.	4	* Copyright (c) 2005, 2007 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials	5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	7	* which accompanies this distribution, and is available at
Lines 27-42 Link Here
27		27
28	import org.eclipse.emf.common.notify.Notification;	28	import org.eclipse.emf.common.notify.Notification;
29	import org.eclipse.emf.common.notify.NotificationChain;	29	import org.eclipse.emf.common.notify.NotificationChain;
30
31	import org.eclipse.emf.common.util.EList;	30	import org.eclipse.emf.common.util.EList;
32
33	import org.eclipse.emf.ecore.EClass;	31	import org.eclipse.emf.ecore.EClass;
34	import org.eclipse.emf.ecore.EStructuralFeature;
35	import org.eclipse.emf.ecore.InternalEObject;	32	import org.eclipse.emf.ecore.InternalEObject;
36
37	import org.eclipse.emf.ecore.impl.ENotificationImpl;	33	import org.eclipse.emf.ecore.impl.ENotificationImpl;
38	import org.eclipse.emf.ecore.impl.EObjectImpl;	34	import org.eclipse.emf.ecore.impl.EObjectImpl;
39
40	import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;	35	import org.eclipse.emf.ecore.util.EObjectContainmentWithInverseEList;
41	import org.eclipse.emf.ecore.util.EcoreUtil;	36	import org.eclipse.emf.ecore.util.EcoreUtil;
42	import org.eclipse.emf.ecore.util.InternalEList;	37	import org.eclipse.emf.ecore.util.InternalEList;
Lines 86-92 Link Here
86	* @generated	81	* @generated
87	* @ordered	82	* @ordered
88	*/	83	*/
89	protected EList item = null;	84	protected EList<InventoryItem> item;
90		85
91	/**	86	/**
92	* The cached value of the '{@link #getLocation() <em>Location</em>}' containment reference.	87	* The cached value of the '{@link #getLocation() <em>Location</em>}' containment reference.
Lines 96-102 Link Here
96	* @generated	91	* @generated
97	* @ordered	92	* @ordered
98	*/	93	*/
99	protected Address location = null;	94	protected Address location;
100		95
101	/**	96	/**
102	* <!-- begin-user-doc -->	97	* <!-- begin-user-doc -->
Lines 112-119 Link Here
112	* <!-- end-user-doc -->	107	* <!-- end-user-doc -->
113	* @generated	108	* @generated
114	*/	109	*/
115	protected EClass eStaticClass() {	110	@Override
116	return OrderSystemPackage.eINSTANCE.getWarehouse();	111	protected EClass eStaticClass() {
		112	return OrderSystemPackage.Literals.WAREHOUSE;
117	}	113	}
118		114
119	/**	115	/**
Lines 144-150 Link Here
144	*/	140	*/
145	public OrderSystem getOwner() {	141	public OrderSystem getOwner() {
146	if (eContainerFeatureID != OrderSystemPackage.WAREHOUSE__OWNER) return null;	142	if (eContainerFeatureID != OrderSystemPackage.WAREHOUSE__OWNER) return null;
147	return (OrderSystem)eContainer;	143	return (OrderSystem)eContainer();
		144	}
		145
		146	/**
		147	* <!-- begin-user-doc -->
		148	* <!-- end-user-doc -->
		149	* @generated
		150	*/
		151	public NotificationChain basicSetOwner(OrderSystem newOwner, NotificationChain msgs) {
		152	msgs = eBasicSetContainer((InternalEObject)newOwner, OrderSystemPackage.WAREHOUSE__OWNER, msgs);
		153	return msgs;
148	}	154	}
149		155
150	/**	156	/**
Lines 153-167 Link Here
153	* @generated	159	* @generated
154	*/	160	*/
155	public void setOwner(OrderSystem newOwner) {	161	public void setOwner(OrderSystem newOwner) {
156	if (newOwner != eContainer \|\| (eContainerFeatureID != OrderSystemPackage.WAREHOUSE__OWNER && newOwner != null)) {	162	if (newOwner != eInternalContainer() \|\| (eContainerFeatureID != OrderSystemPackage.WAREHOUSE__OWNER && newOwner != null)) {
157	if (EcoreUtil.isAncestor(this, newOwner))	163	if (EcoreUtil.isAncestor(this, newOwner))
158	throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$	164	throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$
159	NotificationChain msgs = null;	165	NotificationChain msgs = null;
160	if (eContainer != null)	166	if (eInternalContainer() != null)
161	msgs = eBasicRemoveFromContainer(msgs);	167	msgs = eBasicRemoveFromContainer(msgs);
162	if (newOwner != null)	168	if (newOwner != null)
163	msgs = ((InternalEObject)newOwner).eInverseAdd(this, OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE, OrderSystem.class, msgs);	169	msgs = ((InternalEObject)newOwner).eInverseAdd(this, OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE, OrderSystem.class, msgs);
164	msgs = eBasicSetContainer((InternalEObject)newOwner, OrderSystemPackage.WAREHOUSE__OWNER, msgs);	170	msgs = basicSetOwner(newOwner, msgs);
165	if (msgs != null) msgs.dispatch();	171	if (msgs != null) msgs.dispatch();
166	}	172	}
167	else if (eNotificationRequired())	173	else if (eNotificationRequired())
Lines 173-181 Link Here
173	* <!-- end-user-doc -->	179	* <!-- end-user-doc -->
174	* @generated	180	* @generated
175	*/	181	*/
176	public EList getItem() {	182	public EList<InventoryItem> getItem() {
177	if (item == null) {	183	if (item == null) {
178	item = new EObjectContainmentWithInverseEList(InventoryItem.class, this, OrderSystemPackage.WAREHOUSE__ITEM, OrderSystemPackage.INVENTORY_ITEM__WAREHOUSE);	184	item = new EObjectContainmentWithInverseEList<InventoryItem>(InventoryItem.class, this, OrderSystemPackage.WAREHOUSE__ITEM, OrderSystemPackage.INVENTORY_ITEM__WAREHOUSE);
179	}	185	}
180	return item;	186	return item;
181	}	187	}
Lines 225-296 Link Here
225		231
226	/**	232	/**
227	* <!-- begin-user-doc -->	233	* <!-- begin-user-doc -->
228	* <!-- end-user-doc -->	234	* <!-- end-user-doc -->
229	* @generated	235	* @generated
230	*/	236	*/
231	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {	237	@SuppressWarnings("unchecked")
232	if (featureID >= 0) {	238	@Override
233	switch (eDerivedStructuralFeatureID(featureID, baseClass)) {	239	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
234	case OrderSystemPackage.WAREHOUSE__OWNER:	240	switch (featureID) {
235	if (eContainer != null)	241	case OrderSystemPackage.WAREHOUSE__OWNER:
236	msgs = eBasicRemoveFromContainer(msgs);	242	if (eInternalContainer() != null)
237	return eBasicSetContainer(otherEnd, OrderSystemPackage.WAREHOUSE__OWNER, msgs);	243	msgs = eBasicRemoveFromContainer(msgs);
238	case OrderSystemPackage.WAREHOUSE__ITEM:	244	return basicSetOwner((OrderSystem)otherEnd, msgs);
239	return ((InternalEList)getItem()).basicAdd(otherEnd, msgs);	245	case OrderSystemPackage.WAREHOUSE__ITEM:
240	default:	246	return ((InternalEList<InternalEObject>)(InternalEList<?>)getItem()).basicAdd(otherEnd, msgs);
241	return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
242	}
243	}	247	}
244	if (eContainer != null)	248	return super.eInverseAdd(otherEnd, featureID, msgs);
245	msgs = eBasicRemoveFromContainer(msgs);
246	return eBasicSetContainer(otherEnd, featureID, msgs);
247	}	249	}
248		250
249	/**	251	/**
250	* <!-- begin-user-doc -->	252	* <!-- begin-user-doc -->
251	* <!-- end-user-doc -->	253	* <!-- end-user-doc -->
252	* @generated	254	* @generated
253	*/	255	*/
254	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {	256	@Override
255	if (featureID >= 0) {	257	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
256	switch (eDerivedStructuralFeatureID(featureID, baseClass)) {	258	switch (featureID) {
257	case OrderSystemPackage.WAREHOUSE__OWNER:	259	case OrderSystemPackage.WAREHOUSE__OWNER:
258	return eBasicSetContainer(null, OrderSystemPackage.WAREHOUSE__OWNER, msgs);	260	return basicSetOwner(null, msgs);
259	case OrderSystemPackage.WAREHOUSE__ITEM:	261	case OrderSystemPackage.WAREHOUSE__ITEM:
260	return ((InternalEList)getItem()).basicRemove(otherEnd, msgs);	262	return ((InternalEList<?>)getItem()).basicRemove(otherEnd, msgs);
261	case OrderSystemPackage.WAREHOUSE__LOCATION:	263	case OrderSystemPackage.WAREHOUSE__LOCATION:
262	return basicSetLocation(null, msgs);	264	return basicSetLocation(null, msgs);
263	default:
264	return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
265	}
266	}	265	}
267	return eBasicSetContainer(null, featureID, msgs);	266	return super.eInverseRemove(otherEnd, featureID, msgs);
268	}	267	}
269		268
270	/**	269	/**
271	* <!-- begin-user-doc -->	270	* <!-- begin-user-doc -->
272	* <!-- end-user-doc -->	271	* <!-- end-user-doc -->
273	* @generated	272	* @generated
274	*/	273	*/
275	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {	274	@Override
276	if (eContainerFeatureID >= 0) {	275	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
277	switch (eContainerFeatureID) {	276	switch (eContainerFeatureID) {
278	case OrderSystemPackage.WAREHOUSE__OWNER:	277	case OrderSystemPackage.WAREHOUSE__OWNER:
279	return (eContainer).eInverseRemove(this, OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE, OrderSystem.class, msgs);	278	return eInternalContainer().eInverseRemove(this, OrderSystemPackage.ORDER_SYSTEM__WAREHOUSE, OrderSystem.class, msgs);
280	default:
281	return eDynamicBasicRemoveFromContainer(msgs);
282	}
283	}	279	}
284	return (eContainer).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);	280	return super.eBasicRemoveFromContainerFeature(msgs);
285	}	281	}
286		282
287	/**	283	/**
288	* <!-- begin-user-doc -->	284	* <!-- begin-user-doc -->
289	* <!-- end-user-doc -->	285	* <!-- end-user-doc -->
290	* @generated	286	* @generated
291	*/	287	*/
292	public Object eGet(EStructuralFeature eFeature, boolean resolve) {	288	@Override
293	switch (eDerivedStructuralFeatureID(eFeature)) {	289	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		290	switch (featureID) {
294	case OrderSystemPackage.WAREHOUSE__NAME:	291	case OrderSystemPackage.WAREHOUSE__NAME:
295	return getName();	292	return getName();
296	case OrderSystemPackage.WAREHOUSE__OWNER:	293	case OrderSystemPackage.WAREHOUSE__OWNER:
Lines 300-315 Link Here
300	case OrderSystemPackage.WAREHOUSE__LOCATION:	297	case OrderSystemPackage.WAREHOUSE__LOCATION:
301	return getLocation();	298	return getLocation();
302	}	299	}
303	return eDynamicGet(eFeature, resolve);	300	return super.eGet(featureID, resolve, coreType);
304	}	301	}
305		302
306	/**	303	/**
307	* <!-- begin-user-doc -->	304	* <!-- begin-user-doc -->
308	* <!-- end-user-doc -->	305	* <!-- end-user-doc -->
309	* @generated	306	* @generated
310	*/	307	*/
311	public void eSet(EStructuralFeature eFeature, Object newValue) {	308	@SuppressWarnings("unchecked")
312	switch (eDerivedStructuralFeatureID(eFeature)) {	309	@Override
		310	public void eSet(int featureID, Object newValue) {
		311	switch (featureID) {
313	case OrderSystemPackage.WAREHOUSE__NAME:	312	case OrderSystemPackage.WAREHOUSE__NAME:
314	setName((String)newValue);	313	setName((String)newValue);
315	return;	314	return;
Lines 318-339 Link Here
318	return;	317	return;
319	case OrderSystemPackage.WAREHOUSE__ITEM:	318	case OrderSystemPackage.WAREHOUSE__ITEM:
320	getItem().clear();	319	getItem().clear();
321	getItem().addAll((Collection)newValue);	320	getItem().addAll((Collection<? extends InventoryItem>)newValue);
322	return;	321	return;
323	case OrderSystemPackage.WAREHOUSE__LOCATION:	322	case OrderSystemPackage.WAREHOUSE__LOCATION:
324	setLocation((Address)newValue);	323	setLocation((Address)newValue);
325	return;	324	return;
326	}	325	}
327	eDynamicSet(eFeature, newValue);	326	super.eSet(featureID, newValue);
328	}	327	}
329		328
330	/**	329	/**
331	* <!-- begin-user-doc -->	330	* <!-- begin-user-doc -->
332	* <!-- end-user-doc -->	331	* <!-- end-user-doc -->
333	* @generated	332	* @generated
334	*/	333	*/
335	public void eUnset(EStructuralFeature eFeature) {	334	@Override
336	switch (eDerivedStructuralFeatureID(eFeature)) {	335	public void eUnset(int featureID) {
		336	switch (featureID) {
337	case OrderSystemPackage.WAREHOUSE__NAME:	337	case OrderSystemPackage.WAREHOUSE__NAME:
338	setName(NAME_EDEFAULT);	338	setName(NAME_EDEFAULT);
339	return;	339	return;
Lines 347-362 Link Here
347	setLocation((Address)null);	347	setLocation((Address)null);
348	return;	348	return;
349	}	349	}
350	eDynamicUnset(eFeature);	350	super.eUnset(featureID);
351	}	351	}
352		352
353	/**	353	/**
354	* <!-- begin-user-doc -->	354	* <!-- begin-user-doc -->
355	* <!-- end-user-doc -->	355	* <!-- end-user-doc -->
356	* @generated	356	* @generated
357	*/	357	*/
358	public boolean eIsSet(EStructuralFeature eFeature) {	358	@Override
359	switch (eDerivedStructuralFeatureID(eFeature)) {	359	public boolean eIsSet(int featureID) {
		360	switch (featureID) {
360	case OrderSystemPackage.WAREHOUSE__NAME:	361	case OrderSystemPackage.WAREHOUSE__NAME:
361	return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);	362	return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
362	case OrderSystemPackage.WAREHOUSE__OWNER:	363	case OrderSystemPackage.WAREHOUSE__OWNER:
Lines 366-375 Link Here
366	case OrderSystemPackage.WAREHOUSE__LOCATION:	367	case OrderSystemPackage.WAREHOUSE__LOCATION:
367	return location != null;	368	return location != null;
368	}	369	}
369	return eDynamicIsSet(eFeature);	370	return super.eIsSet(featureID);
370	}	371	}
371		372
372	/**	373	/**
373	* <!-- begin-user-doc -->	374	* <!-- begin-user-doc -->
374	* <!-- end-user-doc -->	375	* <!-- end-user-doc -->
375	*/	376	*/

Lines 1-7 Link Here

(-)src/ordersystem/impl/AccountImpl.java (-69 / +68 lines)
1	/**	1	/**
2	* <copyright>	2	* <copyright>
3	*	3	*
4	* Copyright (c) 2005 IBM Corporation and others.	4	* Copyright (c) 2005, 2007 IBM Corporation and others.
5	* All rights reserved. This program and the accompanying materials	5	* All rights reserved. This program and the accompanying materials
6	* are made available under the terms of the Eclipse Public License v1.0	6	* are made available under the terms of the Eclipse Public License v1.0
7	* which accompanies this distribution, and is available at	7	* which accompanies this distribution, and is available at
Lines 20-38 Link Here
20	import ordersystem.Account;	20	import ordersystem.Account;
21	import ordersystem.Address;	21	import ordersystem.Address;
22	import ordersystem.Customer;	22	import ordersystem.Customer;
23
24	import ordersystem.OrderSystemPackage;	23	import ordersystem.OrderSystemPackage;
25		24
26	import org.eclipse.emf.common.notify.Notification;	25	import org.eclipse.emf.common.notify.Notification;
27	import org.eclipse.emf.common.notify.NotificationChain;	26	import org.eclipse.emf.common.notify.NotificationChain;
28
29	import org.eclipse.emf.ecore.EClass;	27	import org.eclipse.emf.ecore.EClass;
30	import org.eclipse.emf.ecore.EStructuralFeature;
31	import org.eclipse.emf.ecore.InternalEObject;	28	import org.eclipse.emf.ecore.InternalEObject;
32
33	import org.eclipse.emf.ecore.impl.ENotificationImpl;	29	import org.eclipse.emf.ecore.impl.ENotificationImpl;
34	import org.eclipse.emf.ecore.impl.EObjectImpl;	30	import org.eclipse.emf.ecore.impl.EObjectImpl;
35
36	import org.eclipse.emf.ecore.util.EcoreUtil;	31	import org.eclipse.emf.ecore.util.EcoreUtil;
37		32
38	/**	33	/**
Lines 101-107 Link Here
101	* @generated	96	* @generated
102	* @ordered	97	* @ordered
103	*/	98	*/
104	protected Address billingAddress = null;	99	protected Address billingAddress;
105		100
106	/**	101	/**
107	* The cached value of the '{@link #getShippingAddress() <em>Shipping Address</em>}' containment reference.	102	* The cached value of the '{@link #getShippingAddress() <em>Shipping Address</em>}' containment reference.
Lines 111-117 Link Here
111	* @generated	106	* @generated
112	* @ordered	107	* @ordered
113	*/	108	*/
114	protected Address shippingAddress = null;	109	protected Address shippingAddress;
115		110
116	/**	111	/**
117	* <!-- begin-user-doc -->	112	* <!-- begin-user-doc -->
Lines 127-134 Link Here
127	* <!-- end-user-doc -->	122	* <!-- end-user-doc -->
128	* @generated	123	* @generated
129	*/	124	*/
130	protected EClass eStaticClass() {	125	@Override
131	return OrderSystemPackage.eINSTANCE.getAccount();	126	protected EClass eStaticClass() {
		127	return OrderSystemPackage.Literals.ACCOUNT;
132	}	128	}
133		129
134	/**	130	/**
Lines 180-186 Link Here
180	*/	176	*/
181	public Customer getOwner() {	177	public Customer getOwner() {
182	if (eContainerFeatureID != OrderSystemPackage.ACCOUNT__OWNER) return null;	178	if (eContainerFeatureID != OrderSystemPackage.ACCOUNT__OWNER) return null;
183	return (Customer)eContainer;	179	return (Customer)eContainer();
		180	}
		181
		182	/**
		183	* <!-- begin-user-doc -->
		184	* <!-- end-user-doc -->
		185	* @generated
		186	*/
		187	public NotificationChain basicSetOwner(Customer newOwner, NotificationChain msgs) {
		188	msgs = eBasicSetContainer((InternalEObject)newOwner, OrderSystemPackage.ACCOUNT__OWNER, msgs);
		189	return msgs;
184	}	190	}
185		191
186	/**	192	/**
Lines 189-203 Link Here
189	* @generated	195	* @generated
190	*/	196	*/
191	public void setOwner(Customer newOwner) {	197	public void setOwner(Customer newOwner) {
192	if (newOwner != eContainer \|\| (eContainerFeatureID != OrderSystemPackage.ACCOUNT__OWNER && newOwner != null)) {	198	if (newOwner != eInternalContainer() \|\| (eContainerFeatureID != OrderSystemPackage.ACCOUNT__OWNER && newOwner != null)) {
193	if (EcoreUtil.isAncestor(this, newOwner))	199	if (EcoreUtil.isAncestor(this, newOwner))
194	throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$	200	throw new IllegalArgumentException("Recursive containment not allowed for " + toString()); //$NON-NLS-1$
195	NotificationChain msgs = null;	201	NotificationChain msgs = null;
196	if (eContainer != null)	202	if (eInternalContainer() != null)
197	msgs = eBasicRemoveFromContainer(msgs);	203	msgs = eBasicRemoveFromContainer(msgs);
198	if (newOwner != null)	204	if (newOwner != null)
199	msgs = ((InternalEObject)newOwner).eInverseAdd(this, OrderSystemPackage.CUSTOMER__ACCOUNT, Customer.class, msgs);	205	msgs = ((InternalEObject)newOwner).eInverseAdd(this, OrderSystemPackage.CUSTOMER__ACCOUNT, Customer.class, msgs);
200	msgs = eBasicSetContainer((InternalEObject)newOwner, OrderSystemPackage.ACCOUNT__OWNER, msgs);	206	msgs = basicSetOwner(newOwner, msgs);
201	if (msgs != null) msgs.dispatch();	207	if (msgs != null) msgs.dispatch();
202	}	208	}
203	else if (eNotificationRequired())	209	else if (eNotificationRequired())
Lines 292-361 Link Here
292		298
293	/**	299	/**
294	* <!-- begin-user-doc -->	300	* <!-- begin-user-doc -->
295	* <!-- end-user-doc -->	301	* <!-- end-user-doc -->
296	* @generated	302	* @generated
297	*/	303	*/
298	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {	304	@Override
299	if (featureID >= 0) {	305	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
300	switch (eDerivedStructuralFeatureID(featureID, baseClass)) {	306	switch (featureID) {
301	case OrderSystemPackage.ACCOUNT__OWNER:	307	case OrderSystemPackage.ACCOUNT__OWNER:
302	if (eContainer != null)	308	if (eInternalContainer() != null)
303	msgs = eBasicRemoveFromContainer(msgs);	309	msgs = eBasicRemoveFromContainer(msgs);
304	return eBasicSetContainer(otherEnd, OrderSystemPackage.ACCOUNT__OWNER, msgs);	310	return basicSetOwner((Customer)otherEnd, msgs);
305	default:
306	return eDynamicInverseAdd(otherEnd, featureID, baseClass, msgs);
307	}
308	}	311	}
309	if (eContainer != null)	312	return super.eInverseAdd(otherEnd, featureID, msgs);
310	msgs = eBasicRemoveFromContainer(msgs);
311	return eBasicSetContainer(otherEnd, featureID, msgs);
312	}	313	}
313		314
314	/**	315	/**
315	* <!-- begin-user-doc -->	316	* <!-- begin-user-doc -->
316	* <!-- end-user-doc -->	317	* <!-- end-user-doc -->
317	* @generated	318	* @generated
318	*/	319	*/
319	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {	320	@Override
320	if (featureID >= 0) {	321	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
321	switch (eDerivedStructuralFeatureID(featureID, baseClass)) {	322	switch (featureID) {
322	case OrderSystemPackage.ACCOUNT__OWNER:	323	case OrderSystemPackage.ACCOUNT__OWNER:
323	return eBasicSetContainer(null, OrderSystemPackage.ACCOUNT__OWNER, msgs);	324	return basicSetOwner(null, msgs);
324	case OrderSystemPackage.ACCOUNT__BILLING_ADDRESS:	325	case OrderSystemPackage.ACCOUNT__BILLING_ADDRESS:
325	return basicSetBillingAddress(null, msgs);	326	return basicSetBillingAddress(null, msgs);
326	case OrderSystemPackage.ACCOUNT__SHIPPING_ADDRESS:	327	case OrderSystemPackage.ACCOUNT__SHIPPING_ADDRESS:
327	return basicSetShippingAddress(null, msgs);	328	return basicSetShippingAddress(null, msgs);
328	default:
329	return eDynamicInverseRemove(otherEnd, featureID, baseClass, msgs);
330	}
331	}	329	}
332	return eBasicSetContainer(null, featureID, msgs);	330	return super.eInverseRemove(otherEnd, featureID, msgs);
333	}	331	}
334		332
335	/**	333	/**
336	* <!-- begin-user-doc -->	334	* <!-- begin-user-doc -->
337	* <!-- end-user-doc -->	335	* <!-- end-user-doc -->
338	* @generated	336	* @generated
339	*/	337	*/
340	public NotificationChain eBasicRemoveFromContainer(NotificationChain msgs) {	338	@Override
341	if (eContainerFeatureID >= 0) {	339	public NotificationChain eBasicRemoveFromContainerFeature(NotificationChain msgs) {
342	switch (eContainerFeatureID) {	340	switch (eContainerFeatureID) {
343	case OrderSystemPackage.ACCOUNT__OWNER:	341	case OrderSystemPackage.ACCOUNT__OWNER:
344	return (eContainer).eInverseRemove(this, OrderSystemPackage.CUSTOMER__ACCOUNT, Customer.class, msgs);	342	return eInternalContainer().eInverseRemove(this, OrderSystemPackage.CUSTOMER__ACCOUNT, Customer.class, msgs);
345	default:
346	return eDynamicBasicRemoveFromContainer(msgs);
347	}
348	}	343	}
349	return (eContainer).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - eContainerFeatureID, null, msgs);	344	return super.eBasicRemoveFromContainerFeature(msgs);
350	}	345	}
351		346
352	/**	347	/**
353	* <!-- begin-user-doc -->	348	* <!-- begin-user-doc -->
354	* <!-- end-user-doc -->	349	* <!-- end-user-doc -->
355	* @generated	350	* @generated
356	*/	351	*/
357	public Object eGet(EStructuralFeature eFeature, boolean resolve) {	352	@Override
358	switch (eDerivedStructuralFeatureID(eFeature)) {	353	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		354	switch (featureID) {
359	case OrderSystemPackage.ACCOUNT__PAYMENT_METHOD:	355	case OrderSystemPackage.ACCOUNT__PAYMENT_METHOD:
360	return getPaymentMethod();	356	return getPaymentMethod();
361	case OrderSystemPackage.ACCOUNT__ACCOUNT_NUMBER:	357	case OrderSystemPackage.ACCOUNT__ACCOUNT_NUMBER:
Lines 367-382 Link Here
367	case OrderSystemPackage.ACCOUNT__SHIPPING_ADDRESS:	363	case OrderSystemPackage.ACCOUNT__SHIPPING_ADDRESS:
368	return getShippingAddress();	364	return getShippingAddress();
369	}	365	}
370	return eDynamicGet(eFeature, resolve);	366	return super.eGet(featureID, resolve, coreType);
371	}	367	}
372		368
373	/**	369	/**
374	* <!-- begin-user-doc -->	370	* <!-- begin-user-doc -->
375	* <!-- end-user-doc -->	371	* <!-- end-user-doc -->
376	* @generated	372	* @generated
377	*/	373	*/
378	public void eSet(EStructuralFeature eFeature, Object newValue) {	374	@Override
379	switch (eDerivedStructuralFeatureID(eFeature)) {	375	public void eSet(int featureID, Object newValue) {
		376	switch (featureID) {
380	case OrderSystemPackage.ACCOUNT__PAYMENT_METHOD:	377	case OrderSystemPackage.ACCOUNT__PAYMENT_METHOD:
381	setPaymentMethod((String)newValue);	378	setPaymentMethod((String)newValue);
382	return;	379	return;
Lines 393-408 Link Here
393	setShippingAddress((Address)newValue);	390	setShippingAddress((Address)newValue);
394	return;	391	return;
395	}	392	}
396	eDynamicSet(eFeature, newValue);	393	super.eSet(featureID, newValue);
397	}	394	}
398		395
399	/**	396	/**
400	* <!-- begin-user-doc -->	397	* <!-- begin-user-doc -->
401	* <!-- end-user-doc -->	398	* <!-- end-user-doc -->
402	* @generated	399	* @generated
403	*/	400	*/
404	public void eUnset(EStructuralFeature eFeature) {	401	@Override
405	switch (eDerivedStructuralFeatureID(eFeature)) {	402	public void eUnset(int featureID) {
		403	switch (featureID) {
406	case OrderSystemPackage.ACCOUNT__PAYMENT_METHOD:	404	case OrderSystemPackage.ACCOUNT__PAYMENT_METHOD:
407	setPaymentMethod(PAYMENT_METHOD_EDEFAULT);	405	setPaymentMethod(PAYMENT_METHOD_EDEFAULT);
408	return;	406	return;
Lines 419-434 Link Here
419	setShippingAddress((Address)null);	417	setShippingAddress((Address)null);
420	return;	418	return;
421	}	419	}
422	eDynamicUnset(eFeature);	420	super.eUnset(featureID);
423	}	421	}
424		422
425	/**	423	/**
426	* <!-- begin-user-doc -->	424	* <!-- begin-user-doc -->
427	* <!-- end-user-doc -->	425	* <!-- end-user-doc -->
428	* @generated	426	* @generated
429	*/	427	*/
430	public boolean eIsSet(EStructuralFeature eFeature) {	428	@Override
431	switch (eDerivedStructuralFeatureID(eFeature)) {	429	public boolean eIsSet(int featureID) {
		430	switch (featureID) {
432	case OrderSystemPackage.ACCOUNT__PAYMENT_METHOD:	431	case OrderSystemPackage.ACCOUNT__PAYMENT_METHOD:
433	return PAYMENT_METHOD_EDEFAULT == null ? paymentMethod != null : !PAYMENT_METHOD_EDEFAULT.equals(paymentMethod);	432	return PAYMENT_METHOD_EDEFAULT == null ? paymentMethod != null : !PAYMENT_METHOD_EDEFAULT.equals(paymentMethod);
434	case OrderSystemPackage.ACCOUNT__ACCOUNT_NUMBER:	433	case OrderSystemPackage.ACCOUNT__ACCOUNT_NUMBER:
Lines 440-449 Link Here
440	case OrderSystemPackage.ACCOUNT__SHIPPING_ADDRESS:	439	case OrderSystemPackage.ACCOUNT__SHIPPING_ADDRESS:
441	return shippingAddress != null;	440	return shippingAddress != null;
442	}	441	}
443	return eDynamicIsSet(eFeature);	442	return super.eIsSet(featureID);
444	}	443	}
445		444
446	/**	445	/**
447	* <!-- begin-user-doc -->	446	* <!-- begin-user-doc -->
448	* <!-- end-user-doc -->	447	* <!-- end-user-doc -->
449	*/	448	*/