/**
*/
package org.eclipse.viatra.solver.language.model.problem.util;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.viatra.solver.language.model.problem.*;
/**
*
* The Adapter Factory for the model.
* It provides an adapter createXXX
method for each class of the model.
*
* @see org.eclipse.viatra.solver.language.model.problem.ProblemPackage
* @generated
*/
public class ProblemAdapterFactory extends AdapterFactoryImpl {
/**
* The cached model package.
*
*
* @generated
*/
protected static ProblemPackage modelPackage;
/**
* Creates an instance of the adapter factory.
*
*
* @generated
*/
public ProblemAdapterFactory() {
if (modelPackage == null) {
modelPackage = ProblemPackage.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 ProblemSwitch modelSwitch = new ProblemSwitch() {
@Override
public Adapter caseProblem(Problem object) {
return createProblemAdapter();
}
@Override
public Adapter caseRelation(Relation object) {
return createRelationAdapter();
}
@Override
public Adapter caseClassDeclaration(ClassDeclaration object) {
return createClassDeclarationAdapter();
}
@Override
public Adapter caseReferenceDeclaration(ReferenceDeclaration object) {
return createReferenceDeclarationAdapter();
}
@Override
public Adapter caseNamedElement(NamedElement object) {
return createNamedElementAdapter();
}
@Override
public Adapter casePredicateDefinition(PredicateDefinition object) {
return createPredicateDefinitionAdapter();
}
@Override
public Adapter caseParameter(Parameter object) {
return createParameterAdapter();
}
@Override
public Adapter caseVariable(Variable object) {
return createVariableAdapter();
}
@Override
public Adapter caseConjunction(Conjunction object) {
return createConjunctionAdapter();
}
@Override
public Adapter caseLiteral(Literal object) {
return createLiteralAdapter();
}
@Override
public Adapter caseAtom(Atom object) {
return createAtomAdapter();
}
@Override
public Adapter caseImplicitVariable(ImplicitVariable object) {
return createImplicitVariableAdapter();
}
@Override
public Adapter caseNegativeLiteral(NegativeLiteral object) {
return createNegativeLiteralAdapter();
}
@Override
public Adapter caseExistentialQuantifier(ExistentialQuantifier object) {
return createExistentialQuantifierAdapter();
}
@Override
public Adapter caseAssertion(Assertion object) {
return createAssertionAdapter();
}
@Override
public Adapter caseNode(Node object) {
return createNodeAdapter();
}
@Override
public Adapter caseScopeDeclaration(ScopeDeclaration object) {
return createScopeDeclarationAdapter();
}
@Override
public Adapter caseStatement(Statement object) {
return createStatementAdapter();
}
@Override
public Adapter caseTypeScope(TypeScope object) {
return createTypeScopeAdapter();
}
@Override
public Adapter caseMultiplicity(Multiplicity object) {
return createMultiplicityAdapter();
}
@Override
public Adapter caseRangeMultiplicity(RangeMultiplicity object) {
return createRangeMultiplicityAdapter();
}
@Override
public Adapter caseExactMultiplicity(ExactMultiplicity object) {
return createExactMultiplicityAdapter();
}
@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 org.eclipse.viatra.solver.language.model.problem.Problem Problem}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.Problem
* @generated
*/
public Adapter createProblemAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.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 org.eclipse.viatra.solver.language.model.problem.Relation
* @generated
*/
public Adapter createRelationAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ClassDeclaration Class Declaration}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.ClassDeclaration
* @generated
*/
public Adapter createClassDeclarationAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration Reference Declaration}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration
* @generated
*/
public Adapter createReferenceDeclarationAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.NamedElement Named Element}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.NamedElement
* @generated
*/
public Adapter createNamedElementAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.PredicateDefinition Predicate Definition}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.PredicateDefinition
* @generated
*/
public Adapter createPredicateDefinitionAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Parameter Parameter}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.Parameter
* @generated
*/
public Adapter createParameterAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Variable Variable}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.Variable
* @generated
*/
public Adapter createVariableAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Conjunction Conjunction}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.Conjunction
* @generated
*/
public Adapter createConjunctionAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Literal Literal}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.Literal
* @generated
*/
public Adapter createLiteralAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Atom Atom}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.Atom
* @generated
*/
public Adapter createAtomAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ImplicitVariable Implicit Variable}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.ImplicitVariable
* @generated
*/
public Adapter createImplicitVariableAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.NegativeLiteral Negative Literal}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.NegativeLiteral
* @generated
*/
public Adapter createNegativeLiteralAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ExistentialQuantifier Existential Quantifier}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.ExistentialQuantifier
* @generated
*/
public Adapter createExistentialQuantifierAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Assertion Assertion}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.Assertion
* @generated
*/
public Adapter createAssertionAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Node Node}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.Node
* @generated
*/
public Adapter createNodeAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ScopeDeclaration Scope Declaration}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.ScopeDeclaration
* @generated
*/
public Adapter createScopeDeclarationAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Statement Statement}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.Statement
* @generated
*/
public Adapter createStatementAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.TypeScope Type Scope}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.TypeScope
* @generated
*/
public Adapter createTypeScopeAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Multiplicity Multiplicity}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.Multiplicity
* @generated
*/
public Adapter createMultiplicityAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.RangeMultiplicity Range Multiplicity}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.RangeMultiplicity
* @generated
*/
public Adapter createRangeMultiplicityAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ExactMultiplicity Exact Multiplicity}'.
*
* 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 org.eclipse.viatra.solver.language.model.problem.ExactMultiplicity
* @generated
*/
public Adapter createExactMultiplicityAdapter() {
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;
}
} //ProblemAdapterFactory