From e3774317421935b8d63e2e0ad08a141853d31908 Mon Sep 17 00:00:00 2001 From: Aren Babikian Date: Mon, 11 Jan 2021 06:42:10 -0500 Subject: first version of the simpleScenario MM+VQL. noRealMatches bug found --- .../util/SimpleScenarioAdapterFactory.java | 282 +++++++++++++++++++++ 1 file changed, 282 insertions(+) create mode 100644 Domains/traffic.scenarios.simplified/ecore-gen/simpleScenario/util/SimpleScenarioAdapterFactory.java (limited to 'Domains/traffic.scenarios.simplified/ecore-gen/simpleScenario/util/SimpleScenarioAdapterFactory.java') diff --git a/Domains/traffic.scenarios.simplified/ecore-gen/simpleScenario/util/SimpleScenarioAdapterFactory.java b/Domains/traffic.scenarios.simplified/ecore-gen/simpleScenario/util/SimpleScenarioAdapterFactory.java new file mode 100644 index 00000000..eb9bc05f --- /dev/null +++ b/Domains/traffic.scenarios.simplified/ecore-gen/simpleScenario/util/SimpleScenarioAdapterFactory.java @@ -0,0 +1,282 @@ +/** + */ +package simpleScenario.util; + +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notifier; + +import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl; + +import org.eclipse.emf.ecore.EObject; + +import simpleScenario.*; + +/** + * + * The Adapter Factory for the model. + * It provides an adapter createXXX method for each class of the model. + * + * @see simpleScenario.SimpleScenarioPackage + * @generated + */ +public class SimpleScenarioAdapterFactory extends AdapterFactoryImpl { + /** + * The cached model package. + * + * + * @generated + */ + protected static SimpleScenarioPackage modelPackage; + + /** + * Creates an instance of the adapter factory. + * + * + * @generated + */ + public SimpleScenarioAdapterFactory() { + if (modelPackage == null) { + modelPackage = SimpleScenarioPackage.eINSTANCE; + } + } + + /** + * Returns whether this factory is applicable for the type of the object. + * + * This implementation returns true if the object is either the model's package or is an instance object of the model. + * + * @return whether this factory is applicable for the type of the object. + * @generated + */ + @Override + public boolean isFactoryForType(Object object) { + if (object == modelPackage) { + return true; + } + if (object instanceof EObject) { + return ((EObject)object).eClass().getEPackage() == modelPackage; + } + return false; + } + + /** + * The switch that delegates to the createXXX methods. + * + * + * @generated + */ + protected SimpleScenarioSwitch modelSwitch = + new SimpleScenarioSwitch() { + @Override + public Adapter caseSimpleScenario(SimpleScenario object) { + return createSimpleScenarioAdapter(); + } + @Override + public Adapter caseLane(Lane object) { + return createLaneAdapter(); + } + @Override + public Adapter caseActor(Actor object) { + return createActorAdapter(); + } + @Override + public Adapter caseRelation(Relation object) { + return createRelationAdapter(); + } + @Override + public Adapter caseSpatialRelation(SpatialRelation object) { + return createSpatialRelationAdapter(); + } + @Override + public Adapter caseTemporalRelation(TemporalRelation object) { + return createTemporalRelationAdapter(); + } + @Override + public Adapter caseVisionBlocked(VisionBlocked object) { + return createVisionBlockedAdapter(); + } + @Override + public Adapter caseSeperationDistance(SeperationDistance object) { + return createSeperationDistanceAdapter(); + } + @Override + public Adapter caseCollisionExists(CollisionExists object) { + return createCollisionExistsAdapter(); + } + @Override + public Adapter caseCollisionDoesNotExist(CollisionDoesNotExist object) { + return createCollisionDoesNotExistAdapter(); + } + @Override + public Adapter defaultCase(EObject object) { + return createEObjectAdapter(); + } + }; + + /** + * Creates an adapter for the target. + * + * + * @param target the object to adapt. + * @return the adapter for the target. + * @generated + */ + @Override + public Adapter createAdapter(Notifier target) { + return modelSwitch.doSwitch((EObject)target); + } + + + /** + * Creates a new adapter for an object of class '{@link simpleScenario.SimpleScenario Simple Scenario}'. + * + * 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. + * + * @return the new adapter. + * @see simpleScenario.SimpleScenario + * @generated + */ + public Adapter createSimpleScenarioAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link simpleScenario.Lane Lane}'. + * + * 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. + * + * @return the new adapter. + * @see simpleScenario.Lane + * @generated + */ + public Adapter createLaneAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link simpleScenario.Actor Actor}'. + * + * 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. + * + * @return the new adapter. + * @see simpleScenario.Actor + * @generated + */ + public Adapter createActorAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link simpleScenario.Relation Relation}'. + * + * 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. + * + * @return the new adapter. + * @see simpleScenario.Relation + * @generated + */ + public Adapter createRelationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link simpleScenario.SpatialRelation Spatial Relation}'. + * + * 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. + * + * @return the new adapter. + * @see simpleScenario.SpatialRelation + * @generated + */ + public Adapter createSpatialRelationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link simpleScenario.TemporalRelation Temporal Relation}'. + * + * 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. + * + * @return the new adapter. + * @see simpleScenario.TemporalRelation + * @generated + */ + public Adapter createTemporalRelationAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link simpleScenario.VisionBlocked Vision Blocked}'. + * + * 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. + * + * @return the new adapter. + * @see simpleScenario.VisionBlocked + * @generated + */ + public Adapter createVisionBlockedAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link simpleScenario.SeperationDistance Seperation Distance}'. + * + * 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. + * + * @return the new adapter. + * @see simpleScenario.SeperationDistance + * @generated + */ + public Adapter createSeperationDistanceAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link simpleScenario.CollisionExists Collision Exists}'. + * + * 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. + * + * @return the new adapter. + * @see simpleScenario.CollisionExists + * @generated + */ + public Adapter createCollisionExistsAdapter() { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link simpleScenario.CollisionDoesNotExist Collision Does Not Exist}'. + * + * 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. + * + * @return the new adapter. + * @see simpleScenario.CollisionDoesNotExist + * @generated + */ + public Adapter createCollisionDoesNotExistAdapter() { + return null; + } + + /** + * Creates a new adapter for the default case. + * + * This default implementation returns null. + * + * @return the new adapter. + * @generated + */ + public Adapter createEObjectAdapter() { + return null; + } + +} //SimpleScenarioAdapterFactory -- cgit v1.2.3-70-g09d2