/**
*/
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 caseUnboundedMultiplicity(UnboundedMultiplicity object) {
return createUnboundedMultiplicityAdapter();
}
@Override
public Adapter caseVariableOrNodeArgument(VariableOrNodeArgument object) {
return createVariableOrNodeArgumentAdapter();
}
@Override
public Adapter caseEnumDeclaration(EnumDeclaration object) {
return createEnumDeclarationAdapter();
}
@Override
public Adapter caseVariableOrNode(VariableOrNode object) {
return createVariableOrNodeAdapter();
}
@Override
public Adapter caseConstant(Constant object) {
return createConstantAdapter();
}
@Override
public Adapter caseIntConstant(IntConstant object) {
return createIntConstantAdapter();
}
@Override
public Adapter caseRealConstant(RealConstant object) {
return createRealConstantAdapter();
}
@Override
public Adapter caseStringConstant(StringConstant object) {
return createStringConstantAdapter();
}
@Override
public Adapter caseConstantArgument(ConstantArgument object) {
return createConstantArgumentAdapter();
}
@Override
public Adapter caseArgument(Argument object) {
return createArgumentAdapter();
}
@Override
public Adapter caseNodeAssertionArgument(NodeAssertionArgument object) {
return createNodeAssertionArgumentAdapter();
}
@Override
public Adapter caseAssertionArgument(AssertionArgument object) {
return createAssertionArgumentAdapter();
}
@Override
public Adapter caseConstantAssertionArgument(ConstantAssertionArgument object) {
return createConstantAssertionArgumentAdapter();
}
@Override
public Adapter caseNodeValueAssertion(NodeValueAssertion object) {
return createNodeValueAssertionAdapter();
}
@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 an object of class '{@link org.eclipse.viatra.solver.language.model.problem.UnboundedMultiplicity Unbounded 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.UnboundedMultiplicity
* @generated
*/
public Adapter createUnboundedMultiplicityAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.VariableOrNodeArgument Variable Or Node Argument}'.
*
* 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.VariableOrNodeArgument
* @generated
*/
public Adapter createVariableOrNodeArgumentAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Argument Argument}'.
*
* 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.Argument
* @generated
*/
public Adapter createArgumentAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.NodeAssertionArgument Node Assertion Argument}'.
*
* 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.NodeAssertionArgument
* @generated
*/
public Adapter createNodeAssertionArgumentAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.AssertionArgument Assertion Argument}'.
*
* 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.AssertionArgument
* @generated
*/
public Adapter createAssertionArgumentAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ConstantAssertionArgument Constant Assertion Argument}'.
*
* 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.ConstantAssertionArgument
* @generated
*/
public Adapter createConstantAssertionArgumentAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.NodeValueAssertion Node Value 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.NodeValueAssertion
* @generated
*/
public Adapter createNodeValueAssertionAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.EnumDeclaration Enum 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.EnumDeclaration
* @generated
*/
public Adapter createEnumDeclarationAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.VariableOrNode Variable Or 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.VariableOrNode
* @generated
*/
public Adapter createVariableOrNodeAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Constant Constant}'.
*
* 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.Constant
* @generated
*/
public Adapter createConstantAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.IntConstant Int Constant}'.
*
* 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.IntConstant
* @generated
*/
public Adapter createIntConstantAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.RealConstant Real Constant}'.
*
* 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.RealConstant
* @generated
*/
public Adapter createRealConstantAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.StringConstant String Constant}'.
*
* 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.StringConstant
* @generated
*/
public Adapter createStringConstantAdapter() {
return null;
}
/**
* Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ConstantArgument Constant Argument}'.
*
* 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.ConstantArgument
* @generated
*/
public Adapter createConstantArgumentAdapter() {
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