From 8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe Mon Sep 17 00:00:00 2001 From: Oszkar Semerath Date: Tue, 28 Apr 2020 20:43:04 +0200 Subject: initial commit --- .../impl/SolverLanguagePackageImpl.java | 2007 ++++++++++++++++++++ 1 file changed, 2007 insertions(+) create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java (limited to 'Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java') diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java new file mode 100644 index 00000000..9e5d391b --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java @@ -0,0 +1,2007 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EAttribute; +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.EReference; + +import org.eclipse.emf.ecore.impl.EPackageImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.AllInstances; +import org.eclipse.viatra.solver.language.solverLanguage.AllObjects; +import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse; +import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject; +import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue; +import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue; +import org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.ClosureType; +import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject; +import org.eclipse.viatra.solver.language.solverLanguage.Constraint; +import org.eclipse.viatra.solver.language.solverLanguage.DataObject; +import org.eclipse.viatra.solver.language.solverLanguage.DataSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate; +import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.False; +import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.IntObject; +import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.Interpretation; +import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure; +import org.eclipse.viatra.solver.language.solverLanguage.Literal; +import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; +import org.eclipse.viatra.solver.language.solverLanguage.NamedObject; +import org.eclipse.viatra.solver.language.solverLanguage.Negative; +import org.eclipse.viatra.solver.language.solverLanguage.Parameter; +import org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol; +import org.eclipse.viatra.solver.language.solverLanguage.PatternBody; +import org.eclipse.viatra.solver.language.solverLanguage.Polarity; +import org.eclipse.viatra.solver.language.solverLanguage.Positive; +import org.eclipse.viatra.solver.language.solverLanguage.Predicate; +import org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.Problem; +import org.eclipse.viatra.solver.language.solverLanguage.RealObject; +import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguageFactory; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.Statement; +import org.eclipse.viatra.solver.language.solverLanguage.StringObject; +import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.Symbol; +import org.eclipse.viatra.solver.language.solverLanguage.True; +import org.eclipse.viatra.solver.language.solverLanguage.TruthValue; +import org.eclipse.viatra.solver.language.solverLanguage.Unknown; +import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject; +import org.eclipse.viatra.solver.language.solverLanguage.Variable; + +/** + * + * An implementation of the model Package. + * + * @generated + */ +public class SolverLanguagePackageImpl extends EPackageImpl implements SolverLanguagePackage +{ + /** + * + * + * @generated + */ + private EClass problemEClass = null; + + /** + * + * + * @generated + */ + private EClass statementEClass = null; + + /** + * + * + * @generated + */ + private EClass booleanValueEClass = null; + + /** + * + * + * @generated + */ + private EClass truthValueEClass = null; + + /** + * + * + * @generated + */ + private EClass interpretationEClass = null; + + /** + * + * + * @generated + */ + private EClass basicInterpretationEClass = null; + + /** + * + * + * @generated + */ + private EClass symbolEClass = null; + + /** + * + * + * @generated + */ + private EClass modelSymbolEClass = null; + + /** + * + * + * @generated + */ + private EClass partialitySymbolEClass = null; + + /** + * + * + * @generated + */ + private EClass existSymbolEClass = null; + + /** + * + * + * @generated + */ + private EClass equalsSymbolEClass = null; + + /** + * + * + * @generated + */ + private EClass dataSymbolEClass = null; + + /** + * + * + * @generated + */ + private EClass booleanSymbolEClass = null; + + /** + * + * + * @generated + */ + private EClass integerSymbolEClass = null; + + /** + * + * + * @generated + */ + private EClass realSymbolEClass = null; + + /** + * + * + * @generated + */ + private EClass stringSymbolEClass = null; + + /** + * + * + * @generated + */ + private EClass complexObjectEClass = null; + + /** + * + * + * @generated + */ + private EClass objectEClass = null; + + /** + * + * + * @generated + */ + private EClass namedObjectEClass = null; + + /** + * + * + * @generated + */ + private EClass unnamedObjectEClass = null; + + /** + * + * + * @generated + */ + private EClass dataObjectEClass = null; + + /** + * + * + * @generated + */ + private EClass booleanObjectEClass = null; + + /** + * + * + * @generated + */ + private EClass intObjectEClass = null; + + /** + * + * + * @generated + */ + private EClass realObjectEClass = null; + + /** + * + * + * @generated + */ + private EClass stringObjectEClass = null; + + /** + * + * + * @generated + */ + private EClass predicateEClass = null; + + /** + * + * + * @generated + */ + private EClass predicateSymbolEClass = null; + + /** + * + * + * @generated + */ + private EClass errorPredicateEClass = null; + + /** + * + * + * @generated + */ + private EClass parameterEClass = null; + + /** + * + * + * @generated + */ + private EClass patternBodyEClass = null; + + /** + * + * + * @generated + */ + private EClass polarityEClass = null; + + /** + * + * + * @generated + */ + private EClass constraintEClass = null; + + /** + * + * + * @generated + */ + private EClass closureTypeEClass = null; + + /** + * + * + * @generated + */ + private EClass literalEClass = null; + + /** + * + * + * @generated + */ + private EClass variableEClass = null; + + /** + * + * + * @generated + */ + private EClass allInstancesEClass = null; + + /** + * + * + * @generated + */ + private EClass allObjectsEClass = null; + + /** + * + * + * @generated + */ + private EClass defaultInterpretationEClass = null; + + /** + * + * + * @generated + */ + private EClass cdInterpretationEClass = null; + + /** + * + * + * @generated + */ + private EClass classInterpretationEClass = null; + + /** + * + * + * @generated + */ + private EClass enumInterpretationEClass = null; + + /** + * + * + * @generated + */ + private EClass fieldRelationInterpretationEClass = null; + + /** + * + * + * @generated + */ + private EClass globalRelationInterpretationEClass = null; + + /** + * + * + * @generated + */ + private EClass multiplicityDefinitionEClass = null; + + /** + * + * + * @generated + */ + private EClass booleanTrueEClass = null; + + /** + * + * + * @generated + */ + private EClass booleanFalseEClass = null; + + /** + * + * + * @generated + */ + private EClass trueEClass = null; + + /** + * + * + * @generated + */ + private EClass falseEClass = null; + + /** + * + * + * @generated + */ + private EClass unknownEClass = null; + + /** + * + * + * @generated + */ + private EClass errorEClass = null; + + /** + * + * + * @generated + */ + private EClass positiveEClass = null; + + /** + * + * + * @generated + */ + private EClass negativeEClass = null; + + /** + * + * + * @generated + */ + private EClass reflexiveClosureEClass = null; + + /** + * + * + * @generated + */ + private EClass irreflexiveClosureEClass = null; + + /** + * Creates an instance of the model Package, registered with + * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package + * package URI value. + *

Note: the correct way to create the package is via the static + * factory method {@link #init init()}, which also performs + * initialization of the package, or returns the registered package, + * if one already exists. + * + * + * @see org.eclipse.emf.ecore.EPackage.Registry + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#eNS_URI + * @see #init() + * @generated + */ + private SolverLanguagePackageImpl() + { + super(eNS_URI, SolverLanguageFactory.eINSTANCE); + } + + /** + * + * + * @generated + */ + private static boolean isInited = false; + + /** + * Creates, registers, and initializes the Package for this model, and for any others upon which it depends. + * + *

This method is used to initialize {@link SolverLanguagePackage#eINSTANCE} when that field is accessed. + * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package. + * + * + * @see #eNS_URI + * @see #createPackageContents() + * @see #initializePackageContents() + * @generated + */ + public static SolverLanguagePackage init() + { + if (isInited) return (SolverLanguagePackage)EPackage.Registry.INSTANCE.getEPackage(SolverLanguagePackage.eNS_URI); + + // Obtain or create and register package + Object registeredSolverLanguagePackage = EPackage.Registry.INSTANCE.get(eNS_URI); + SolverLanguagePackageImpl theSolverLanguagePackage = registeredSolverLanguagePackage instanceof SolverLanguagePackageImpl ? (SolverLanguagePackageImpl)registeredSolverLanguagePackage : new SolverLanguagePackageImpl(); + + isInited = true; + + // Create package meta-data objects + theSolverLanguagePackage.createPackageContents(); + + // Initialize created meta-data + theSolverLanguagePackage.initializePackageContents(); + + // Mark meta-data to indicate it can't be changed + theSolverLanguagePackage.freeze(); + + // Update the registry and return the package + EPackage.Registry.INSTANCE.put(SolverLanguagePackage.eNS_URI, theSolverLanguagePackage); + return theSolverLanguagePackage; + } + + /** + * + * + * @generated + */ + @Override + public EClass getProblem() + { + return problemEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getProblem_Statements() + { + return (EReference)problemEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getStatement() + { + return statementEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getBooleanValue() + { + return booleanValueEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getTruthValue() + { + return truthValueEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getInterpretation() + { + return interpretationEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getBasicInterpretation() + { + return basicInterpretationEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getBasicInterpretation_Symbol() + { + return (EReference)basicInterpretationEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EReference getBasicInterpretation_Objects() + { + return (EReference)basicInterpretationEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + @Override + public EReference getBasicInterpretation_Value() + { + return (EReference)basicInterpretationEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + @Override + public EClass getSymbol() + { + return symbolEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getModelSymbol() + { + return modelSymbolEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getModelSymbol_Name() + { + return (EAttribute)modelSymbolEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getPartialitySymbol() + { + return partialitySymbolEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getExistSymbol() + { + return existSymbolEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getEqualsSymbol() + { + return equalsSymbolEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getDataSymbol() + { + return dataSymbolEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getBooleanSymbol() + { + return booleanSymbolEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getIntegerSymbol() + { + return integerSymbolEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getRealSymbol() + { + return realSymbolEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getStringSymbol() + { + return stringSymbolEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getComplexObject() + { + return complexObjectEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getObject() + { + return objectEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getNamedObject() + { + return namedObjectEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getNamedObject_Name() + { + return (EAttribute)namedObjectEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getUnnamedObject() + { + return unnamedObjectEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getUnnamedObject_Name() + { + return (EAttribute)unnamedObjectEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getDataObject() + { + return dataObjectEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getBooleanObject() + { + return booleanObjectEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getBooleanObject_Value() + { + return (EReference)booleanObjectEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getIntObject() + { + return intObjectEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getIntObject_Value() + { + return (EAttribute)intObjectEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getRealObject() + { + return realObjectEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getRealObject_Value() + { + return (EAttribute)realObjectEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getStringObject() + { + return stringObjectEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getStringObject_Value() + { + return (EAttribute)stringObjectEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getPredicate() + { + return predicateEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getPredicate_Parameters() + { + return (EReference)predicateEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EReference getPredicate_Bodies() + { + return (EReference)predicateEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + @Override + public EClass getPredicateSymbol() + { + return predicateSymbolEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getPredicateSymbol_Symbol() + { + return (EReference)predicateSymbolEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getErrorPredicate() + { + return errorPredicateEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getErrorPredicate_Name() + { + return (EAttribute)errorPredicateEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getParameter() + { + return parameterEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getParameter_Variable() + { + return (EReference)parameterEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EReference getParameter_Type() + { + return (EReference)parameterEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + @Override + public EClass getPatternBody() + { + return patternBodyEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getPatternBody_Constraints() + { + return (EReference)patternBodyEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getPolarity() + { + return polarityEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getConstraint() + { + return constraintEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getConstraint_Polarity() + { + return (EReference)constraintEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EReference getConstraint_Symbol() + { + return (EReference)constraintEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + @Override + public EReference getConstraint_Params() + { + return (EReference)constraintEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + @Override + public EReference getConstraint_ClosureType() + { + return (EReference)constraintEClass.getEStructuralFeatures().get(3); + } + + /** + * + * + * @generated + */ + @Override + public EClass getClosureType() + { + return closureTypeEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getLiteral() + { + return literalEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getVariable() + { + return variableEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getVariable_Name() + { + return (EAttribute)variableEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getAllInstances() + { + return allInstancesEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getAllInstances_Symbol() + { + return (EReference)allInstancesEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getAllObjects() + { + return allObjectsEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getDefaultInterpretation() + { + return defaultInterpretationEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getDefaultInterpretation_Interpretation() + { + return (EReference)defaultInterpretationEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EClass getCDInterpretation() + { + return cdInterpretationEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getClassInterpretation() + { + return classInterpretationEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getClassInterpretation_Abstract() + { + return (EAttribute)classInterpretationEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EReference getClassInterpretation_Symbol() + { + return (EReference)classInterpretationEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + @Override + public EReference getClassInterpretation_Supertypes() + { + return (EReference)classInterpretationEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + @Override + public EReference getClassInterpretation_Fielt() + { + return (EReference)classInterpretationEClass.getEStructuralFeatures().get(3); + } + + /** + * + * + * @generated + */ + @Override + public EClass getEnumInterpretation() + { + return enumInterpretationEClass; + } + + /** + * + * + * @generated + */ + @Override + public EReference getEnumInterpretation_Symbol() + { + return (EReference)enumInterpretationEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EReference getEnumInterpretation_Objects() + { + return (EReference)enumInterpretationEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + @Override + public EClass getFieldRelationInterpretation() + { + return fieldRelationInterpretationEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getFieldRelationInterpretation_Containment() + { + return (EAttribute)fieldRelationInterpretationEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EReference getFieldRelationInterpretation_Symbol() + { + return (EReference)fieldRelationInterpretationEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + @Override + public EReference getFieldRelationInterpretation_Multiplicity() + { + return (EReference)fieldRelationInterpretationEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + @Override + public EReference getFieldRelationInterpretation_Target() + { + return (EReference)fieldRelationInterpretationEClass.getEStructuralFeatures().get(3); + } + + /** + * + * + * @generated + */ + @Override + public EClass getGlobalRelationInterpretation() + { + return globalRelationInterpretationEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getGlobalRelationInterpretation_Containment() + { + return (EAttribute)globalRelationInterpretationEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EReference getGlobalRelationInterpretation_Symbol() + { + return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + @Override + public EReference getGlobalRelationInterpretation_SourceMultiplicity() + { + return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + @Override + public EReference getGlobalRelationInterpretation_Source() + { + return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(3); + } + + /** + * + * + * @generated + */ + @Override + public EReference getGlobalRelationInterpretation_TargetMultiplicity() + { + return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(4); + } + + /** + * + * + * @generated + */ + @Override + public EReference getGlobalRelationInterpretation_Target() + { + return (EReference)globalRelationInterpretationEClass.getEStructuralFeatures().get(5); + } + + /** + * + * + * @generated + */ + @Override + public EClass getMultiplicityDefinition() + { + return multiplicityDefinitionEClass; + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getMultiplicityDefinition_Lower() + { + return (EAttribute)multiplicityDefinitionEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getMultiplicityDefinition_Upper() + { + return (EAttribute)multiplicityDefinitionEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + @Override + public EAttribute getMultiplicityDefinition_UnlimitedUpper() + { + return (EAttribute)multiplicityDefinitionEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + @Override + public EClass getBooleanTrue() + { + return booleanTrueEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getBooleanFalse() + { + return booleanFalseEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getTrue() + { + return trueEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getFalse() + { + return falseEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getUnknown() + { + return unknownEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getError() + { + return errorEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getPositive() + { + return positiveEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getNegative() + { + return negativeEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getReflexiveClosure() + { + return reflexiveClosureEClass; + } + + /** + * + * + * @generated + */ + @Override + public EClass getIrreflexiveClosure() + { + return irreflexiveClosureEClass; + } + + /** + * + * + * @generated + */ + @Override + public SolverLanguageFactory getSolverLanguageFactory() + { + return (SolverLanguageFactory)getEFactoryInstance(); + } + + /** + * + * + * @generated + */ + private boolean isCreated = false; + + /** + * Creates the meta-model objects for the package. This method is + * guarded to have no affect on any invocation but its first. + * + * + * @generated + */ + public void createPackageContents() + { + if (isCreated) return; + isCreated = true; + + // Create classes and their features + problemEClass = createEClass(PROBLEM); + createEReference(problemEClass, PROBLEM__STATEMENTS); + + statementEClass = createEClass(STATEMENT); + + booleanValueEClass = createEClass(BOOLEAN_VALUE); + + truthValueEClass = createEClass(TRUTH_VALUE); + + interpretationEClass = createEClass(INTERPRETATION); + + basicInterpretationEClass = createEClass(BASIC_INTERPRETATION); + createEReference(basicInterpretationEClass, BASIC_INTERPRETATION__SYMBOL); + createEReference(basicInterpretationEClass, BASIC_INTERPRETATION__OBJECTS); + createEReference(basicInterpretationEClass, BASIC_INTERPRETATION__VALUE); + + symbolEClass = createEClass(SYMBOL); + + modelSymbolEClass = createEClass(MODEL_SYMBOL); + createEAttribute(modelSymbolEClass, MODEL_SYMBOL__NAME); + + partialitySymbolEClass = createEClass(PARTIALITY_SYMBOL); + + existSymbolEClass = createEClass(EXIST_SYMBOL); + + equalsSymbolEClass = createEClass(EQUALS_SYMBOL); + + dataSymbolEClass = createEClass(DATA_SYMBOL); + + booleanSymbolEClass = createEClass(BOOLEAN_SYMBOL); + + integerSymbolEClass = createEClass(INTEGER_SYMBOL); + + realSymbolEClass = createEClass(REAL_SYMBOL); + + stringSymbolEClass = createEClass(STRING_SYMBOL); + + complexObjectEClass = createEClass(COMPLEX_OBJECT); + + objectEClass = createEClass(OBJECT); + + namedObjectEClass = createEClass(NAMED_OBJECT); + createEAttribute(namedObjectEClass, NAMED_OBJECT__NAME); + + unnamedObjectEClass = createEClass(UNNAMED_OBJECT); + createEAttribute(unnamedObjectEClass, UNNAMED_OBJECT__NAME); + + dataObjectEClass = createEClass(DATA_OBJECT); + + booleanObjectEClass = createEClass(BOOLEAN_OBJECT); + createEReference(booleanObjectEClass, BOOLEAN_OBJECT__VALUE); + + intObjectEClass = createEClass(INT_OBJECT); + createEAttribute(intObjectEClass, INT_OBJECT__VALUE); + + realObjectEClass = createEClass(REAL_OBJECT); + createEAttribute(realObjectEClass, REAL_OBJECT__VALUE); + + stringObjectEClass = createEClass(STRING_OBJECT); + createEAttribute(stringObjectEClass, STRING_OBJECT__VALUE); + + predicateEClass = createEClass(PREDICATE); + createEReference(predicateEClass, PREDICATE__PARAMETERS); + createEReference(predicateEClass, PREDICATE__BODIES); + + predicateSymbolEClass = createEClass(PREDICATE_SYMBOL); + createEReference(predicateSymbolEClass, PREDICATE_SYMBOL__SYMBOL); + + errorPredicateEClass = createEClass(ERROR_PREDICATE); + createEAttribute(errorPredicateEClass, ERROR_PREDICATE__NAME); + + parameterEClass = createEClass(PARAMETER); + createEReference(parameterEClass, PARAMETER__VARIABLE); + createEReference(parameterEClass, PARAMETER__TYPE); + + patternBodyEClass = createEClass(PATTERN_BODY); + createEReference(patternBodyEClass, PATTERN_BODY__CONSTRAINTS); + + polarityEClass = createEClass(POLARITY); + + constraintEClass = createEClass(CONSTRAINT); + createEReference(constraintEClass, CONSTRAINT__POLARITY); + createEReference(constraintEClass, CONSTRAINT__SYMBOL); + createEReference(constraintEClass, CONSTRAINT__PARAMS); + createEReference(constraintEClass, CONSTRAINT__CLOSURE_TYPE); + + closureTypeEClass = createEClass(CLOSURE_TYPE); + + literalEClass = createEClass(LITERAL); + + variableEClass = createEClass(VARIABLE); + createEAttribute(variableEClass, VARIABLE__NAME); + + allInstancesEClass = createEClass(ALL_INSTANCES); + createEReference(allInstancesEClass, ALL_INSTANCES__SYMBOL); + + allObjectsEClass = createEClass(ALL_OBJECTS); + + defaultInterpretationEClass = createEClass(DEFAULT_INTERPRETATION); + createEReference(defaultInterpretationEClass, DEFAULT_INTERPRETATION__INTERPRETATION); + + cdInterpretationEClass = createEClass(CD_INTERPRETATION); + + classInterpretationEClass = createEClass(CLASS_INTERPRETATION); + createEAttribute(classInterpretationEClass, CLASS_INTERPRETATION__ABSTRACT); + createEReference(classInterpretationEClass, CLASS_INTERPRETATION__SYMBOL); + createEReference(classInterpretationEClass, CLASS_INTERPRETATION__SUPERTYPES); + createEReference(classInterpretationEClass, CLASS_INTERPRETATION__FIELT); + + enumInterpretationEClass = createEClass(ENUM_INTERPRETATION); + createEReference(enumInterpretationEClass, ENUM_INTERPRETATION__SYMBOL); + createEReference(enumInterpretationEClass, ENUM_INTERPRETATION__OBJECTS); + + fieldRelationInterpretationEClass = createEClass(FIELD_RELATION_INTERPRETATION); + createEAttribute(fieldRelationInterpretationEClass, FIELD_RELATION_INTERPRETATION__CONTAINMENT); + createEReference(fieldRelationInterpretationEClass, FIELD_RELATION_INTERPRETATION__SYMBOL); + createEReference(fieldRelationInterpretationEClass, FIELD_RELATION_INTERPRETATION__MULTIPLICITY); + createEReference(fieldRelationInterpretationEClass, FIELD_RELATION_INTERPRETATION__TARGET); + + globalRelationInterpretationEClass = createEClass(GLOBAL_RELATION_INTERPRETATION); + createEAttribute(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__CONTAINMENT); + createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__SYMBOL); + createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY); + createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__SOURCE); + createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY); + createEReference(globalRelationInterpretationEClass, GLOBAL_RELATION_INTERPRETATION__TARGET); + + multiplicityDefinitionEClass = createEClass(MULTIPLICITY_DEFINITION); + createEAttribute(multiplicityDefinitionEClass, MULTIPLICITY_DEFINITION__LOWER); + createEAttribute(multiplicityDefinitionEClass, MULTIPLICITY_DEFINITION__UPPER); + createEAttribute(multiplicityDefinitionEClass, MULTIPLICITY_DEFINITION__UNLIMITED_UPPER); + + booleanTrueEClass = createEClass(BOOLEAN_TRUE); + + booleanFalseEClass = createEClass(BOOLEAN_FALSE); + + trueEClass = createEClass(TRUE); + + falseEClass = createEClass(FALSE); + + unknownEClass = createEClass(UNKNOWN); + + errorEClass = createEClass(ERROR); + + positiveEClass = createEClass(POSITIVE); + + negativeEClass = createEClass(NEGATIVE); + + reflexiveClosureEClass = createEClass(REFLEXIVE_CLOSURE); + + irreflexiveClosureEClass = createEClass(IRREFLEXIVE_CLOSURE); + } + + /** + * + * + * @generated + */ + private boolean isInitialized = false; + + /** + * Complete the initialization of the package and its meta-model. This + * method is guarded to have no affect on any invocation but its first. + * + * + * @generated + */ + public void initializePackageContents() + { + if (isInitialized) return; + isInitialized = true; + + // Initialize package + setName(eNAME); + setNsPrefix(eNS_PREFIX); + setNsURI(eNS_URI); + + // Create type parameters + + // Set bounds for type parameters + + // Add supertypes to classes + interpretationEClass.getESuperTypes().add(this.getStatement()); + basicInterpretationEClass.getESuperTypes().add(this.getInterpretation()); + modelSymbolEClass.getESuperTypes().add(this.getSymbol()); + partialitySymbolEClass.getESuperTypes().add(this.getSymbol()); + existSymbolEClass.getESuperTypes().add(this.getPartialitySymbol()); + equalsSymbolEClass.getESuperTypes().add(this.getPartialitySymbol()); + dataSymbolEClass.getESuperTypes().add(this.getSymbol()); + booleanSymbolEClass.getESuperTypes().add(this.getDataSymbol()); + integerSymbolEClass.getESuperTypes().add(this.getDataSymbol()); + realSymbolEClass.getESuperTypes().add(this.getDataSymbol()); + stringSymbolEClass.getESuperTypes().add(this.getDataSymbol()); + objectEClass.getESuperTypes().add(this.getComplexObject()); + namedObjectEClass.getESuperTypes().add(this.getObject()); + unnamedObjectEClass.getESuperTypes().add(this.getObject()); + dataObjectEClass.getESuperTypes().add(this.getObject()); + dataObjectEClass.getESuperTypes().add(this.getLiteral()); + booleanObjectEClass.getESuperTypes().add(this.getDataObject()); + intObjectEClass.getESuperTypes().add(this.getDataObject()); + realObjectEClass.getESuperTypes().add(this.getDataObject()); + stringObjectEClass.getESuperTypes().add(this.getDataObject()); + predicateEClass.getESuperTypes().add(this.getStatement()); + predicateSymbolEClass.getESuperTypes().add(this.getPredicate()); + errorPredicateEClass.getESuperTypes().add(this.getPredicate()); + variableEClass.getESuperTypes().add(this.getLiteral()); + allInstancesEClass.getESuperTypes().add(this.getComplexObject()); + allObjectsEClass.getESuperTypes().add(this.getComplexObject()); + defaultInterpretationEClass.getESuperTypes().add(this.getInterpretation()); + cdInterpretationEClass.getESuperTypes().add(this.getInterpretation()); + classInterpretationEClass.getESuperTypes().add(this.getCDInterpretation()); + enumInterpretationEClass.getESuperTypes().add(this.getCDInterpretation()); + globalRelationInterpretationEClass.getESuperTypes().add(this.getCDInterpretation()); + booleanTrueEClass.getESuperTypes().add(this.getBooleanValue()); + booleanFalseEClass.getESuperTypes().add(this.getBooleanValue()); + trueEClass.getESuperTypes().add(this.getTruthValue()); + falseEClass.getESuperTypes().add(this.getTruthValue()); + unknownEClass.getESuperTypes().add(this.getTruthValue()); + errorEClass.getESuperTypes().add(this.getTruthValue()); + positiveEClass.getESuperTypes().add(this.getPolarity()); + negativeEClass.getESuperTypes().add(this.getPolarity()); + reflexiveClosureEClass.getESuperTypes().add(this.getClosureType()); + irreflexiveClosureEClass.getESuperTypes().add(this.getClosureType()); + + // Initialize classes and features; add operations and parameters + initEClass(problemEClass, Problem.class, "Problem", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getProblem_Statements(), this.getStatement(), null, "statements", null, 0, -1, Problem.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(statementEClass, Statement.class, "Statement", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(booleanValueEClass, BooleanValue.class, "BooleanValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(truthValueEClass, TruthValue.class, "TruthValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(interpretationEClass, Interpretation.class, "Interpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(basicInterpretationEClass, BasicInterpretation.class, "BasicInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getBasicInterpretation_Symbol(), this.getSymbol(), null, "symbol", null, 0, 1, BasicInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getBasicInterpretation_Objects(), this.getComplexObject(), null, "objects", null, 0, -1, BasicInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getBasicInterpretation_Value(), this.getTruthValue(), null, "value", null, 0, 1, BasicInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(symbolEClass, Symbol.class, "Symbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(modelSymbolEClass, ModelSymbol.class, "ModelSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getModelSymbol_Name(), ecorePackage.getEString(), "name", null, 0, 1, ModelSymbol.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(partialitySymbolEClass, PartialitySymbol.class, "PartialitySymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(existSymbolEClass, ExistSymbol.class, "ExistSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(equalsSymbolEClass, EqualsSymbol.class, "EqualsSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(dataSymbolEClass, DataSymbol.class, "DataSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(booleanSymbolEClass, BooleanSymbol.class, "BooleanSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(integerSymbolEClass, IntegerSymbol.class, "IntegerSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(realSymbolEClass, RealSymbol.class, "RealSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(stringSymbolEClass, StringSymbol.class, "StringSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(complexObjectEClass, ComplexObject.class, "ComplexObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(objectEClass, org.eclipse.viatra.solver.language.solverLanguage.Object.class, "Object", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(namedObjectEClass, NamedObject.class, "NamedObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getNamedObject_Name(), ecorePackage.getEString(), "name", null, 0, 1, NamedObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(unnamedObjectEClass, UnnamedObject.class, "UnnamedObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getUnnamedObject_Name(), ecorePackage.getEString(), "name", null, 0, 1, UnnamedObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(dataObjectEClass, DataObject.class, "DataObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(booleanObjectEClass, BooleanObject.class, "BooleanObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getBooleanObject_Value(), this.getBooleanValue(), null, "value", null, 0, 1, BooleanObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(intObjectEClass, IntObject.class, "IntObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getIntObject_Value(), ecorePackage.getEInt(), "value", null, 0, 1, IntObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(realObjectEClass, RealObject.class, "RealObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getRealObject_Value(), ecorePackage.getEBigDecimal(), "value", null, 0, 1, RealObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(stringObjectEClass, StringObject.class, "StringObject", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getStringObject_Value(), ecorePackage.getEString(), "value", null, 0, 1, StringObject.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(predicateEClass, Predicate.class, "Predicate", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getPredicate_Parameters(), this.getParameter(), null, "parameters", null, 0, -1, Predicate.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getPredicate_Bodies(), this.getPatternBody(), null, "bodies", null, 0, -1, Predicate.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(predicateSymbolEClass, PredicateSymbol.class, "PredicateSymbol", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getPredicateSymbol_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, PredicateSymbol.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(errorPredicateEClass, ErrorPredicate.class, "ErrorPredicate", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getErrorPredicate_Name(), ecorePackage.getEString(), "name", null, 0, 1, ErrorPredicate.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(parameterEClass, Parameter.class, "Parameter", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getParameter_Variable(), this.getVariable(), null, "variable", null, 0, 1, Parameter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getParameter_Type(), this.getSymbol(), null, "type", null, 0, 1, Parameter.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(patternBodyEClass, PatternBody.class, "PatternBody", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getPatternBody_Constraints(), this.getConstraint(), null, "constraints", null, 0, -1, PatternBody.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(polarityEClass, Polarity.class, "Polarity", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(constraintEClass, Constraint.class, "Constraint", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getConstraint_Polarity(), this.getPolarity(), null, "polarity", null, 0, 1, Constraint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getConstraint_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, Constraint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getConstraint_Params(), this.getLiteral(), null, "params", null, 0, -1, Constraint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getConstraint_ClosureType(), this.getClosureType(), null, "closureType", null, 0, 1, Constraint.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(closureTypeEClass, ClosureType.class, "ClosureType", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(literalEClass, Literal.class, "Literal", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(variableEClass, Variable.class, "Variable", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getVariable_Name(), ecorePackage.getEString(), "name", null, 0, 1, Variable.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(allInstancesEClass, AllInstances.class, "AllInstances", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getAllInstances_Symbol(), this.getSymbol(), null, "symbol", null, 0, 1, AllInstances.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(allObjectsEClass, AllObjects.class, "AllObjects", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(defaultInterpretationEClass, DefaultInterpretation.class, "DefaultInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getDefaultInterpretation_Interpretation(), this.getBasicInterpretation(), null, "interpretation", null, 0, 1, DefaultInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(cdInterpretationEClass, CDInterpretation.class, "CDInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(classInterpretationEClass, ClassInterpretation.class, "ClassInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getClassInterpretation_Abstract(), ecorePackage.getEBoolean(), "abstract", null, 0, 1, ClassInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getClassInterpretation_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, ClassInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getClassInterpretation_Supertypes(), this.getModelSymbol(), null, "supertypes", null, 0, -1, ClassInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getClassInterpretation_Fielt(), this.getFieldRelationInterpretation(), null, "fielt", null, 0, -1, ClassInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(enumInterpretationEClass, EnumInterpretation.class, "EnumInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getEnumInterpretation_Symbol(), this.getModelSymbol(), null, "Symbol", null, 0, 1, EnumInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getEnumInterpretation_Objects(), this.getNamedObject(), null, "objects", null, 0, -1, EnumInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(fieldRelationInterpretationEClass, FieldRelationInterpretation.class, "FieldRelationInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getFieldRelationInterpretation_Containment(), ecorePackage.getEBoolean(), "containment", null, 0, 1, FieldRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getFieldRelationInterpretation_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, FieldRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getFieldRelationInterpretation_Multiplicity(), this.getMultiplicityDefinition(), null, "multiplicity", null, 0, 1, FieldRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getFieldRelationInterpretation_Target(), this.getSymbol(), null, "target", null, 0, 1, FieldRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(globalRelationInterpretationEClass, GlobalRelationInterpretation.class, "GlobalRelationInterpretation", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getGlobalRelationInterpretation_Containment(), ecorePackage.getEBoolean(), "containment", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getGlobalRelationInterpretation_Symbol(), this.getModelSymbol(), null, "symbol", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getGlobalRelationInterpretation_SourceMultiplicity(), this.getMultiplicityDefinition(), null, "sourceMultiplicity", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getGlobalRelationInterpretation_Source(), this.getSymbol(), null, "source", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getGlobalRelationInterpretation_TargetMultiplicity(), this.getMultiplicityDefinition(), null, "targetMultiplicity", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getGlobalRelationInterpretation_Target(), this.getSymbol(), null, "target", null, 0, 1, GlobalRelationInterpretation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(multiplicityDefinitionEClass, MultiplicityDefinition.class, "MultiplicityDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getMultiplicityDefinition_Lower(), ecorePackage.getEInt(), "lower", null, 0, 1, MultiplicityDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEAttribute(getMultiplicityDefinition_Upper(), ecorePackage.getEInt(), "upper", null, 0, 1, MultiplicityDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEAttribute(getMultiplicityDefinition_UnlimitedUpper(), ecorePackage.getEBoolean(), "unlimitedUpper", null, 0, 1, MultiplicityDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(booleanTrueEClass, BooleanTrue.class, "BooleanTrue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(booleanFalseEClass, BooleanFalse.class, "BooleanFalse", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(trueEClass, True.class, "True", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(falseEClass, False.class, "False", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(unknownEClass, Unknown.class, "Unknown", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(errorEClass, org.eclipse.viatra.solver.language.solverLanguage.Error.class, "Error", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(positiveEClass, Positive.class, "Positive", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(negativeEClass, Negative.class, "Negative", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(reflexiveClosureEClass, ReflexiveClosure.class, "ReflexiveClosure", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(irreflexiveClosureEClass, IrreflexiveClosure.class, "IrreflexiveClosure", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + // Create resource + createResource(eNS_URI); + } + +} //SolverLanguagePackageImpl -- cgit v1.2.3-54-g00ecf