From 60f01f46ba232ed6416054f0a6115cb2a9b70b4e Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Sat, 10 Jun 2017 19:05:05 +0200 Subject: Migrating Additional projects --- .../impl/LogiclanguagePackageImpl.java | 2032 ++++++++++++++++++++ 1 file changed, 2032 insertions(+) create mode 100644 Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/impl/LogiclanguagePackageImpl.java (limited to 'Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/impl/LogiclanguagePackageImpl.java') diff --git a/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/impl/LogiclanguagePackageImpl.java b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/impl/LogiclanguagePackageImpl.java new file mode 100644 index 00000000..b73d679d --- /dev/null +++ b/Framework/hu.bme.mit.inf.dslreasoner.logic.model/ecore-gen/hu/bme/mit/inf/dslreasoner/logic/model/logiclanguage/impl/LogiclanguagePackageImpl.java @@ -0,0 +1,2032 @@ +/** + */ +package hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.impl; + +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.And; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Assertion; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.AtomicTerm; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolLiteral; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolOperation; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.BoolTypeReference; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Constant; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDeclaration; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ConstantDefinition; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Distinct; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Divison; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Equals; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Exists; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Forall; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Function; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDeclaration; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.FunctionDefinition; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IfThenElse; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Iff; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Impl; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.InstanceOf; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntLiteral; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntOperation; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.IntTypeReference; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LessOrEqualThan; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LessThan; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguagePackage; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Minus; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Mod; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.MoreOrEqualThan; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.MoreThan; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Multiply; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Not; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Or; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Plus; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.PrimitiveRelation; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.PrimitiveTypeReference; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.QuantifiedExpression; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealLiteral; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RealTypeReference; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicDeclaration; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicValue; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Term; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDescriptor; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeReference; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.UnknownBecauseUninterpreted; +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Variable; + +import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage; + +import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.impl.LogicproblemPackageImpl; + +import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicresultPackage; + +import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.impl.LogicresultPackageImpl; + +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; + +/** + * + * An implementation of the model Package. + * + * @generated + */ +public class LogiclanguagePackageImpl extends EPackageImpl implements LogiclanguagePackage { + /** + * + * + * @generated + */ + private EClass typeEClass = null; + + /** + * + * + * @generated + */ + private EClass definedElementEClass = null; + + /** + * + * + * @generated + */ + private EClass typeDefinitionEClass = null; + + /** + * + * + * @generated + */ + private EClass typeReferenceEClass = null; + + /** + * + * + * @generated + */ + private EClass complexTypeReferenceEClass = null; + + /** + * + * + * @generated + */ + private EClass primitiveTypeReferenceEClass = null; + + /** + * + * + * @generated + */ + private EClass intTypeReferenceEClass = null; + + /** + * + * + * @generated + */ + private EClass boolTypeReferenceEClass = null; + + /** + * + * + * @generated + */ + private EClass realTypeReferenceEClass = null; + + /** + * + * + * @generated + */ + private EClass functionEClass = null; + + /** + * + * + * @generated + */ + private EClass termEClass = null; + + /** + * + * + * @generated + */ + private EClass symbolicDeclarationEClass = null; + + /** + * + * + * @generated + */ + private EClass symbolicValueEClass = null; + + /** + * + * + * @generated + */ + private EClass atomicTermEClass = null; + + /** + * + * + * @generated + */ + private EClass intLiteralEClass = null; + + /** + * + * + * @generated + */ + private EClass boolLiteralEClass = null; + + /** + * + * + * @generated + */ + private EClass realLiteralEClass = null; + + /** + * + * + * @generated + */ + private EClass variableEClass = null; + + /** + * + * + * @generated + */ + private EClass quantifiedExpressionEClass = null; + + /** + * + * + * @generated + */ + private EClass existsEClass = null; + + /** + * + * + * @generated + */ + private EClass forallEClass = null; + + /** + * + * + * @generated + */ + private EClass boolOperationEClass = null; + + /** + * + * + * @generated + */ + private EClass andEClass = null; + + /** + * + * + * @generated + */ + private EClass orEClass = null; + + /** + * + * + * @generated + */ + private EClass implEClass = null; + + /** + * + * + * @generated + */ + private EClass notEClass = null; + + /** + * + * + * @generated + */ + private EClass iffEClass = null; + + /** + * + * + * @generated + */ + private EClass primitiveRelationEClass = null; + + /** + * + * + * @generated + */ + private EClass equalsEClass = null; + + /** + * + * + * @generated + */ + private EClass distinctEClass = null; + + /** + * + * + * @generated + */ + private EClass lessThanEClass = null; + + /** + * + * + * @generated + */ + private EClass moreThanEClass = null; + + /** + * + * + * @generated + */ + private EClass lessOrEqualThanEClass = null; + + /** + * + * + * @generated + */ + private EClass moreOrEqualThanEClass = null; + + /** + * + * + * @generated + */ + private EClass intOperationEClass = null; + + /** + * + * + * @generated + */ + private EClass plusEClass = null; + + /** + * + * + * @generated + */ + private EClass minusEClass = null; + + /** + * + * + * @generated + */ + private EClass multiplyEClass = null; + + /** + * + * + * @generated + */ + private EClass divisonEClass = null; + + /** + * + * + * @generated + */ + private EClass modEClass = null; + + /** + * + * + * @generated + */ + private EClass typeDescriptorEClass = null; + + /** + * + * + * @generated + */ + private EClass termDescriptionEClass = null; + + /** + * + * + * @generated + */ + private EClass assertionEClass = null; + + /** + * + * + * @generated + */ + private EClass relationEClass = null; + + /** + * + * + * @generated + */ + private EClass constantEClass = null; + + /** + * + * + * @generated + */ + private EClass constantDefinitionEClass = null; + + /** + * + * + * @generated + */ + private EClass relationDefinitionEClass = null; + + /** + * + * + * @generated + */ + private EClass functionDefinitionEClass = null; + + /** + * + * + * @generated + */ + private EClass ifThenElseEClass = null; + + /** + * + * + * @generated + */ + private EClass constantDeclarationEClass = null; + + /** + * + * + * @generated + */ + private EClass relationDeclarationEClass = null; + + /** + * + * + * @generated + */ + private EClass functionDeclarationEClass = null; + + /** + * + * + * @generated + */ + private EClass typeDeclarationEClass = null; + + /** + * + * + * @generated + */ + private EClass unknownBecauseUninterpretedEClass = null; + + /** + * + * + * @generated + */ + private EClass instanceOfEClass = 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 hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguagePackage#eNS_URI + * @see #init() + * @generated + */ + private LogiclanguagePackageImpl() { + super(eNS_URI, LogiclanguageFactory.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 LogiclanguagePackage#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 LogiclanguagePackage init() { + if (isInited) return (LogiclanguagePackage)EPackage.Registry.INSTANCE.getEPackage(LogiclanguagePackage.eNS_URI); + + // Obtain or create and register package + LogiclanguagePackageImpl theLogiclanguagePackage = (LogiclanguagePackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof LogiclanguagePackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new LogiclanguagePackageImpl()); + + isInited = true; + + // Obtain or create and register interdependencies + LogicproblemPackageImpl theLogicproblemPackage = (LogicproblemPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(LogicproblemPackage.eNS_URI) instanceof LogicproblemPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(LogicproblemPackage.eNS_URI) : LogicproblemPackage.eINSTANCE); + LogicresultPackageImpl theLogicresultPackage = (LogicresultPackageImpl)(EPackage.Registry.INSTANCE.getEPackage(LogicresultPackage.eNS_URI) instanceof LogicresultPackageImpl ? EPackage.Registry.INSTANCE.getEPackage(LogicresultPackage.eNS_URI) : LogicresultPackage.eINSTANCE); + + // Create package meta-data objects + theLogiclanguagePackage.createPackageContents(); + theLogicproblemPackage.createPackageContents(); + theLogicresultPackage.createPackageContents(); + + // Initialize created meta-data + theLogiclanguagePackage.initializePackageContents(); + theLogicproblemPackage.initializePackageContents(); + theLogicresultPackage.initializePackageContents(); + + // Mark meta-data to indicate it can't be changed + theLogiclanguagePackage.freeze(); + + + // Update the registry and return the package + EPackage.Registry.INSTANCE.put(LogiclanguagePackage.eNS_URI, theLogiclanguagePackage); + return theLogiclanguagePackage; + } + + /** + * + * + * @generated + */ + public EClass getType() { + return typeEClass; + } + + /** + * + * + * @generated + */ + public EAttribute getType_Name() { + return (EAttribute)typeEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getType_Subtypes() { + return (EReference)typeEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EReference getType_Supertypes() { + return (EReference)typeEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + public EAttribute getType_IsAbstract() { + return (EAttribute)typeEClass.getEStructuralFeatures().get(3); + } + + /** + * + * + * @generated + */ + public EClass getDefinedElement() { + return definedElementEClass; + } + + /** + * + * + * @generated + */ + public EReference getDefinedElement_DefinedInType() { + return (EReference)definedElementEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getTypeDefinition() { + return typeDefinitionEClass; + } + + /** + * + * + * @generated + */ + public EReference getTypeDefinition_Elements() { + return (EReference)typeDefinitionEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getTypeDefinition_Defines() { + return (EReference)typeDefinitionEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getTypeReference() { + return typeReferenceEClass; + } + + /** + * + * + * @generated + */ + public EClass getComplexTypeReference() { + return complexTypeReferenceEClass; + } + + /** + * + * + * @generated + */ + public EReference getComplexTypeReference_Referred() { + return (EReference)complexTypeReferenceEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getPrimitiveTypeReference() { + return primitiveTypeReferenceEClass; + } + + /** + * + * + * @generated + */ + public EClass getIntTypeReference() { + return intTypeReferenceEClass; + } + + /** + * + * + * @generated + */ + public EClass getBoolTypeReference() { + return boolTypeReferenceEClass; + } + + /** + * + * + * @generated + */ + public EClass getRealTypeReference() { + return realTypeReferenceEClass; + } + + /** + * + * + * @generated + */ + public EClass getFunction() { + return functionEClass; + } + + /** + * + * + * @generated + */ + public EReference getFunction_Range() { + return (EReference)functionEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getFunction_Parameters() { + return (EReference)functionEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EReference getFunction_Annotations() { + return (EReference)functionEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + public EClass getTerm() { + return termEClass; + } + + /** + * + * + * @generated + */ + public EClass getSymbolicDeclaration() { + return symbolicDeclarationEClass; + } + + /** + * + * + * @generated + */ + public EAttribute getSymbolicDeclaration_Name() { + return (EAttribute)symbolicDeclarationEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getSymbolicValue() { + return symbolicValueEClass; + } + + /** + * + * + * @generated + */ + public EReference getSymbolicValue_SymbolicReference() { + return (EReference)symbolicValueEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getSymbolicValue_ParameterSubstitutions() { + return (EReference)symbolicValueEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getAtomicTerm() { + return atomicTermEClass; + } + + /** + * + * + * @generated + */ + public EClass getIntLiteral() { + return intLiteralEClass; + } + + /** + * + * + * @generated + */ + public EAttribute getIntLiteral_Value() { + return (EAttribute)intLiteralEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getBoolLiteral() { + return boolLiteralEClass; + } + + /** + * + * + * @generated + */ + public EAttribute getBoolLiteral_Value() { + return (EAttribute)boolLiteralEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getRealLiteral() { + return realLiteralEClass; + } + + /** + * + * + * @generated + */ + public EAttribute getRealLiteral_Value() { + return (EAttribute)realLiteralEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getVariable() { + return variableEClass; + } + + /** + * + * + * @generated + */ + public EReference getVariable_Range() { + return (EReference)variableEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getQuantifiedExpression() { + return quantifiedExpressionEClass; + } + + /** + * + * + * @generated + */ + public EReference getQuantifiedExpression_QuantifiedVariables() { + return (EReference)quantifiedExpressionEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getQuantifiedExpression_Expression() { + return (EReference)quantifiedExpressionEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getExists() { + return existsEClass; + } + + /** + * + * + * @generated + */ + public EClass getForall() { + return forallEClass; + } + + /** + * + * + * @generated + */ + public EClass getBoolOperation() { + return boolOperationEClass; + } + + /** + * + * + * @generated + */ + public EClass getAnd() { + return andEClass; + } + + /** + * + * + * @generated + */ + public EReference getAnd_Operands() { + return (EReference)andEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getOr() { + return orEClass; + } + + /** + * + * + * @generated + */ + public EReference getOr_Operands() { + return (EReference)orEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getImpl() { + return implEClass; + } + + /** + * + * + * @generated + */ + public EReference getImpl_LeftOperand() { + return (EReference)implEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getImpl_RightOperand() { + return (EReference)implEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getNot() { + return notEClass; + } + + /** + * + * + * @generated + */ + public EReference getNot_Operand() { + return (EReference)notEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getIff() { + return iffEClass; + } + + /** + * + * + * @generated + */ + public EReference getIff_LeftOperand() { + return (EReference)iffEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getIff_RightOperand() { + return (EReference)iffEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getPrimitiveRelation() { + return primitiveRelationEClass; + } + + /** + * + * + * @generated + */ + public EClass getEquals() { + return equalsEClass; + } + + /** + * + * + * @generated + */ + public EReference getEquals_LeftOperand() { + return (EReference)equalsEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getEquals_RightOperand() { + return (EReference)equalsEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getDistinct() { + return distinctEClass; + } + + /** + * + * + * @generated + */ + public EReference getDistinct_Operands() { + return (EReference)distinctEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EClass getLessThan() { + return lessThanEClass; + } + + /** + * + * + * @generated + */ + public EReference getLessThan_LeftOperand() { + return (EReference)lessThanEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getLessThan_RightOperand() { + return (EReference)lessThanEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getMoreThan() { + return moreThanEClass; + } + + /** + * + * + * @generated + */ + public EReference getMoreThan_LeftOperand() { + return (EReference)moreThanEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getMoreThan_RightOperand() { + return (EReference)moreThanEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getLessOrEqualThan() { + return lessOrEqualThanEClass; + } + + /** + * + * + * @generated + */ + public EReference getLessOrEqualThan_LeftOperand() { + return (EReference)lessOrEqualThanEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getLessOrEqualThan_RightOperand() { + return (EReference)lessOrEqualThanEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getMoreOrEqualThan() { + return moreOrEqualThanEClass; + } + + /** + * + * + * @generated + */ + public EReference getMoreOrEqualThan_LeftOperand() { + return (EReference)moreOrEqualThanEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getMoreOrEqualThan_RightOperand() { + return (EReference)moreOrEqualThanEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getIntOperation() { + return intOperationEClass; + } + + /** + * + * + * @generated + */ + public EReference getIntOperation_LeftOperand() { + return (EReference)intOperationEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getIntOperation_RightOperand() { + return (EReference)intOperationEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getPlus() { + return plusEClass; + } + + /** + * + * + * @generated + */ + public EClass getMinus() { + return minusEClass; + } + + /** + * + * + * @generated + */ + public EClass getMultiply() { + return multiplyEClass; + } + + /** + * + * + * @generated + */ + public EClass getDivison() { + return divisonEClass; + } + + /** + * + * + * @generated + */ + public EClass getMod() { + return modEClass; + } + + /** + * + * + * @generated + */ + public EClass getTypeDescriptor() { + return typeDescriptorEClass; + } + + /** + * + * + * @generated + */ + public EClass getTermDescription() { + return termDescriptionEClass; + } + + /** + * + * + * @generated + */ + public EClass getAssertion() { + return assertionEClass; + } + + /** + * + * + * @generated + */ + public EReference getAssertion_Value() { + return (EReference)assertionEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EAttribute getAssertion_Name() { + return (EAttribute)assertionEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EReference getAssertion_Annotations() { + return (EReference)assertionEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + public EClass getRelation() { + return relationEClass; + } + + /** + * + * + * @generated + */ + public EReference getRelation_Parameters() { + return (EReference)relationEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getRelation_Annotations() { + return (EReference)relationEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getConstant() { + return constantEClass; + } + + /** + * + * + * @generated + */ + public EReference getConstant_Type() { + return (EReference)constantEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getConstant_Annotations() { + return (EReference)constantEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getConstantDefinition() { + return constantDefinitionEClass; + } + + /** + * + * + * @generated + */ + public EReference getConstantDefinition_Value() { + return (EReference)constantDefinitionEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getConstantDefinition_Defines() { + return (EReference)constantDefinitionEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EClass getRelationDefinition() { + return relationDefinitionEClass; + } + + /** + * + * + * @generated + */ + public EReference getRelationDefinition_Variables() { + return (EReference)relationDefinitionEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getRelationDefinition_Value() { + return (EReference)relationDefinitionEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EReference getRelationDefinition_Defines() { + return (EReference)relationDefinitionEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + public EClass getFunctionDefinition() { + return functionDefinitionEClass; + } + + /** + * + * + * @generated + */ + public EReference getFunctionDefinition_Variable() { + return (EReference)functionDefinitionEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getFunctionDefinition_Defines() { + return (EReference)functionDefinitionEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EReference getFunctionDefinition_Value() { + return (EReference)functionDefinitionEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + public EClass getIfThenElse() { + return ifThenElseEClass; + } + + /** + * + * + * @generated + */ + public EReference getIfThenElse_Condition() { + return (EReference)ifThenElseEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getIfThenElse_IfTrue() { + return (EReference)ifThenElseEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public EReference getIfThenElse_IfFalse() { + return (EReference)ifThenElseEClass.getEStructuralFeatures().get(2); + } + + /** + * + * + * @generated + */ + public EClass getConstantDeclaration() { + return constantDeclarationEClass; + } + + /** + * + * + * @generated + */ + public EClass getRelationDeclaration() { + return relationDeclarationEClass; + } + + /** + * + * + * @generated + */ + public EClass getFunctionDeclaration() { + return functionDeclarationEClass; + } + + /** + * + * + * @generated + */ + public EClass getTypeDeclaration() { + return typeDeclarationEClass; + } + + /** + * + * + * @generated + */ + public EClass getUnknownBecauseUninterpreted() { + return unknownBecauseUninterpretedEClass; + } + + /** + * + * + * @generated + */ + public EClass getInstanceOf() { + return instanceOfEClass; + } + + /** + * + * + * @generated + */ + public EReference getInstanceOf_Value() { + return (EReference)instanceOfEClass.getEStructuralFeatures().get(0); + } + + /** + * + * + * @generated + */ + public EReference getInstanceOf_Range() { + return (EReference)instanceOfEClass.getEStructuralFeatures().get(1); + } + + /** + * + * + * @generated + */ + public LogiclanguageFactory getLogiclanguageFactory() { + return (LogiclanguageFactory)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 + typeEClass = createEClass(TYPE); + createEAttribute(typeEClass, TYPE__NAME); + createEReference(typeEClass, TYPE__SUBTYPES); + createEReference(typeEClass, TYPE__SUPERTYPES); + createEAttribute(typeEClass, TYPE__IS_ABSTRACT); + + definedElementEClass = createEClass(DEFINED_ELEMENT); + createEReference(definedElementEClass, DEFINED_ELEMENT__DEFINED_IN_TYPE); + + typeDefinitionEClass = createEClass(TYPE_DEFINITION); + createEReference(typeDefinitionEClass, TYPE_DEFINITION__ELEMENTS); + createEReference(typeDefinitionEClass, TYPE_DEFINITION__DEFINES); + + typeReferenceEClass = createEClass(TYPE_REFERENCE); + + complexTypeReferenceEClass = createEClass(COMPLEX_TYPE_REFERENCE); + createEReference(complexTypeReferenceEClass, COMPLEX_TYPE_REFERENCE__REFERRED); + + primitiveTypeReferenceEClass = createEClass(PRIMITIVE_TYPE_REFERENCE); + + intTypeReferenceEClass = createEClass(INT_TYPE_REFERENCE); + + boolTypeReferenceEClass = createEClass(BOOL_TYPE_REFERENCE); + + realTypeReferenceEClass = createEClass(REAL_TYPE_REFERENCE); + + functionEClass = createEClass(FUNCTION); + createEReference(functionEClass, FUNCTION__RANGE); + createEReference(functionEClass, FUNCTION__PARAMETERS); + createEReference(functionEClass, FUNCTION__ANNOTATIONS); + + termEClass = createEClass(TERM); + + symbolicDeclarationEClass = createEClass(SYMBOLIC_DECLARATION); + createEAttribute(symbolicDeclarationEClass, SYMBOLIC_DECLARATION__NAME); + + symbolicValueEClass = createEClass(SYMBOLIC_VALUE); + createEReference(symbolicValueEClass, SYMBOLIC_VALUE__SYMBOLIC_REFERENCE); + createEReference(symbolicValueEClass, SYMBOLIC_VALUE__PARAMETER_SUBSTITUTIONS); + + atomicTermEClass = createEClass(ATOMIC_TERM); + + intLiteralEClass = createEClass(INT_LITERAL); + createEAttribute(intLiteralEClass, INT_LITERAL__VALUE); + + boolLiteralEClass = createEClass(BOOL_LITERAL); + createEAttribute(boolLiteralEClass, BOOL_LITERAL__VALUE); + + realLiteralEClass = createEClass(REAL_LITERAL); + createEAttribute(realLiteralEClass, REAL_LITERAL__VALUE); + + variableEClass = createEClass(VARIABLE); + createEReference(variableEClass, VARIABLE__RANGE); + + quantifiedExpressionEClass = createEClass(QUANTIFIED_EXPRESSION); + createEReference(quantifiedExpressionEClass, QUANTIFIED_EXPRESSION__QUANTIFIED_VARIABLES); + createEReference(quantifiedExpressionEClass, QUANTIFIED_EXPRESSION__EXPRESSION); + + existsEClass = createEClass(EXISTS); + + forallEClass = createEClass(FORALL); + + boolOperationEClass = createEClass(BOOL_OPERATION); + + andEClass = createEClass(AND); + createEReference(andEClass, AND__OPERANDS); + + orEClass = createEClass(OR); + createEReference(orEClass, OR__OPERANDS); + + implEClass = createEClass(IMPL); + createEReference(implEClass, IMPL__LEFT_OPERAND); + createEReference(implEClass, IMPL__RIGHT_OPERAND); + + notEClass = createEClass(NOT); + createEReference(notEClass, NOT__OPERAND); + + iffEClass = createEClass(IFF); + createEReference(iffEClass, IFF__LEFT_OPERAND); + createEReference(iffEClass, IFF__RIGHT_OPERAND); + + primitiveRelationEClass = createEClass(PRIMITIVE_RELATION); + + equalsEClass = createEClass(EQUALS); + createEReference(equalsEClass, EQUALS__LEFT_OPERAND); + createEReference(equalsEClass, EQUALS__RIGHT_OPERAND); + + distinctEClass = createEClass(DISTINCT); + createEReference(distinctEClass, DISTINCT__OPERANDS); + + lessThanEClass = createEClass(LESS_THAN); + createEReference(lessThanEClass, LESS_THAN__LEFT_OPERAND); + createEReference(lessThanEClass, LESS_THAN__RIGHT_OPERAND); + + moreThanEClass = createEClass(MORE_THAN); + createEReference(moreThanEClass, MORE_THAN__LEFT_OPERAND); + createEReference(moreThanEClass, MORE_THAN__RIGHT_OPERAND); + + lessOrEqualThanEClass = createEClass(LESS_OR_EQUAL_THAN); + createEReference(lessOrEqualThanEClass, LESS_OR_EQUAL_THAN__LEFT_OPERAND); + createEReference(lessOrEqualThanEClass, LESS_OR_EQUAL_THAN__RIGHT_OPERAND); + + moreOrEqualThanEClass = createEClass(MORE_OR_EQUAL_THAN); + createEReference(moreOrEqualThanEClass, MORE_OR_EQUAL_THAN__LEFT_OPERAND); + createEReference(moreOrEqualThanEClass, MORE_OR_EQUAL_THAN__RIGHT_OPERAND); + + intOperationEClass = createEClass(INT_OPERATION); + createEReference(intOperationEClass, INT_OPERATION__LEFT_OPERAND); + createEReference(intOperationEClass, INT_OPERATION__RIGHT_OPERAND); + + plusEClass = createEClass(PLUS); + + minusEClass = createEClass(MINUS); + + multiplyEClass = createEClass(MULTIPLY); + + divisonEClass = createEClass(DIVISON); + + modEClass = createEClass(MOD); + + typeDescriptorEClass = createEClass(TYPE_DESCRIPTOR); + + termDescriptionEClass = createEClass(TERM_DESCRIPTION); + + assertionEClass = createEClass(ASSERTION); + createEReference(assertionEClass, ASSERTION__VALUE); + createEAttribute(assertionEClass, ASSERTION__NAME); + createEReference(assertionEClass, ASSERTION__ANNOTATIONS); + + relationEClass = createEClass(RELATION); + createEReference(relationEClass, RELATION__PARAMETERS); + createEReference(relationEClass, RELATION__ANNOTATIONS); + + constantEClass = createEClass(CONSTANT); + createEReference(constantEClass, CONSTANT__TYPE); + createEReference(constantEClass, CONSTANT__ANNOTATIONS); + + constantDefinitionEClass = createEClass(CONSTANT_DEFINITION); + createEReference(constantDefinitionEClass, CONSTANT_DEFINITION__VALUE); + createEReference(constantDefinitionEClass, CONSTANT_DEFINITION__DEFINES); + + relationDefinitionEClass = createEClass(RELATION_DEFINITION); + createEReference(relationDefinitionEClass, RELATION_DEFINITION__VARIABLES); + createEReference(relationDefinitionEClass, RELATION_DEFINITION__VALUE); + createEReference(relationDefinitionEClass, RELATION_DEFINITION__DEFINES); + + functionDefinitionEClass = createEClass(FUNCTION_DEFINITION); + createEReference(functionDefinitionEClass, FUNCTION_DEFINITION__VARIABLE); + createEReference(functionDefinitionEClass, FUNCTION_DEFINITION__DEFINES); + createEReference(functionDefinitionEClass, FUNCTION_DEFINITION__VALUE); + + ifThenElseEClass = createEClass(IF_THEN_ELSE); + createEReference(ifThenElseEClass, IF_THEN_ELSE__CONDITION); + createEReference(ifThenElseEClass, IF_THEN_ELSE__IF_TRUE); + createEReference(ifThenElseEClass, IF_THEN_ELSE__IF_FALSE); + + constantDeclarationEClass = createEClass(CONSTANT_DECLARATION); + + relationDeclarationEClass = createEClass(RELATION_DECLARATION); + + functionDeclarationEClass = createEClass(FUNCTION_DECLARATION); + + typeDeclarationEClass = createEClass(TYPE_DECLARATION); + + unknownBecauseUninterpretedEClass = createEClass(UNKNOWN_BECAUSE_UNINTERPRETED); + + instanceOfEClass = createEClass(INSTANCE_OF); + createEReference(instanceOfEClass, INSTANCE_OF__VALUE); + createEReference(instanceOfEClass, INSTANCE_OF__RANGE); + } + + /** + * + * + * @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); + + // Obtain other dependent packages + LogicproblemPackage theLogicproblemPackage = (LogicproblemPackage)EPackage.Registry.INSTANCE.getEPackage(LogicproblemPackage.eNS_URI); + + // Create type parameters + + // Set bounds for type parameters + + // Add supertypes to classes + typeEClass.getESuperTypes().add(this.getTypeDescriptor()); + definedElementEClass.getESuperTypes().add(this.getSymbolicDeclaration()); + typeDefinitionEClass.getESuperTypes().add(this.getType()); + typeReferenceEClass.getESuperTypes().add(this.getTypeDescriptor()); + complexTypeReferenceEClass.getESuperTypes().add(this.getTypeReference()); + primitiveTypeReferenceEClass.getESuperTypes().add(this.getTypeReference()); + intTypeReferenceEClass.getESuperTypes().add(this.getPrimitiveTypeReference()); + boolTypeReferenceEClass.getESuperTypes().add(this.getPrimitiveTypeReference()); + realTypeReferenceEClass.getESuperTypes().add(this.getPrimitiveTypeReference()); + functionEClass.getESuperTypes().add(this.getSymbolicDeclaration()); + termEClass.getESuperTypes().add(this.getTermDescription()); + symbolicDeclarationEClass.getESuperTypes().add(this.getTermDescription()); + symbolicValueEClass.getESuperTypes().add(this.getTerm()); + atomicTermEClass.getESuperTypes().add(this.getTerm()); + intLiteralEClass.getESuperTypes().add(this.getAtomicTerm()); + boolLiteralEClass.getESuperTypes().add(this.getAtomicTerm()); + realLiteralEClass.getESuperTypes().add(this.getAtomicTerm()); + variableEClass.getESuperTypes().add(this.getSymbolicDeclaration()); + quantifiedExpressionEClass.getESuperTypes().add(this.getTerm()); + existsEClass.getESuperTypes().add(this.getQuantifiedExpression()); + forallEClass.getESuperTypes().add(this.getQuantifiedExpression()); + boolOperationEClass.getESuperTypes().add(this.getTerm()); + andEClass.getESuperTypes().add(this.getBoolOperation()); + orEClass.getESuperTypes().add(this.getBoolOperation()); + implEClass.getESuperTypes().add(this.getBoolOperation()); + notEClass.getESuperTypes().add(this.getBoolOperation()); + iffEClass.getESuperTypes().add(this.getBoolOperation()); + primitiveRelationEClass.getESuperTypes().add(this.getTerm()); + equalsEClass.getESuperTypes().add(this.getPrimitiveRelation()); + distinctEClass.getESuperTypes().add(this.getPrimitiveRelation()); + lessThanEClass.getESuperTypes().add(this.getPrimitiveRelation()); + moreThanEClass.getESuperTypes().add(this.getPrimitiveRelation()); + lessOrEqualThanEClass.getESuperTypes().add(this.getPrimitiveRelation()); + moreOrEqualThanEClass.getESuperTypes().add(this.getPrimitiveRelation()); + intOperationEClass.getESuperTypes().add(this.getTerm()); + plusEClass.getESuperTypes().add(this.getIntOperation()); + minusEClass.getESuperTypes().add(this.getIntOperation()); + multiplyEClass.getESuperTypes().add(this.getIntOperation()); + divisonEClass.getESuperTypes().add(this.getIntOperation()); + modEClass.getESuperTypes().add(this.getIntOperation()); + relationEClass.getESuperTypes().add(this.getSymbolicDeclaration()); + constantEClass.getESuperTypes().add(this.getSymbolicDeclaration()); + constantDefinitionEClass.getESuperTypes().add(this.getConstant()); + relationDefinitionEClass.getESuperTypes().add(this.getRelation()); + functionDefinitionEClass.getESuperTypes().add(this.getFunction()); + ifThenElseEClass.getESuperTypes().add(this.getTerm()); + constantDeclarationEClass.getESuperTypes().add(this.getConstant()); + relationDeclarationEClass.getESuperTypes().add(this.getRelation()); + functionDeclarationEClass.getESuperTypes().add(this.getFunction()); + typeDeclarationEClass.getESuperTypes().add(this.getType()); + unknownBecauseUninterpretedEClass.getESuperTypes().add(this.getTerm()); + instanceOfEClass.getESuperTypes().add(this.getTerm()); + + // Initialize classes, features, and operations; add parameters + initEClass(typeEClass, Type.class, "Type", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getType_Name(), ecorePackage.getEString(), "name", null, 1, 1, Type.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getType_Subtypes(), this.getType(), this.getType_Supertypes(), "subtypes", null, 0, -1, Type.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getType_Supertypes(), this.getType(), this.getType_Subtypes(), "supertypes", null, 0, -1, Type.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEAttribute(getType_IsAbstract(), ecorePackage.getEBoolean(), "isAbstract", null, 1, 1, Type.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(definedElementEClass, DefinedElement.class, "DefinedElement", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getDefinedElement_DefinedInType(), this.getTypeDefinition(), this.getTypeDefinition_Elements(), "definedInType", null, 1, -1, DefinedElement.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(typeDefinitionEClass, TypeDefinition.class, "TypeDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getTypeDefinition_Elements(), this.getDefinedElement(), this.getDefinedElement_DefinedInType(), "elements", null, 0, -1, TypeDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getTypeDefinition_Defines(), this.getTypeDeclaration(), null, "defines", null, 0, 1, TypeDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(typeReferenceEClass, TypeReference.class, "TypeReference", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(complexTypeReferenceEClass, ComplexTypeReference.class, "ComplexTypeReference", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getComplexTypeReference_Referred(), this.getType(), null, "referred", null, 0, 1, ComplexTypeReference.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(primitiveTypeReferenceEClass, PrimitiveTypeReference.class, "PrimitiveTypeReference", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(intTypeReferenceEClass, IntTypeReference.class, "IntTypeReference", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(boolTypeReferenceEClass, BoolTypeReference.class, "BoolTypeReference", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(realTypeReferenceEClass, RealTypeReference.class, "RealTypeReference", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(functionEClass, Function.class, "Function", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getFunction_Range(), this.getTypeReference(), null, "range", null, 1, 1, Function.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getFunction_Parameters(), this.getTypeReference(), null, "parameters", null, 0, -1, Function.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getFunction_Annotations(), theLogicproblemPackage.getFunctionAnnotation(), theLogicproblemPackage.getFunctionAnnotation_Target(), "annotations", null, 0, -1, Function.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(termEClass, Term.class, "Term", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(symbolicDeclarationEClass, SymbolicDeclaration.class, "SymbolicDeclaration", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getSymbolicDeclaration_Name(), ecorePackage.getEString(), "name", null, 1, 1, SymbolicDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(symbolicValueEClass, SymbolicValue.class, "SymbolicValue", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getSymbolicValue_SymbolicReference(), this.getSymbolicDeclaration(), null, "symbolicReference", null, 0, 1, SymbolicValue.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getSymbolicValue_ParameterSubstitutions(), this.getTerm(), null, "parameterSubstitutions", null, 0, -1, SymbolicValue.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(atomicTermEClass, AtomicTerm.class, "AtomicTerm", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(intLiteralEClass, IntLiteral.class, "IntLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getIntLiteral_Value(), ecorePackage.getEInt(), "value", null, 0, 1, IntLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(boolLiteralEClass, BoolLiteral.class, "BoolLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getBoolLiteral_Value(), ecorePackage.getEBoolean(), "value", null, 0, 1, BoolLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(realLiteralEClass, RealLiteral.class, "RealLiteral", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEAttribute(getRealLiteral_Value(), ecorePackage.getEBigDecimal(), "value", null, 0, 1, RealLiteral.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(variableEClass, Variable.class, "Variable", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getVariable_Range(), this.getTypeReference(), null, "range", null, 1, 1, Variable.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(quantifiedExpressionEClass, QuantifiedExpression.class, "QuantifiedExpression", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getQuantifiedExpression_QuantifiedVariables(), this.getVariable(), null, "quantifiedVariables", null, 0, -1, QuantifiedExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getQuantifiedExpression_Expression(), this.getTerm(), null, "expression", null, 0, 1, QuantifiedExpression.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(existsEClass, Exists.class, "Exists", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(forallEClass, Forall.class, "Forall", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(boolOperationEClass, BoolOperation.class, "BoolOperation", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(andEClass, And.class, "And", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getAnd_Operands(), this.getTerm(), null, "operands", null, 0, -1, And.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(orEClass, Or.class, "Or", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getOr_Operands(), this.getTerm(), null, "operands", null, 0, -1, Or.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(implEClass, Impl.class, "Impl", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getImpl_LeftOperand(), this.getTerm(), null, "leftOperand", null, 0, 1, Impl.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getImpl_RightOperand(), this.getTerm(), null, "rightOperand", null, 0, 1, Impl.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(notEClass, Not.class, "Not", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getNot_Operand(), this.getTerm(), null, "operand", null, 0, 1, Not.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(iffEClass, Iff.class, "Iff", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getIff_LeftOperand(), this.getTerm(), null, "leftOperand", null, 0, 1, Iff.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getIff_RightOperand(), this.getTerm(), null, "rightOperand", null, 0, 1, Iff.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(primitiveRelationEClass, PrimitiveRelation.class, "PrimitiveRelation", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(equalsEClass, Equals.class, "Equals", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getEquals_LeftOperand(), this.getTerm(), null, "leftOperand", null, 0, 1, Equals.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getEquals_RightOperand(), this.getTerm(), null, "rightOperand", null, 0, 1, Equals.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(distinctEClass, Distinct.class, "Distinct", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getDistinct_Operands(), this.getTerm(), null, "operands", null, 0, -1, Distinct.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(lessThanEClass, LessThan.class, "LessThan", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getLessThan_LeftOperand(), this.getTerm(), null, "leftOperand", null, 0, 1, LessThan.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getLessThan_RightOperand(), this.getTerm(), null, "rightOperand", null, 0, 1, LessThan.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(moreThanEClass, MoreThan.class, "MoreThan", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getMoreThan_LeftOperand(), this.getTerm(), null, "leftOperand", null, 0, 1, MoreThan.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getMoreThan_RightOperand(), this.getTerm(), null, "rightOperand", null, 0, 1, MoreThan.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(lessOrEqualThanEClass, LessOrEqualThan.class, "LessOrEqualThan", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getLessOrEqualThan_LeftOperand(), this.getTerm(), null, "leftOperand", null, 0, 1, LessOrEqualThan.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getLessOrEqualThan_RightOperand(), this.getTerm(), null, "rightOperand", null, 0, 1, LessOrEqualThan.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(moreOrEqualThanEClass, MoreOrEqualThan.class, "MoreOrEqualThan", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getMoreOrEqualThan_LeftOperand(), this.getTerm(), null, "leftOperand", null, 0, 1, MoreOrEqualThan.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getMoreOrEqualThan_RightOperand(), this.getTerm(), null, "rightOperand", null, 0, 1, MoreOrEqualThan.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(intOperationEClass, IntOperation.class, "IntOperation", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getIntOperation_LeftOperand(), this.getTerm(), null, "leftOperand", null, 0, 1, IntOperation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getIntOperation_RightOperand(), this.getTerm(), null, "rightOperand", null, 0, 1, IntOperation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(plusEClass, Plus.class, "Plus", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(minusEClass, Minus.class, "Minus", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(multiplyEClass, Multiply.class, "Multiply", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(divisonEClass, Divison.class, "Divison", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(modEClass, Mod.class, "Mod", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(typeDescriptorEClass, TypeDescriptor.class, "TypeDescriptor", IS_ABSTRACT, IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(termDescriptionEClass, TermDescription.class, "TermDescription", IS_ABSTRACT, IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(assertionEClass, Assertion.class, "Assertion", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getAssertion_Value(), this.getTerm(), null, "value", null, 1, 1, Assertion.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEAttribute(getAssertion_Name(), ecorePackage.getEString(), "name", null, 1, 1, Assertion.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getAssertion_Annotations(), theLogicproblemPackage.getAssertionAnnotation(), theLogicproblemPackage.getAssertionAnnotation_Target(), "annotations", null, 0, -1, Assertion.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(relationEClass, Relation.class, "Relation", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getRelation_Parameters(), this.getTypeReference(), null, "parameters", null, 0, -1, Relation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getRelation_Annotations(), theLogicproblemPackage.getRelationAnnotation(), theLogicproblemPackage.getRelationAnnotation_Target(), "annotations", null, 0, -1, Relation.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(constantEClass, Constant.class, "Constant", IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getConstant_Type(), this.getTypeReference(), null, "type", null, 1, 1, Constant.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getConstant_Annotations(), theLogicproblemPackage.getConstantAnnotation(), theLogicproblemPackage.getConstantAnnotation_Target(), "annotations", null, 0, -1, Constant.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(constantDefinitionEClass, ConstantDefinition.class, "ConstantDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getConstantDefinition_Value(), this.getTerm(), null, "value", null, 1, 1, ConstantDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getConstantDefinition_Defines(), this.getConstantDeclaration(), null, "defines", null, 0, 1, ConstantDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(relationDefinitionEClass, RelationDefinition.class, "RelationDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getRelationDefinition_Variables(), this.getVariable(), null, "variables", null, 0, -1, RelationDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getRelationDefinition_Value(), this.getTerm(), null, "value", null, 1, 1, RelationDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getRelationDefinition_Defines(), this.getRelationDeclaration(), null, "defines", null, 0, 1, RelationDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(functionDefinitionEClass, FunctionDefinition.class, "FunctionDefinition", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getFunctionDefinition_Variable(), this.getVariable(), null, "variable", null, 0, -1, FunctionDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getFunctionDefinition_Defines(), this.getFunctionDeclaration(), null, "defines", null, 0, 1, FunctionDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getFunctionDefinition_Value(), this.getTerm(), null, "value", null, 1, 1, FunctionDefinition.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(ifThenElseEClass, IfThenElse.class, "IfThenElse", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getIfThenElse_Condition(), this.getTerm(), null, "condition", null, 1, 1, IfThenElse.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getIfThenElse_IfTrue(), this.getTerm(), null, "ifTrue", null, 1, 1, IfThenElse.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getIfThenElse_IfFalse(), this.getTerm(), null, "ifFalse", null, 1, 1, IfThenElse.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + initEClass(constantDeclarationEClass, ConstantDeclaration.class, "ConstantDeclaration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(relationDeclarationEClass, RelationDeclaration.class, "RelationDeclaration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(functionDeclarationEClass, FunctionDeclaration.class, "FunctionDeclaration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(typeDeclarationEClass, TypeDeclaration.class, "TypeDeclaration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(unknownBecauseUninterpretedEClass, UnknownBecauseUninterpreted.class, "UnknownBecauseUninterpreted", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + + initEClass(instanceOfEClass, InstanceOf.class, "InstanceOf", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS); + initEReference(getInstanceOf_Value(), this.getTerm(), null, "value", null, 1, 1, InstanceOf.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + initEReference(getInstanceOf_Range(), this.getTypeReference(), null, "range", null, 1, 1, InstanceOf.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED); + + // Create resource + createResource(eNS_URI); + } + +} //LogiclanguagePackageImpl -- cgit v1.2.3-54-g00ecf