From 8a7b9b436b31e6d2f5a0521a077c960ebdeb4cbe Mon Sep 17 00:00:00 2001 From: Oszkar Semerath Date: Tue, 28 Apr 2020 20:43:04 +0200 Subject: initial commit --- .../AbstractSolverLanguageRuntimeModule.java | 201 + .../viatra/solver/language/SolverLanguage.xtextbin | Bin 0 -> 7297 bytes .../SolverLanguageStandaloneSetupGenerated.java | 42 + .../SolverLanguageAntlrTokenFileProvider.java | 16 + .../parser/antlr/SolverLanguageParser.java | 40 + .../parser/antlr/internal/InternalSolverLanguage.g | 2575 +++++++ .../antlr/internal/InternalSolverLanguage.tokens | 67 + .../internal/InternalSolverLanguageLexer.java | 1669 +++++ .../internal/InternalSolverLanguageParser.java | 7214 ++++++++++++++++++++ .../AbstractSolverLanguageScopeProvider.java | 9 + .../SolverLanguageSemanticSequencer.java | 781 +++ .../SolverLanguageSyntacticSequencer.java | 60 + .../services/SolverLanguageGrammarAccess.java | 2124 ++++++ .../language/solverLanguage/AllInstances.java | 47 + .../solver/language/solverLanguage/AllObjects.java | 19 + .../solverLanguage/BasicInterpretation.java | 84 + .../language/solverLanguage/BooleanFalse.java | 19 + .../language/solverLanguage/BooleanObject.java | 47 + .../language/solverLanguage/BooleanSymbol.java | 19 + .../language/solverLanguage/BooleanTrue.java | 19 + .../language/solverLanguage/BooleanValue.java | 20 + .../language/solverLanguage/CDInterpretation.java | 19 + .../solverLanguage/ClassInterpretation.java | 97 + .../language/solverLanguage/ClosureType.java | 20 + .../language/solverLanguage/ComplexObject.java | 20 + .../solver/language/solverLanguage/Constraint.java | 109 + .../solver/language/solverLanguage/DataObject.java | 19 + .../solver/language/solverLanguage/DataSymbol.java | 19 + .../solverLanguage/DefaultInterpretation.java | 47 + .../solverLanguage/EnumInterpretation.java | 61 + .../language/solverLanguage/EqualsSymbol.java | 19 + .../solver/language/solverLanguage/Error.java | 19 + .../language/solverLanguage/ErrorPredicate.java | 47 + .../language/solverLanguage/ExistSymbol.java | 19 + .../solver/language/solverLanguage/False.java | 19 + .../FieldRelationInterpretation.java | 117 + .../GlobalRelationInterpretation.java | 162 + .../solver/language/solverLanguage/IntObject.java | 47 + .../language/solverLanguage/IntegerSymbol.java | 19 + .../language/solverLanguage/Interpretation.java | 19 + .../solverLanguage/IrreflexiveClosure.java | 19 + .../solver/language/solverLanguage/Literal.java | 20 + .../language/solverLanguage/ModelSymbol.java | 47 + .../solverLanguage/MultiplicityDefinition.java | 94 + .../language/solverLanguage/NamedObject.java | 47 + .../solver/language/solverLanguage/Negative.java | 19 + .../solver/language/solverLanguage/Object.java | 19 + .../solver/language/solverLanguage/Parameter.java | 71 + .../language/solverLanguage/PartialitySymbol.java | 19 + .../language/solverLanguage/PatternBody.java | 40 + .../solver/language/solverLanguage/Polarity.java | 20 + .../solver/language/solverLanguage/Positive.java | 19 + .../solver/language/solverLanguage/Predicate.java | 51 + .../language/solverLanguage/PredicateSymbol.java | 47 + .../solver/language/solverLanguage/Problem.java | 40 + .../solver/language/solverLanguage/RealObject.java | 48 + .../solver/language/solverLanguage/RealSymbol.java | 19 + .../language/solverLanguage/ReflexiveClosure.java | 19 + .../solverLanguage/SolverLanguageFactory.java | 521 ++ .../solverLanguage/SolverLanguagePackage.java | 3460 ++++++++++ .../solver/language/solverLanguage/Statement.java | 20 + .../language/solverLanguage/StringObject.java | 47 + .../language/solverLanguage/StringSymbol.java | 19 + .../solver/language/solverLanguage/Symbol.java | 20 + .../solver/language/solverLanguage/True.java | 19 + .../solver/language/solverLanguage/TruthValue.java | 20 + .../solver/language/solverLanguage/Unknown.java | 19 + .../language/solverLanguage/UnnamedObject.java | 47 + .../solver/language/solverLanguage/Variable.java | 47 + .../solverLanguage/impl/AllInstancesImpl.java | 196 + .../solverLanguage/impl/AllObjectsImpl.java | 41 + .../impl/BasicInterpretationImpl.java | 318 + .../solverLanguage/impl/BooleanFalseImpl.java | 41 + .../solverLanguage/impl/BooleanObjectImpl.java | 196 + .../solverLanguage/impl/BooleanSymbolImpl.java | 41 + .../solverLanguage/impl/BooleanTrueImpl.java | 41 + .../solverLanguage/impl/BooleanValueImpl.java | 43 + .../solverLanguage/impl/CDInterpretationImpl.java | 41 + .../impl/ClassInterpretationImpl.java | 356 + .../solverLanguage/impl/ClosureTypeImpl.java | 43 + .../solverLanguage/impl/ComplexObjectImpl.java | 43 + .../solverLanguage/impl/ConstraintImpl.java | 393 ++ .../solverLanguage/impl/DataObjectImpl.java | 41 + .../solverLanguage/impl/DataSymbolImpl.java | 41 + .../impl/DefaultInterpretationImpl.java | 196 + .../impl/EnumInterpretationImpl.java | 244 + .../solverLanguage/impl/EqualsSymbolImpl.java | 41 + .../language/solverLanguage/impl/ErrorImpl.java | 40 + .../solverLanguage/impl/ErrorPredicateImpl.java | 179 + .../solverLanguage/impl/ExistSymbolImpl.java | 41 + .../language/solverLanguage/impl/FalseImpl.java | 41 + .../impl/FieldRelationInterpretationImpl.java | 418 ++ .../impl/GlobalRelationInterpretationImpl.java | 563 ++ .../solverLanguage/impl/IntObjectImpl.java | 179 + .../solverLanguage/impl/IntegerSymbolImpl.java | 41 + .../solverLanguage/impl/InterpretationImpl.java | 41 + .../impl/IrreflexiveClosureImpl.java | 41 + .../language/solverLanguage/impl/LiteralImpl.java | 43 + .../solverLanguage/impl/ModelSymbolImpl.java | 179 + .../impl/MultiplicityDefinitionImpl.java | 296 + .../solverLanguage/impl/NamedObjectImpl.java | 179 + .../language/solverLanguage/impl/NegativeImpl.java | 41 + .../language/solverLanguage/impl/ObjectImpl.java | 40 + .../solverLanguage/impl/ParameterImpl.java | 271 + .../solverLanguage/impl/PartialitySymbolImpl.java | 41 + .../solverLanguage/impl/PatternBodyImpl.java | 169 + .../language/solverLanguage/impl/PolarityImpl.java | 43 + .../language/solverLanguage/impl/PositiveImpl.java | 41 + .../solverLanguage/impl/PredicateImpl.java | 207 + .../solverLanguage/impl/PredicateSymbolImpl.java | 196 + .../language/solverLanguage/impl/ProblemImpl.java | 169 + .../solverLanguage/impl/RealObjectImpl.java | 181 + .../solverLanguage/impl/RealSymbolImpl.java | 41 + .../solverLanguage/impl/ReflexiveClosureImpl.java | 41 + .../impl/SolverLanguageFactoryImpl.java | 851 +++ .../impl/SolverLanguagePackageImpl.java | 2007 ++++++ .../solverLanguage/impl/StatementImpl.java | 43 + .../solverLanguage/impl/StringObjectImpl.java | 179 + .../solverLanguage/impl/StringSymbolImpl.java | 41 + .../language/solverLanguage/impl/SymbolImpl.java | 43 + .../language/solverLanguage/impl/TrueImpl.java | 41 + .../solverLanguage/impl/TruthValueImpl.java | 43 + .../language/solverLanguage/impl/UnknownImpl.java | 41 + .../solverLanguage/impl/UnnamedObjectImpl.java | 179 + .../language/solverLanguage/impl/VariableImpl.java | 179 + .../util/SolverLanguageAdapterFactory.java | 1245 ++++ .../solverLanguage/util/SolverLanguageSwitch.java | 1464 ++++ .../AbstractSolverLanguageValidator.java | 19 + ...lverLanguageConfigurableIssueCodesProvider.java | 22 + 129 files changed, 33382 insertions(+) create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllInstances.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllObjects.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BasicInterpretation.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanFalse.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanObject.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanSymbol.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanTrue.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanValue.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/CDInterpretation.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClassInterpretation.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClosureType.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ComplexObject.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Constraint.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataObject.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataSymbol.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultInterpretation.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EnumInterpretation.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EqualsSymbol.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Error.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ErrorPredicate.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExistSymbol.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/False.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/FieldRelationInterpretation.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/GlobalRelationInterpretation.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntObject.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntegerSymbol.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interpretation.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IrreflexiveClosure.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Literal.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ModelSymbol.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MultiplicityDefinition.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NamedObject.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Negative.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Object.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Parameter.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PartialitySymbol.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PatternBody.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Polarity.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Positive.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Predicate.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PredicateSymbol.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Problem.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealObject.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealSymbol.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ReflexiveClosure.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguageFactory.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguagePackage.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Statement.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringObject.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringSymbol.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Symbol.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/True.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TruthValue.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Unknown.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedObject.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Variable.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllInstancesImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllObjectsImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BasicInterpretationImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanFalseImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanObjectImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanSymbolImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanTrueImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanValueImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CDInterpretationImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassInterpretationImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClosureTypeImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComplexObjectImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConstraintImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataObjectImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataSymbolImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DefaultInterpretationImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EnumInterpretationImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EqualsSymbolImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorPredicateImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExistSymbolImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FalseImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FieldRelationInterpretationImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/GlobalRelationInterpretationImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntObjectImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntegerSymbolImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/InterpretationImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IrreflexiveClosureImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LiteralImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ModelSymbolImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MultiplicityDefinitionImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NamedObjectImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NegativeImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ParameterImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PartialitySymbolImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PatternBodyImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PolarityImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PositiveImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateSymbolImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ProblemImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealObjectImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealSymbolImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReflexiveClosureImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguagePackageImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StatementImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringObjectImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringSymbolImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SymbolImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TrueImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TruthValueImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnknownImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedObjectImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/VariableImpl.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java create mode 100644 Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java (limited to 'Application/org.eclipse.viatra.solver.language/src-gen/org') diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java new file mode 100644 index 00000000..cbf67ff9 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/AbstractSolverLanguageRuntimeModule.java @@ -0,0 +1,201 @@ +/* + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language; + +import com.google.inject.Binder; +import com.google.inject.Provider; +import com.google.inject.name.Names; +import java.util.Properties; +import org.eclipse.viatra.solver.language.generator.SolverLanguageGenerator; +import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageAntlrTokenFileProvider; +import org.eclipse.viatra.solver.language.parser.antlr.SolverLanguageParser; +import org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageLexer; +import org.eclipse.viatra.solver.language.scoping.SolverLanguageScopeProvider; +import org.eclipse.viatra.solver.language.serializer.SolverLanguageSemanticSequencer; +import org.eclipse.viatra.solver.language.serializer.SolverLanguageSyntacticSequencer; +import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; +import org.eclipse.viatra.solver.language.validation.SolverLanguageConfigurableIssueCodesProvider; +import org.eclipse.viatra.solver.language.validation.SolverLanguageValidator; +import org.eclipse.xtext.Constants; +import org.eclipse.xtext.IGrammarAccess; +import org.eclipse.xtext.generator.IGenerator2; +import org.eclipse.xtext.naming.DefaultDeclarativeQualifiedNameProvider; +import org.eclipse.xtext.naming.IQualifiedNameProvider; +import org.eclipse.xtext.parser.IParser; +import org.eclipse.xtext.parser.ITokenToStringConverter; +import org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider; +import org.eclipse.xtext.parser.antlr.AntlrTokenToStringConverter; +import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider; +import org.eclipse.xtext.parser.antlr.ITokenDefProvider; +import org.eclipse.xtext.parser.antlr.Lexer; +import org.eclipse.xtext.parser.antlr.LexerBindings; +import org.eclipse.xtext.parser.antlr.LexerProvider; +import org.eclipse.xtext.resource.IContainer; +import org.eclipse.xtext.resource.IResourceDescriptions; +import org.eclipse.xtext.resource.containers.IAllContainersState; +import org.eclipse.xtext.resource.containers.ResourceSetBasedAllContainersStateProvider; +import org.eclipse.xtext.resource.containers.StateBasedContainerManager; +import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider; +import org.eclipse.xtext.resource.impl.ResourceSetBasedResourceDescriptions; +import org.eclipse.xtext.scoping.IGlobalScopeProvider; +import org.eclipse.xtext.scoping.IScopeProvider; +import org.eclipse.xtext.scoping.IgnoreCaseLinking; +import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider; +import org.eclipse.xtext.scoping.impl.DefaultGlobalScopeProvider; +import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider; +import org.eclipse.xtext.serializer.ISerializer; +import org.eclipse.xtext.serializer.impl.Serializer; +import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer; +import org.eclipse.xtext.serializer.sequencer.ISyntacticSequencer; +import org.eclipse.xtext.service.DefaultRuntimeModule; +import org.eclipse.xtext.service.SingletonBinding; +import org.eclipse.xtext.validation.ConfigurableIssueCodesProvider; + +/** + * Manual modifications go to {@link SolverLanguageRuntimeModule}. + */ +@SuppressWarnings("all") +public abstract class AbstractSolverLanguageRuntimeModule extends DefaultRuntimeModule { + + protected Properties properties = null; + + @Override + public void configure(Binder binder) { + properties = tryBindProperties(binder, "org/eclipse/viatra/solver/language/SolverLanguage.properties"); + super.configure(binder); + } + + public void configureLanguageName(Binder binder) { + binder.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("org.eclipse.viatra.solver.language.SolverLanguage"); + } + + public void configureFileExtensions(Binder binder) { + if (properties == null || properties.getProperty(Constants.FILE_EXTENSIONS) == null) + binder.bind(String.class).annotatedWith(Names.named(Constants.FILE_EXTENSIONS)).toInstance("vsc"); + } + + // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2 + public ClassLoader bindClassLoaderToInstance() { + return getClass().getClassLoader(); + } + + // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2 + public Class bindIGrammarAccess() { + return SolverLanguageGrammarAccess.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISemanticSequencer() { + return SolverLanguageSemanticSequencer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISyntacticSequencer() { + return SolverLanguageSyntacticSequencer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISerializer() { + return Serializer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIParser() { + return SolverLanguageParser.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindITokenToStringConverter() { + return AntlrTokenToStringConverter.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIAntlrTokenFileProvider() { + return SolverLanguageAntlrTokenFileProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindLexer() { + return InternalSolverLanguageLexer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindITokenDefProvider() { + return AntlrTokenDefProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Provider provideInternalSolverLanguageLexer() { + return LexerProvider.create(InternalSolverLanguageLexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public void configureRuntimeLexer(Binder binder) { + binder.bind(Lexer.class) + .annotatedWith(Names.named(LexerBindings.RUNTIME)) + .to(InternalSolverLanguageLexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 + @SingletonBinding(eager=true) + public Class bindSolverLanguageValidator() { + return SolverLanguageValidator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 + public Class bindConfigurableIssueCodesProvider() { + return SolverLanguageConfigurableIssueCodesProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public Class bindIScopeProvider() { + return SolverLanguageScopeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public void configureIScopeProviderDelegate(Binder binder) { + binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(ImportedNamespaceAwareLocalScopeProvider.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public Class bindIGlobalScopeProvider() { + return DefaultGlobalScopeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public void configureIgnoreCaseLinking(Binder binder) { + binder.bindConstant().annotatedWith(IgnoreCaseLinking.class).to(false); + } + + // contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2 + public Class bindIQualifiedNameProvider() { + return DefaultDeclarativeQualifiedNameProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public Class bindIContainer$Manager() { + return StateBasedContainerManager.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public Class bindIAllContainersState$Provider() { + return ResourceSetBasedAllContainersStateProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public void configureIResourceDescriptions(Binder binder) { + binder.bind(IResourceDescriptions.class).to(ResourceSetBasedResourceDescriptions.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public void configureIResourceDescriptionsPersisted(Binder binder) { + binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(ResourceSetBasedResourceDescriptions.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 + public Class bindIGenerator2() { + return SolverLanguageGenerator.class; + } + +} diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin new file mode 100644 index 00000000..20f3e983 Binary files /dev/null and b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguage.xtextbin differ diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java new file mode 100644 index 00000000..91347850 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/SolverLanguageStandaloneSetupGenerated.java @@ -0,0 +1,42 @@ +/* + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language; + +import com.google.inject.Guice; +import com.google.inject.Injector; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.resource.Resource; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.xtext.ISetup; +import org.eclipse.xtext.common.TerminalsStandaloneSetup; +import org.eclipse.xtext.resource.IResourceFactory; +import org.eclipse.xtext.resource.IResourceServiceProvider; + +@SuppressWarnings("all") +public class SolverLanguageStandaloneSetupGenerated implements ISetup { + + @Override + public Injector createInjectorAndDoEMFRegistration() { + TerminalsStandaloneSetup.doSetup(); + + Injector injector = createInjector(); + register(injector); + return injector; + } + + public Injector createInjector() { + return Guice.createInjector(new SolverLanguageRuntimeModule()); + } + + public void register(Injector injector) { + if (!EPackage.Registry.INSTANCE.containsKey("http://www.eclipse.org/viatra/solver/language/SolverLanguage")) { + EPackage.Registry.INSTANCE.put("http://www.eclipse.org/viatra/solver/language/SolverLanguage", SolverLanguagePackage.eINSTANCE); + } + IResourceFactory resourceFactory = injector.getInstance(IResourceFactory.class); + IResourceServiceProvider serviceProvider = injector.getInstance(IResourceServiceProvider.class); + + Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("vsc", resourceFactory); + IResourceServiceProvider.Registry.INSTANCE.getExtensionToFactoryMap().put("vsc", serviceProvider); + } +} diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java new file mode 100644 index 00000000..059473c8 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageAntlrTokenFileProvider.java @@ -0,0 +1,16 @@ +/* + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.parser.antlr; + +import java.io.InputStream; +import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider; + +public class SolverLanguageAntlrTokenFileProvider implements IAntlrTokenFileProvider { + + @Override + public InputStream getAntlrTokenFile() { + ClassLoader classLoader = getClass().getClassLoader(); + return classLoader.getResourceAsStream("org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens"); + } +} diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java new file mode 100644 index 00000000..7155770e --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/SolverLanguageParser.java @@ -0,0 +1,40 @@ +/* + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.parser.antlr; + +import com.google.inject.Inject; +import org.eclipse.viatra.solver.language.parser.antlr.internal.InternalSolverLanguageParser; +import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; +import org.eclipse.xtext.parser.antlr.AbstractAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; + +public class SolverLanguageParser extends AbstractAntlrParser { + + @Inject + private SolverLanguageGrammarAccess grammarAccess; + + @Override + protected void setInitialHiddenTokens(XtextTokenStream tokenStream) { + tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT"); + } + + + @Override + protected InternalSolverLanguageParser createParser(XtextTokenStream stream) { + return new InternalSolverLanguageParser(stream, getGrammarAccess()); + } + + @Override + protected String getDefaultRuleName() { + return "Problem"; + } + + public SolverLanguageGrammarAccess getGrammarAccess() { + return this.grammarAccess; + } + + public void setGrammarAccess(SolverLanguageGrammarAccess grammarAccess) { + this.grammarAccess = grammarAccess; + } +} diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g new file mode 100644 index 00000000..afd73c2d --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.g @@ -0,0 +1,2575 @@ +/* + * generated by Xtext 2.18.0.M3 + */ +grammar InternalSolverLanguage; + +options { + superClass=AbstractInternalAntlrParser; +} + +@lexer::header { +package org.eclipse.viatra.solver.language.parser.antlr.internal; + +// Hack: Use our own Lexer superclass by means of import. +// Currently there is no other way to specify the superclass for the lexer. +import org.eclipse.xtext.parser.antlr.Lexer; +} + +@parser::header { +package org.eclipse.viatra.solver.language.parser.antlr.internal; + +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; +import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; + +} + +@parser::members { + + private SolverLanguageGrammarAccess grammarAccess; + + public InternalSolverLanguageParser(TokenStream input, SolverLanguageGrammarAccess grammarAccess) { + this(input); + this.grammarAccess = grammarAccess; + registerRules(grammarAccess.getGrammar()); + } + + @Override + protected String getFirstRuleName() { + return "Problem"; + } + + @Override + protected SolverLanguageGrammarAccess getGrammarAccess() { + return grammarAccess; + } + +} + +@rulecatch { + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } +} + +// Entry rule entryRuleProblem +entryRuleProblem returns [EObject current=null]: + { newCompositeNode(grammarAccess.getProblemRule()); } + iv_ruleProblem=ruleProblem + { $current=$iv_ruleProblem.current; } + EOF; + +// Rule Problem +ruleProblem returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); + } + lv_statements_0_0=ruleStatement + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getProblemRule()); + } + add( + $current, + "statements", + lv_statements_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); + afterParserOrEnumRuleCall(); + } + ) + )* +; + +// Entry rule entryRuleStatement +entryRuleStatement returns [EObject current=null]: + { newCompositeNode(grammarAccess.getStatementRule()); } + iv_ruleStatement=ruleStatement + { $current=$iv_ruleStatement.current; } + EOF; + +// Rule Statement +ruleStatement returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0()); + } + this_Interpretation_0=ruleInterpretation + { + $current = $this_Interpretation_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1()); + } + this_Predicate_1=rulePredicate + { + $current = $this_Predicate_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleREALLiteral +entryRuleREALLiteral returns [String current=null]: + { newCompositeNode(grammarAccess.getREALLiteralRule()); } + iv_ruleREALLiteral=ruleREALLiteral + { $current=$iv_ruleREALLiteral.current.getText(); } + EOF; + +// Rule REALLiteral +ruleREALLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + kw='-' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); + } + )? + this_INT_1=RULE_INT + { + $current.merge(this_INT_1); + } + { + newLeafNode(this_INT_1, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); + } + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); + } + this_INT_3=RULE_INT + { + $current.merge(this_INT_3); + } + { + newLeafNode(this_INT_3, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); + } + ) +; + +// Entry rule entryRuleINTLiteral +entryRuleINTLiteral returns [String current=null]: + { newCompositeNode(grammarAccess.getINTLiteralRule()); } + iv_ruleINTLiteral=ruleINTLiteral + { $current=$iv_ruleINTLiteral.current.getText(); } + EOF; + +// Rule INTLiteral +ruleINTLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + kw='-' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); + } + )? + this_INT_1=RULE_INT + { + $current.merge(this_INT_1); + } + { + newLeafNode(this_INT_1, grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); + } + ) +; + +// Entry rule entryRuleBooleanValue +entryRuleBooleanValue returns [EObject current=null]: + { newCompositeNode(grammarAccess.getBooleanValueRule()); } + iv_ruleBooleanValue=ruleBooleanValue + { $current=$iv_ruleBooleanValue.current; } + EOF; + +// Rule BooleanValue +ruleBooleanValue returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0(), + $current); + } + ) + otherlv_1='true' + { + newLeafNode(otherlv_1, grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1()); + } + ) + | + ( + otherlv_2='false' + { + newLeafNode(otherlv_2, grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0()); + } + ( + { + $current = forceCreateModelElement( + grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1(), + $current); + } + ) + ) + ) +; + +// Entry rule entryRuleTruthValue +entryRuleTruthValue returns [EObject current=null]: + { newCompositeNode(grammarAccess.getTruthValueRule()); } + iv_ruleTruthValue=ruleTruthValue + { $current=$iv_ruleTruthValue.current; } + EOF; + +// Rule TruthValue +ruleTruthValue returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getTruthValueAccess().getTrueAction_0_0(), + $current); + } + ) + otherlv_1='true' + { + newLeafNode(otherlv_1, grammarAccess.getTruthValueAccess().getTrueKeyword_0_1()); + } + ) + | + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getTruthValueAccess().getFalseAction_1_0(), + $current); + } + ) + otherlv_3='false' + { + newLeafNode(otherlv_3, grammarAccess.getTruthValueAccess().getFalseKeyword_1_1()); + } + ) + | + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getTruthValueAccess().getUnknownAction_2_0(), + $current); + } + ) + otherlv_5='unknown' + { + newLeafNode(otherlv_5, grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1()); + } + ) + | + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getTruthValueAccess().getErrorAction_3_0(), + $current); + } + ) + otherlv_7='error' + { + newLeafNode(otherlv_7, grammarAccess.getTruthValueAccess().getErrorKeyword_3_1()); + } + ) + ) +; + +// Entry rule entryRuleInterpretation +entryRuleInterpretation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getInterpretationRule()); } + iv_ruleInterpretation=ruleInterpretation + { $current=$iv_ruleInterpretation.current; } + EOF; + +// Rule Interpretation +ruleInterpretation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0()); + } + this_BasicInterpretation_0=ruleBasicInterpretation + { + $current = $this_BasicInterpretation_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1()); + } + this_DefaultInterpretation_1=ruleDefaultInterpretation + { + $current = $this_DefaultInterpretation_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2()); + } + this_CDInterpretation_2=ruleCDInterpretation + { + $current = $this_CDInterpretation_2.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleBasicInterpretation +entryRuleBasicInterpretation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getBasicInterpretationRule()); } + iv_ruleBasicInterpretation=ruleBasicInterpretation + { $current=$iv_ruleBasicInterpretation.current; } + EOF; + +// Rule BasicInterpretation +ruleBasicInterpretation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0()); + } + lv_symbol_0_0=ruleSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); + } + set( + $current, + "symbol", + lv_symbol_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_1='(' + { + newLeafNode(otherlv_1, grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_2_0()); + } + lv_objects_2_0=ruleComplexObject + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); + } + add( + $current, + "objects", + lv_objects_2_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); + afterParserOrEnumRuleCall(); + } + ) + )* + otherlv_3=')' + { + newLeafNode(otherlv_3, grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_3()); + } + otherlv_4=':' + { + newLeafNode(otherlv_4, grammarAccess.getBasicInterpretationAccess().getColonKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_5_0()); + } + lv_value_5_0=ruleTruthValue + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); + } + set( + $current, + "value", + lv_value_5_0, + "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleSymbol +entryRuleSymbol returns [EObject current=null]: + { newCompositeNode(grammarAccess.getSymbolRule()); } + iv_ruleSymbol=ruleSymbol + { $current=$iv_ruleSymbol.current; } + EOF; + +// Rule Symbol +ruleSymbol returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0()); + } + this_ModelSymbol_0=ruleModelSymbol + { + $current = $this_ModelSymbol_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1()); + } + this_PartialitySymbol_1=rulePartialitySymbol + { + $current = $this_PartialitySymbol_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2()); + } + this_DataSymbol_2=ruleDataSymbol + { + $current = $this_DataSymbol_2.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleModelSymbol +entryRuleModelSymbol returns [EObject current=null]: + { newCompositeNode(grammarAccess.getModelSymbolRule()); } + iv_ruleModelSymbol=ruleModelSymbol + { $current=$iv_ruleModelSymbol.current; } + EOF; + +// Rule ModelSymbol +ruleModelSymbol returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + lv_name_0_0=RULE_ID + { + newLeafNode(lv_name_0_0, grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getModelSymbolRule()); + } + setWithLastConsumed( + $current, + "name", + lv_name_0_0, + "org.eclipse.xtext.common.Terminals.ID"); + } + ) + ) +; + +// Entry rule entryRulePartialitySymbol +entryRulePartialitySymbol returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPartialitySymbolRule()); } + iv_rulePartialitySymbol=rulePartialitySymbol + { $current=$iv_rulePartialitySymbol.current; } + EOF; + +// Rule PartialitySymbol +rulePartialitySymbol returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0()); + } + this_ExistSymbol_0=ruleExistSymbol + { + $current = $this_ExistSymbol_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1()); + } + this_EqualsSymbol_1=ruleEqualsSymbol + { + $current = $this_EqualsSymbol_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleExistSymbol +entryRuleExistSymbol returns [EObject current=null]: + { newCompositeNode(grammarAccess.getExistSymbolRule()); } + iv_ruleExistSymbol=ruleExistSymbol + { $current=$iv_ruleExistSymbol.current; } + EOF; + +// Rule ExistSymbol +ruleExistSymbol returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='exists' + { + newLeafNode(otherlv_0, grammarAccess.getExistSymbolAccess().getExistsKeyword_0()); + } + ( + { + $current = forceCreateModelElement( + grammarAccess.getExistSymbolAccess().getExistSymbolAction_1(), + $current); + } + ) + ) +; + +// Entry rule entryRuleEqualsSymbol +entryRuleEqualsSymbol returns [EObject current=null]: + { newCompositeNode(grammarAccess.getEqualsSymbolRule()); } + iv_ruleEqualsSymbol=ruleEqualsSymbol + { $current=$iv_ruleEqualsSymbol.current; } + EOF; + +// Rule EqualsSymbol +ruleEqualsSymbol returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='equals' + { + newLeafNode(otherlv_0, grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0()); + } + ( + { + $current = forceCreateModelElement( + grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1(), + $current); + } + ) + ) +; + +// Entry rule entryRuleDataSymbol +entryRuleDataSymbol returns [EObject current=null]: + { newCompositeNode(grammarAccess.getDataSymbolRule()); } + iv_ruleDataSymbol=ruleDataSymbol + { $current=$iv_ruleDataSymbol.current; } + EOF; + +// Rule DataSymbol +ruleDataSymbol returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0()); + } + this_BooleanSymbol_0=ruleBooleanSymbol + { + $current = $this_BooleanSymbol_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1()); + } + this_IntegerSymbol_1=ruleIntegerSymbol + { + $current = $this_IntegerSymbol_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2()); + } + this_RealSymbol_2=ruleRealSymbol + { + $current = $this_RealSymbol_2.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3()); + } + this_StringSymbol_3=ruleStringSymbol + { + $current = $this_StringSymbol_3.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleBooleanSymbol +entryRuleBooleanSymbol returns [EObject current=null]: + { newCompositeNode(grammarAccess.getBooleanSymbolRule()); } + iv_ruleBooleanSymbol=ruleBooleanSymbol + { $current=$iv_ruleBooleanSymbol.current; } + EOF; + +// Rule BooleanSymbol +ruleBooleanSymbol returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='bool' + { + newLeafNode(otherlv_0, grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0()); + } + ( + { + $current = forceCreateModelElement( + grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1(), + $current); + } + ) + ) +; + +// Entry rule entryRuleIntegerSymbol +entryRuleIntegerSymbol returns [EObject current=null]: + { newCompositeNode(grammarAccess.getIntegerSymbolRule()); } + iv_ruleIntegerSymbol=ruleIntegerSymbol + { $current=$iv_ruleIntegerSymbol.current; } + EOF; + +// Rule IntegerSymbol +ruleIntegerSymbol returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='int' + { + newLeafNode(otherlv_0, grammarAccess.getIntegerSymbolAccess().getIntKeyword_0()); + } + ( + { + $current = forceCreateModelElement( + grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1(), + $current); + } + ) + ) +; + +// Entry rule entryRuleRealSymbol +entryRuleRealSymbol returns [EObject current=null]: + { newCompositeNode(grammarAccess.getRealSymbolRule()); } + iv_ruleRealSymbol=ruleRealSymbol + { $current=$iv_ruleRealSymbol.current; } + EOF; + +// Rule RealSymbol +ruleRealSymbol returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='real' + { + newLeafNode(otherlv_0, grammarAccess.getRealSymbolAccess().getRealKeyword_0()); + } + ( + { + $current = forceCreateModelElement( + grammarAccess.getRealSymbolAccess().getRealSymbolAction_1(), + $current); + } + ) + ) +; + +// Entry rule entryRuleStringSymbol +entryRuleStringSymbol returns [EObject current=null]: + { newCompositeNode(grammarAccess.getStringSymbolRule()); } + iv_ruleStringSymbol=ruleStringSymbol + { $current=$iv_ruleStringSymbol.current; } + EOF; + +// Rule StringSymbol +ruleStringSymbol returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='string' + { + newLeafNode(otherlv_0, grammarAccess.getStringSymbolAccess().getStringKeyword_0()); + } + ( + { + $current = forceCreateModelElement( + grammarAccess.getStringSymbolAccess().getStringSymbolAction_1(), + $current); + } + ) + ) +; + +// Entry rule entryRuleComplexObject +entryRuleComplexObject returns [EObject current=null]: + { newCompositeNode(grammarAccess.getComplexObjectRule()); } + iv_ruleComplexObject=ruleComplexObject + { $current=$iv_ruleComplexObject.current; } + EOF; + +// Rule ComplexObject +ruleComplexObject returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0()); + } + this_Object_0=ruleObject + { + $current = $this_Object_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1()); + } + this_AllInstances_1=ruleAllInstances + { + $current = $this_AllInstances_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2()); + } + this_AllObjects_2=ruleAllObjects + { + $current = $this_AllObjects_2.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleObject +entryRuleObject returns [EObject current=null]: + { newCompositeNode(grammarAccess.getObjectRule()); } + iv_ruleObject=ruleObject + { $current=$iv_ruleObject.current; } + EOF; + +// Rule Object +ruleObject returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0()); + } + this_NamedObject_0=ruleNamedObject + { + $current = $this_NamedObject_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1()); + } + this_UnnamedObject_1=ruleUnnamedObject + { + $current = $this_UnnamedObject_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2()); + } + this_DataObject_2=ruleDataObject + { + $current = $this_DataObject_2.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleNamedObject +entryRuleNamedObject returns [EObject current=null]: + { newCompositeNode(grammarAccess.getNamedObjectRule()); } + iv_ruleNamedObject=ruleNamedObject + { $current=$iv_ruleNamedObject.current; } + EOF; + +// Rule NamedObject +ruleNamedObject returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='\'' + { + newLeafNode(otherlv_0, grammarAccess.getNamedObjectAccess().getApostropheKeyword_0()); + } + ( + ( + lv_name_1_0=RULE_ID + { + newLeafNode(lv_name_1_0, grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getNamedObjectRule()); + } + setWithLastConsumed( + $current, + "name", + lv_name_1_0, + "org.eclipse.xtext.common.Terminals.ID"); + } + ) + ) + otherlv_2='\'' + { + newLeafNode(otherlv_2, grammarAccess.getNamedObjectAccess().getApostropheKeyword_2()); + } + ) +; + +// Entry rule entryRuleUnnamedObject +entryRuleUnnamedObject returns [EObject current=null]: + { newCompositeNode(grammarAccess.getUnnamedObjectRule()); } + iv_ruleUnnamedObject=ruleUnnamedObject + { $current=$iv_ruleUnnamedObject.current; } + EOF; + +// Rule UnnamedObject +ruleUnnamedObject returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + lv_name_0_0=RULE_ID + { + newLeafNode(lv_name_0_0, grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getUnnamedObjectRule()); + } + setWithLastConsumed( + $current, + "name", + lv_name_0_0, + "org.eclipse.xtext.common.Terminals.ID"); + } + ) + ) +; + +// Entry rule entryRuleDataObject +entryRuleDataObject returns [EObject current=null]: + { newCompositeNode(grammarAccess.getDataObjectRule()); } + iv_ruleDataObject=ruleDataObject + { $current=$iv_ruleDataObject.current; } + EOF; + +// Rule DataObject +ruleDataObject returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0()); + } + this_BooleanObject_0=ruleBooleanObject + { + $current = $this_BooleanObject_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1()); + } + this_IntObject_1=ruleIntObject + { + $current = $this_IntObject_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2()); + } + this_RealObject_2=ruleRealObject + { + $current = $this_RealObject_2.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3()); + } + this_StringObject_3=ruleStringObject + { + $current = $this_StringObject_3.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleBooleanObject +entryRuleBooleanObject returns [EObject current=null]: + { newCompositeNode(grammarAccess.getBooleanObjectRule()); } + iv_ruleBooleanObject=ruleBooleanObject + { $current=$iv_ruleBooleanObject.current; } + EOF; + +// Rule BooleanObject +ruleBooleanObject returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0()); + } + lv_value_0_0=ruleBooleanValue + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getBooleanObjectRule()); + } + set( + $current, + "value", + lv_value_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleIntObject +entryRuleIntObject returns [EObject current=null]: + { newCompositeNode(grammarAccess.getIntObjectRule()); } + iv_ruleIntObject=ruleIntObject + { $current=$iv_ruleIntObject.current; } + EOF; + +// Rule IntObject +ruleIntObject returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0()); + } + lv_value_0_0=ruleINTLiteral + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getIntObjectRule()); + } + set( + $current, + "value", + lv_value_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleRealObject +entryRuleRealObject returns [EObject current=null]: + { newCompositeNode(grammarAccess.getRealObjectRule()); } + iv_ruleRealObject=ruleRealObject + { $current=$iv_ruleRealObject.current; } + EOF; + +// Rule RealObject +ruleRealObject returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0()); + } + lv_value_0_0=ruleREALLiteral + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getRealObjectRule()); + } + set( + $current, + "value", + lv_value_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral"); + afterParserOrEnumRuleCall(); + } + ) + ) +; + +// Entry rule entryRuleStringObject +entryRuleStringObject returns [EObject current=null]: + { newCompositeNode(grammarAccess.getStringObjectRule()); } + iv_ruleStringObject=ruleStringObject + { $current=$iv_ruleStringObject.current; } + EOF; + +// Rule StringObject +ruleStringObject returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + lv_value_0_0=RULE_STRING + { + newLeafNode(lv_value_0_0, grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getStringObjectRule()); + } + setWithLastConsumed( + $current, + "value", + lv_value_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); + } + ) + ) +; + +// Entry rule entryRulePredicate +entryRulePredicate returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPredicateRule()); } + iv_rulePredicate=rulePredicate + { $current=$iv_rulePredicate.current; } + EOF; + +// Rule Predicate +rulePredicate returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getPredicateAccess().getPredicateSymbolParserRuleCall_0()); + } + this_PredicateSymbol_0=rulePredicateSymbol + { + $current = $this_PredicateSymbol_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getPredicateAccess().getErrorPredicateParserRuleCall_1()); + } + this_ErrorPredicate_1=ruleErrorPredicate + { + $current = $this_ErrorPredicate_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRulePredicateSymbol +entryRulePredicateSymbol returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPredicateSymbolRule()); } + iv_rulePredicateSymbol=rulePredicateSymbol + { $current=$iv_rulePredicateSymbol.current; } + EOF; + +// Rule PredicateSymbol +rulePredicateSymbol returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='predicate' + { + newLeafNode(otherlv_0, grammarAccess.getPredicateSymbolAccess().getPredicateKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPredicateSymbolAccess().getSymbolModelSymbolParserRuleCall_1_0()); + } + lv_symbol_1_0=ruleModelSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPredicateSymbolRule()); + } + set( + $current, + "symbol", + lv_symbol_1_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getPredicateSymbolAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPredicateSymbolAccess().getParametersParameterParserRuleCall_3_0()); + } + lv_parameters_3_0=ruleParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPredicateSymbolRule()); + } + add( + $current, + "parameters", + lv_parameters_3_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); + afterParserOrEnumRuleCall(); + } + ) + )* + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getPredicateSymbolAccess().getRightParenthesisKeyword_4()); + } + otherlv_5=':' + { + newLeafNode(otherlv_5, grammarAccess.getPredicateSymbolAccess().getColonKeyword_5()); + } + ( + otherlv_6='false' + { + newLeafNode(otherlv_6, grammarAccess.getPredicateSymbolAccess().getFalseKeyword_6_0()); + } + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_0_0()); + } + lv_bodies_7_0=rulePatternBody + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPredicateSymbolRule()); + } + add( + $current, + "bodies", + lv_bodies_7_0, + "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_8='|' + { + newLeafNode(otherlv_8, grammarAccess.getPredicateSymbolAccess().getVerticalLineKeyword_6_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_1_1_0()); + } + lv_bodies_9_0=rulePatternBody + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPredicateSymbolRule()); + } + add( + $current, + "bodies", + lv_bodies_9_0, + "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) + ) + otherlv_10='.' + { + newLeafNode(otherlv_10, grammarAccess.getPredicateSymbolAccess().getFullStopKeyword_7()); + } + ) +; + +// Entry rule entryRuleErrorPredicate +entryRuleErrorPredicate returns [EObject current=null]: + { newCompositeNode(grammarAccess.getErrorPredicateRule()); } + iv_ruleErrorPredicate=ruleErrorPredicate + { $current=$iv_ruleErrorPredicate.current; } + EOF; + +// Rule ErrorPredicate +ruleErrorPredicate returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getErrorPredicateAccess().getErrorPredicateAction_0(), + $current); + } + ) + otherlv_1='error' + { + newLeafNode(otherlv_1, grammarAccess.getErrorPredicateAccess().getErrorKeyword_1()); + } + ( + ( + lv_name_2_0=RULE_ID + { + newLeafNode(lv_name_2_0, grammarAccess.getErrorPredicateAccess().getNameIDTerminalRuleCall_2_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getErrorPredicateRule()); + } + setWithLastConsumed( + $current, + "name", + lv_name_2_0, + "org.eclipse.xtext.common.Terminals.ID"); + } + ) + )? + ( + otherlv_3='(' + { + newLeafNode(otherlv_3, grammarAccess.getErrorPredicateAccess().getLeftParenthesisKeyword_3_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getErrorPredicateAccess().getParametersParameterParserRuleCall_3_1_0()); + } + lv_parameters_4_0=ruleParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getErrorPredicateRule()); + } + add( + $current, + "parameters", + lv_parameters_4_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); + afterParserOrEnumRuleCall(); + } + ) + )* + otherlv_5=')' + { + newLeafNode(otherlv_5, grammarAccess.getErrorPredicateAccess().getRightParenthesisKeyword_3_2()); + } + ) + otherlv_6=':' + { + newLeafNode(otherlv_6, grammarAccess.getErrorPredicateAccess().getColonKeyword_4()); + } + ( + otherlv_7='false' + { + newLeafNode(otherlv_7, grammarAccess.getErrorPredicateAccess().getFalseKeyword_5_0()); + } + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_0_0()); + } + lv_bodies_8_0=rulePatternBody + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getErrorPredicateRule()); + } + add( + $current, + "bodies", + lv_bodies_8_0, + "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_9='|' + { + newLeafNode(otherlv_9, grammarAccess.getErrorPredicateAccess().getVerticalLineKeyword_5_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_1_1_0()); + } + lv_bodies_10_0=rulePatternBody + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getErrorPredicateRule()); + } + add( + $current, + "bodies", + lv_bodies_10_0, + "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) + ) + otherlv_11='.' + { + newLeafNode(otherlv_11, grammarAccess.getErrorPredicateAccess().getFullStopKeyword_6()); + } + ) +; + +// Entry rule entryRuleParameter +entryRuleParameter returns [EObject current=null]: + { newCompositeNode(grammarAccess.getParameterRule()); } + iv_ruleParameter=ruleParameter + { $current=$iv_ruleParameter.current; } + EOF; + +// Rule Parameter +ruleParameter returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0()); + } + lv_variable_0_0=ruleVariable + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + $current, + "variable", + lv_variable_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Variable"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_1=':' + { + newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getColonKeyword_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0()); + } + lv_type_2_0=ruleSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + $current, + "type", + lv_type_2_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRulePatternBody +entryRulePatternBody returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPatternBodyRule()); } + iv_rulePatternBody=rulePatternBody + { $current=$iv_rulePatternBody.current; } + EOF; + +// Rule PatternBody +rulePatternBody returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getPatternBodyAccess().getPatternBodyAction_0(), + $current); + } + ) + ( + otherlv_1='true' + { + newLeafNode(otherlv_1, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); + } + | + ( + ( + { + newCompositeNode(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0()); + } + lv_constraints_2_0=ruleConstraint + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getPatternBodyRule()); + } + add( + $current, + "constraints", + lv_constraints_2_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Constraint"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) + ) +; + +// Entry rule entryRulePolarity +entryRulePolarity returns [EObject current=null]: + { newCompositeNode(grammarAccess.getPolarityRule()); } + iv_rulePolarity=rulePolarity + { $current=$iv_rulePolarity.current; } + EOF; + +// Rule Polarity +rulePolarity returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getPolarityAccess().getPositiveAction_0_0(), + $current); + } + ) + otherlv_1='+' + { + newLeafNode(otherlv_1, grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1()); + } + ) + | + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getPolarityAccess().getNegativeAction_1_0(), + $current); + } + ) + otherlv_3='-' + { + newLeafNode(otherlv_3, grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1()); + } + ) + ) +; + +// Entry rule entryRuleConstraint +entryRuleConstraint returns [EObject current=null]: + { newCompositeNode(grammarAccess.getConstraintRule()); } + iv_ruleConstraint=ruleConstraint + { $current=$iv_ruleConstraint.current; } + EOF; + +// Rule Constraint +ruleConstraint returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0()); + } + lv_polarity_0_0=rulePolarity + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getConstraintRule()); + } + set( + $current, + "polarity", + lv_polarity_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Polarity"); + afterParserOrEnumRuleCall(); + } + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_1_0()); + } + lv_symbol_1_0=ruleModelSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getConstraintRule()); + } + set( + $current, + "symbol", + lv_symbol_1_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_0_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_0_1_0()); + } + lv_params_3_0=ruleLiteral + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getConstraintRule()); + } + add( + $current, + "params", + lv_params_3_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); + afterParserOrEnumRuleCall(); + } + ) + )* + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_0_2()); + } + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_2_1_0_0()); + } + lv_closureType_5_0=ruleClosureType + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getConstraintRule()); + } + set( + $current, + "closureType", + lv_closureType_5_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_6='(' + { + newLeafNode(otherlv_6, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_1_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_2_0()); + } + lv_params_7_0=ruleLiteral + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getConstraintRule()); + } + add( + $current, + "params", + lv_params_7_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_3_0()); + } + lv_params_8_0=ruleLiteral + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getConstraintRule()); + } + add( + $current, + "params", + lv_params_8_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_9=')' + { + newLeafNode(otherlv_9, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_1_4()); + } + ) + ) + ) +; + +// Entry rule entryRuleClosureType +entryRuleClosureType returns [EObject current=null]: + { newCompositeNode(grammarAccess.getClosureTypeRule()); } + iv_ruleClosureType=ruleClosureType + { $current=$iv_ruleClosureType.current; } + EOF; + +// Rule ClosureType +ruleClosureType returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0(), + $current); + } + ) + otherlv_1='*' + { + newLeafNode(otherlv_1, grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1()); + } + ) + | + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0(), + $current); + } + ) + otherlv_3='+' + { + newLeafNode(otherlv_3, grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1()); + } + ) + ) +; + +// Entry rule entryRuleLiteral +entryRuleLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getLiteralRule()); } + iv_ruleLiteral=ruleLiteral + { $current=$iv_ruleLiteral.current; } + EOF; + +// Rule Literal +ruleLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0()); + } + this_Variable_0=ruleVariable + { + $current = $this_Variable_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1()); + } + this_DataObject_1=ruleDataObject + { + $current = $this_DataObject_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleVariable +entryRuleVariable returns [EObject current=null]: + { newCompositeNode(grammarAccess.getVariableRule()); } + iv_ruleVariable=ruleVariable + { $current=$iv_ruleVariable.current; } + EOF; + +// Rule Variable +ruleVariable returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + lv_name_0_0=RULE_ID + { + newLeafNode(lv_name_0_0, grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getVariableRule()); + } + setWithLastConsumed( + $current, + "name", + lv_name_0_0, + "org.eclipse.xtext.common.Terminals.ID"); + } + ) + ) +; + +// Entry rule entryRuleAllInstances +entryRuleAllInstances returns [EObject current=null]: + { newCompositeNode(grammarAccess.getAllInstancesRule()); } + iv_ruleAllInstances=ruleAllInstances + { $current=$iv_ruleAllInstances.current; } + EOF; + +// Rule AllInstances +ruleAllInstances returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0=':' + { + newLeafNode(otherlv_0, grammarAccess.getAllInstancesAccess().getColonKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0()); + } + lv_symbol_1_0=ruleSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getAllInstancesRule()); + } + set( + $current, + "symbol", + lv_symbol_1_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleAllObjects +entryRuleAllObjects returns [EObject current=null]: + { newCompositeNode(grammarAccess.getAllObjectsRule()); } + iv_ruleAllObjects=ruleAllObjects + { $current=$iv_ruleAllObjects.current; } + EOF; + +// Rule AllObjects +ruleAllObjects returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getAllObjectsAccess().getAllObjectsAction_0(), + $current); + } + ) + otherlv_1='*' + { + newLeafNode(otherlv_1, grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1()); + } + ) +; + +// Entry rule entryRuleDefaultInterpretation +entryRuleDefaultInterpretation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getDefaultInterpretationRule()); } + iv_ruleDefaultInterpretation=ruleDefaultInterpretation + { $current=$iv_ruleDefaultInterpretation.current; } + EOF; + +// Rule DefaultInterpretation +ruleDefaultInterpretation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='default' + { + newLeafNode(otherlv_0, grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0()); + } + lv_interpretation_1_0=ruleBasicInterpretation + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getDefaultInterpretationRule()); + } + set( + $current, + "interpretation", + lv_interpretation_1_0, + "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleCDInterpretation +entryRuleCDInterpretation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getCDInterpretationRule()); } + iv_ruleCDInterpretation=ruleCDInterpretation + { $current=$iv_ruleCDInterpretation.current; } + EOF; + +// Rule CDInterpretation +ruleCDInterpretation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0()); + } + this_ClassInterpretation_0=ruleClassInterpretation + { + $current = $this_ClassInterpretation_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1()); + } + this_EnumInterpretation_1=ruleEnumInterpretation + { + $current = $this_EnumInterpretation_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2()); + } + this_GlobalRelationInterpretation_2=ruleGlobalRelationInterpretation + { + $current = $this_GlobalRelationInterpretation_2.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleClassInterpretation +entryRuleClassInterpretation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getClassInterpretationRule()); } + iv_ruleClassInterpretation=ruleClassInterpretation + { $current=$iv_ruleClassInterpretation.current; } + EOF; + +// Rule ClassInterpretation +ruleClassInterpretation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + lv_abstract_0_0='abstract' + { + newLeafNode(lv_abstract_0_0, grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getClassInterpretationRule()); + } + setWithLastConsumed($current, "abstract", true, "abstract"); + } + ) + ) + otherlv_1='class' + { + newLeafNode(otherlv_1, grammarAccess.getClassInterpretationAccess().getClassKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); + } + lv_symbol_2_0=ruleModelSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); + } + set( + $current, + "symbol", + lv_symbol_2_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3='extends' + { + newLeafNode(otherlv_3, grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0()); + } + lv_supertypes_4_0=ruleModelSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); + } + add( + $current, + "supertypes", + lv_supertypes_4_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + } + ) + )+ + )? + otherlv_5='{' + { + newLeafNode(otherlv_5, grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0()); + } + lv_fielt_6_0=ruleFieldRelationInterpretation + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); + } + add( + $current, + "fielt", + lv_fielt_6_0, + "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation"); + afterParserOrEnumRuleCall(); + } + ) + )* + otherlv_7='}' + { + newLeafNode(otherlv_7, grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6()); + } + ) +; + +// Entry rule entryRuleEnumInterpretation +entryRuleEnumInterpretation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getEnumInterpretationRule()); } + iv_ruleEnumInterpretation=ruleEnumInterpretation + { $current=$iv_ruleEnumInterpretation.current; } + EOF; + +// Rule EnumInterpretation +ruleEnumInterpretation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='enum' + { + newLeafNode(otherlv_0, grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); + } + lv_Symbol_1_0=ruleModelSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); + } + set( + $current, + "Symbol", + lv_Symbol_1_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2='{' + { + newLeafNode(otherlv_2, grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0()); + } + lv_objects_3_0=ruleNamedObject + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); + } + add( + $current, + "objects", + lv_objects_3_0, + "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject"); + afterParserOrEnumRuleCall(); + } + ) + )+ + otherlv_4='}' + { + newLeafNode(otherlv_4, grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4()); + } + ) +; + +// Entry rule entryRuleFieldRelationInterpretation +entryRuleFieldRelationInterpretation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFieldRelationInterpretationRule()); } + iv_ruleFieldRelationInterpretation=ruleFieldRelationInterpretation + { $current=$iv_ruleFieldRelationInterpretation.current; } + EOF; + +// Rule FieldRelationInterpretation +ruleFieldRelationInterpretation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + lv_containment_0_0='containment' + { + newLeafNode(lv_containment_0_0, grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getFieldRelationInterpretationRule()); + } + setWithLastConsumed($current, "containment", true, "containment"); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); + } + lv_symbol_1_0=ruleModelSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); + } + set( + $current, + "symbol", + lv_symbol_1_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_2=':' + { + newLeafNode(otherlv_2, grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0()); + } + lv_multiplicity_3_0=ruleMultiplicityDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); + } + set( + $current, + "multiplicity", + lv_multiplicity_3_0, + "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); + afterParserOrEnumRuleCall(); + } + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0()); + } + lv_target_4_0=ruleSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); + } + set( + $current, + "target", + lv_target_4_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleGlobalRelationInterpretation +entryRuleGlobalRelationInterpretation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getGlobalRelationInterpretationRule()); } + iv_ruleGlobalRelationInterpretation=ruleGlobalRelationInterpretation + { $current=$iv_ruleGlobalRelationInterpretation.current; } + EOF; + +// Rule GlobalRelationInterpretation +ruleGlobalRelationInterpretation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + lv_containment_0_0='containment' + { + newLeafNode(lv_containment_0_0, grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getGlobalRelationInterpretationRule()); + } + setWithLastConsumed($current, "containment", true, "containment"); + } + ) + ) + otherlv_1='relation' + { + newLeafNode(otherlv_1, grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); + } + lv_symbol_2_0=ruleModelSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); + } + set( + $current, + "symbol", + lv_symbol_2_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_3=':' + { + newLeafNode(otherlv_3, grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3()); + } + ( + ( + { + newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0()); + } + lv_sourceMultiplicity_4_0=ruleMultiplicityDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); + } + set( + $current, + "sourceMultiplicity", + lv_sourceMultiplicity_4_0, + "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); + afterParserOrEnumRuleCall(); + } + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0()); + } + lv_source_5_0=ruleSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); + } + set( + $current, + "source", + lv_source_5_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0()); + } + lv_targetMultiplicity_6_0=ruleMultiplicityDefinition + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); + } + set( + $current, + "targetMultiplicity", + lv_targetMultiplicity_6_0, + "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); + afterParserOrEnumRuleCall(); + } + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0()); + } + lv_target_7_0=ruleSymbol + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); + } + set( + $current, + "target", + lv_target_7_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleMultiplicityDefinition +entryRuleMultiplicityDefinition returns [EObject current=null]: + { newCompositeNode(grammarAccess.getMultiplicityDefinitionRule()); } + iv_ruleMultiplicityDefinition=ruleMultiplicityDefinition + { $current=$iv_ruleMultiplicityDefinition.current; } + EOF; + +// Rule MultiplicityDefinition +ruleMultiplicityDefinition returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + lv_lower_0_0=RULE_INT + { + newLeafNode(lv_lower_0_0, grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); + } + setWithLastConsumed( + $current, + "lower", + lv_lower_0_0, + "org.eclipse.xtext.common.Terminals.INT"); + } + ) + ) + otherlv_1='..' + { + newLeafNode(otherlv_1, grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1()); + } + ( + ( + ( + lv_upper_2_0=RULE_INT + { + newLeafNode(lv_upper_2_0, grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); + } + setWithLastConsumed( + $current, + "upper", + lv_upper_2_0, + "org.eclipse.xtext.common.Terminals.INT"); + } + ) + ) + | + ( + ( + lv_unlimitedUpper_3_0='*' + { + newLeafNode(lv_unlimitedUpper_3_0, grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); + } + setWithLastConsumed($current, "unlimitedUpper", true, "*"); + } + ) + ) + ) + ) +; + +RULE_STRING : '"' ('\\' .|~(('\\'|'"')))* '"'; + +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; + +RULE_INT : ('0'..'9')+; + +RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; + +RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?; + +RULE_WS : (' '|'\t'|'\r'|'\n')+; + +RULE_ANY_OTHER : .; diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens new file mode 100644 index 00000000..1abe7de4 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguage.tokens @@ -0,0 +1,67 @@ +'('=17 +')'=18 +'*'=30 +'+'=29 +'-'=11 +'.'=12 +'..'=40 +':'=19 +'\''=26 +'abstract'=32 +'bool'=22 +'class'=33 +'containment'=38 +'default'=31 +'enum'=37 +'equals'=21 +'error'=16 +'exists'=20 +'extends'=34 +'false'=14 +'int'=23 +'predicate'=27 +'real'=24 +'relation'=39 +'string'=25 +'true'=13 +'unknown'=15 +'{'=35 +'|'=28 +'}'=36 +RULE_ANY_OTHER=10 +RULE_ID=5 +RULE_INT=4 +RULE_ML_COMMENT=7 +RULE_SL_COMMENT=8 +RULE_STRING=6 +RULE_WS=9 +T__11=11 +T__12=12 +T__13=13 +T__14=14 +T__15=15 +T__16=16 +T__17=17 +T__18=18 +T__19=19 +T__20=20 +T__21=21 +T__22=22 +T__23=23 +T__24=24 +T__25=25 +T__26=26 +T__27=27 +T__28=28 +T__29=29 +T__30=30 +T__31=31 +T__32=32 +T__33=33 +T__34=34 +T__35=35 +T__36=36 +T__37=37 +T__38=38 +T__39=39 +T__40=40 diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java new file mode 100644 index 00000000..f8cb627c --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageLexer.java @@ -0,0 +1,1669 @@ +package org.eclipse.viatra.solver.language.parser.antlr.internal; + +// Hack: Use our own Lexer superclass by means of import. +// Currently there is no other way to specify the superclass for the lexer. +import org.eclipse.xtext.parser.antlr.Lexer; + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalSolverLanguageLexer extends Lexer { + public static final int RULE_STRING=6; + public static final int RULE_SL_COMMENT=8; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__37=37; + public static final int T__16=16; + public static final int T__38=38; + public static final int T__17=17; + public static final int T__39=39; + public static final int T__18=18; + public static final int T__11=11; + public static final int T__33=33; + public static final int T__12=12; + public static final int T__34=34; + public static final int T__13=13; + public static final int T__35=35; + public static final int T__14=14; + public static final int T__36=36; + public static final int EOF=-1; + public static final int T__30=30; + public static final int T__31=31; + public static final int T__32=32; + public static final int RULE_ID=5; + public static final int RULE_WS=9; + public static final int RULE_ANY_OTHER=10; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int RULE_INT=4; + public static final int T__29=29; + public static final int T__22=22; + public static final int RULE_ML_COMMENT=7; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__40=40; + public static final int T__20=20; + public static final int T__21=21; + + // delegates + // delegators + + public InternalSolverLanguageLexer() {;} + public InternalSolverLanguageLexer(CharStream input) { + this(input, new RecognizerSharedState()); + } + public InternalSolverLanguageLexer(CharStream input, RecognizerSharedState state) { + super(input,state); + + } + public String getGrammarFileName() { return "InternalSolverLanguage.g"; } + + // $ANTLR start "T__11" + public final void mT__11() throws RecognitionException { + try { + int _type = T__11; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:11:7: ( '-' ) + // InternalSolverLanguage.g:11:9: '-' + { + match('-'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__11" + + // $ANTLR start "T__12" + public final void mT__12() throws RecognitionException { + try { + int _type = T__12; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:12:7: ( '.' ) + // InternalSolverLanguage.g:12:9: '.' + { + match('.'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__12" + + // $ANTLR start "T__13" + public final void mT__13() throws RecognitionException { + try { + int _type = T__13; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:13:7: ( 'true' ) + // InternalSolverLanguage.g:13:9: 'true' + { + match("true"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__13" + + // $ANTLR start "T__14" + public final void mT__14() throws RecognitionException { + try { + int _type = T__14; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:14:7: ( 'false' ) + // InternalSolverLanguage.g:14:9: 'false' + { + match("false"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__14" + + // $ANTLR start "T__15" + public final void mT__15() throws RecognitionException { + try { + int _type = T__15; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:15:7: ( 'unknown' ) + // InternalSolverLanguage.g:15:9: 'unknown' + { + match("unknown"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__15" + + // $ANTLR start "T__16" + public final void mT__16() throws RecognitionException { + try { + int _type = T__16; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:16:7: ( 'error' ) + // InternalSolverLanguage.g:16:9: 'error' + { + match("error"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__16" + + // $ANTLR start "T__17" + public final void mT__17() throws RecognitionException { + try { + int _type = T__17; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:17:7: ( '(' ) + // InternalSolverLanguage.g:17:9: '(' + { + match('('); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__17" + + // $ANTLR start "T__18" + public final void mT__18() throws RecognitionException { + try { + int _type = T__18; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:18:7: ( ')' ) + // InternalSolverLanguage.g:18:9: ')' + { + match(')'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__18" + + // $ANTLR start "T__19" + public final void mT__19() throws RecognitionException { + try { + int _type = T__19; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:19:7: ( ':' ) + // InternalSolverLanguage.g:19:9: ':' + { + match(':'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__19" + + // $ANTLR start "T__20" + public final void mT__20() throws RecognitionException { + try { + int _type = T__20; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:20:7: ( 'exists' ) + // InternalSolverLanguage.g:20:9: 'exists' + { + match("exists"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__20" + + // $ANTLR start "T__21" + public final void mT__21() throws RecognitionException { + try { + int _type = T__21; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:21:7: ( 'equals' ) + // InternalSolverLanguage.g:21:9: 'equals' + { + match("equals"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__21" + + // $ANTLR start "T__22" + public final void mT__22() throws RecognitionException { + try { + int _type = T__22; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:22:7: ( 'bool' ) + // InternalSolverLanguage.g:22:9: 'bool' + { + match("bool"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__22" + + // $ANTLR start "T__23" + public final void mT__23() throws RecognitionException { + try { + int _type = T__23; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:23:7: ( 'int' ) + // InternalSolverLanguage.g:23:9: 'int' + { + match("int"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__23" + + // $ANTLR start "T__24" + public final void mT__24() throws RecognitionException { + try { + int _type = T__24; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:24:7: ( 'real' ) + // InternalSolverLanguage.g:24:9: 'real' + { + match("real"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__24" + + // $ANTLR start "T__25" + public final void mT__25() throws RecognitionException { + try { + int _type = T__25; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:25:7: ( 'string' ) + // InternalSolverLanguage.g:25:9: 'string' + { + match("string"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__25" + + // $ANTLR start "T__26" + public final void mT__26() throws RecognitionException { + try { + int _type = T__26; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:26:7: ( '\\'' ) + // InternalSolverLanguage.g:26:9: '\\'' + { + match('\''); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__26" + + // $ANTLR start "T__27" + public final void mT__27() throws RecognitionException { + try { + int _type = T__27; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:27:7: ( 'predicate' ) + // InternalSolverLanguage.g:27:9: 'predicate' + { + match("predicate"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__27" + + // $ANTLR start "T__28" + public final void mT__28() throws RecognitionException { + try { + int _type = T__28; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:28:7: ( '|' ) + // InternalSolverLanguage.g:28:9: '|' + { + match('|'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__28" + + // $ANTLR start "T__29" + public final void mT__29() throws RecognitionException { + try { + int _type = T__29; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:29:7: ( '+' ) + // InternalSolverLanguage.g:29:9: '+' + { + match('+'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__29" + + // $ANTLR start "T__30" + public final void mT__30() throws RecognitionException { + try { + int _type = T__30; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:30:7: ( '*' ) + // InternalSolverLanguage.g:30:9: '*' + { + match('*'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__30" + + // $ANTLR start "T__31" + public final void mT__31() throws RecognitionException { + try { + int _type = T__31; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:31:7: ( 'default' ) + // InternalSolverLanguage.g:31:9: 'default' + { + match("default"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__31" + + // $ANTLR start "T__32" + public final void mT__32() throws RecognitionException { + try { + int _type = T__32; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:32:7: ( 'abstract' ) + // InternalSolverLanguage.g:32:9: 'abstract' + { + match("abstract"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__32" + + // $ANTLR start "T__33" + public final void mT__33() throws RecognitionException { + try { + int _type = T__33; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:33:7: ( 'class' ) + // InternalSolverLanguage.g:33:9: 'class' + { + match("class"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__33" + + // $ANTLR start "T__34" + public final void mT__34() throws RecognitionException { + try { + int _type = T__34; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:34:7: ( 'extends' ) + // InternalSolverLanguage.g:34:9: 'extends' + { + match("extends"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__34" + + // $ANTLR start "T__35" + public final void mT__35() throws RecognitionException { + try { + int _type = T__35; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:35:7: ( '{' ) + // InternalSolverLanguage.g:35:9: '{' + { + match('{'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__35" + + // $ANTLR start "T__36" + public final void mT__36() throws RecognitionException { + try { + int _type = T__36; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:36:7: ( '}' ) + // InternalSolverLanguage.g:36:9: '}' + { + match('}'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__36" + + // $ANTLR start "T__37" + public final void mT__37() throws RecognitionException { + try { + int _type = T__37; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:37:7: ( 'enum' ) + // InternalSolverLanguage.g:37:9: 'enum' + { + match("enum"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__37" + + // $ANTLR start "T__38" + public final void mT__38() throws RecognitionException { + try { + int _type = T__38; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:38:7: ( 'containment' ) + // InternalSolverLanguage.g:38:9: 'containment' + { + match("containment"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__38" + + // $ANTLR start "T__39" + public final void mT__39() throws RecognitionException { + try { + int _type = T__39; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:39:7: ( 'relation' ) + // InternalSolverLanguage.g:39:9: 'relation' + { + match("relation"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__39" + + // $ANTLR start "T__40" + public final void mT__40() throws RecognitionException { + try { + int _type = T__40; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:40:7: ( '..' ) + // InternalSolverLanguage.g:40:9: '..' + { + match(".."); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__40" + + // $ANTLR start "RULE_STRING" + public final void mRULE_STRING() throws RecognitionException { + try { + int _type = RULE_STRING; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:2563:13: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' ) + // InternalSolverLanguage.g:2563:15: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + { + match('\"'); + // InternalSolverLanguage.g:2563:19: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop1: + do { + int alt1=3; + int LA1_0 = input.LA(1); + + if ( (LA1_0=='\\') ) { + alt1=1; + } + else if ( ((LA1_0>='\u0000' && LA1_0<='!')||(LA1_0>='#' && LA1_0<='[')||(LA1_0>=']' && LA1_0<='\uFFFF')) ) { + alt1=2; + } + + + switch (alt1) { + case 1 : + // InternalSolverLanguage.g:2563:20: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalSolverLanguage.g:2563:27: ~ ( ( '\\\\' | '\"' ) ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop1; + } + } while (true); + + match('\"'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_STRING" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:2565:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) + // InternalSolverLanguage.g:2565:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + { + // InternalSolverLanguage.g:2565:11: ( '^' )? + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0=='^') ) { + alt2=1; + } + switch (alt2) { + case 1 : + // InternalSolverLanguage.g:2565:11: '^' + { + match('^'); + + } + break; + + } + + if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalSolverLanguage.g:2565:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + loop3: + do { + int alt3=2; + int LA3_0 = input.LA(1); + + if ( ((LA3_0>='0' && LA3_0<='9')||(LA3_0>='A' && LA3_0<='Z')||LA3_0=='_'||(LA3_0>='a' && LA3_0<='z')) ) { + alt3=1; + } + + + switch (alt3) { + case 1 : + // InternalSolverLanguage.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop3; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ID" + + // $ANTLR start "RULE_INT" + public final void mRULE_INT() throws RecognitionException { + try { + int _type = RULE_INT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:2567:10: ( ( '0' .. '9' )+ ) + // InternalSolverLanguage.g:2567:12: ( '0' .. '9' )+ + { + // InternalSolverLanguage.g:2567:12: ( '0' .. '9' )+ + int cnt4=0; + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); + + if ( ((LA4_0>='0' && LA4_0<='9')) ) { + alt4=1; + } + + + switch (alt4) { + case 1 : + // InternalSolverLanguage.g:2567:13: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + if ( cnt4 >= 1 ) break loop4; + EarlyExitException eee = + new EarlyExitException(4, input); + throw eee; + } + cnt4++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_INT" + + // $ANTLR start "RULE_ML_COMMENT" + public final void mRULE_ML_COMMENT() throws RecognitionException { + try { + int _type = RULE_ML_COMMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:2569:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalSolverLanguage.g:2569:19: '/*' ( options {greedy=false; } : . )* '*/' + { + match("/*"); + + // InternalSolverLanguage.g:2569:24: ( options {greedy=false; } : . )* + loop5: + do { + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0=='*') ) { + int LA5_1 = input.LA(2); + + if ( (LA5_1=='/') ) { + alt5=2; + } + else if ( ((LA5_1>='\u0000' && LA5_1<='.')||(LA5_1>='0' && LA5_1<='\uFFFF')) ) { + alt5=1; + } + + + } + else if ( ((LA5_0>='\u0000' && LA5_0<=')')||(LA5_0>='+' && LA5_0<='\uFFFF')) ) { + alt5=1; + } + + + switch (alt5) { + case 1 : + // InternalSolverLanguage.g:2569:52: . + { + matchAny(); + + } + break; + + default : + break loop5; + } + } while (true); + + match("*/"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ML_COMMENT" + + // $ANTLR start "RULE_SL_COMMENT" + public final void mRULE_SL_COMMENT() throws RecognitionException { + try { + int _type = RULE_SL_COMMENT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:2571:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) + // InternalSolverLanguage.g:2571:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? + { + match("//"); + + // InternalSolverLanguage.g:2571:24: (~ ( ( '\\n' | '\\r' ) ) )* + loop6: + do { + int alt6=2; + int LA6_0 = input.LA(1); + + if ( ((LA6_0>='\u0000' && LA6_0<='\t')||(LA6_0>='\u000B' && LA6_0<='\f')||(LA6_0>='\u000E' && LA6_0<='\uFFFF')) ) { + alt6=1; + } + + + switch (alt6) { + case 1 : + // InternalSolverLanguage.g:2571:24: ~ ( ( '\\n' | '\\r' ) ) + { + if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop6; + } + } while (true); + + // InternalSolverLanguage.g:2571:40: ( ( '\\r' )? '\\n' )? + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0=='\n'||LA8_0=='\r') ) { + alt8=1; + } + switch (alt8) { + case 1 : + // InternalSolverLanguage.g:2571:41: ( '\\r' )? '\\n' + { + // InternalSolverLanguage.g:2571:41: ( '\\r' )? + int alt7=2; + int LA7_0 = input.LA(1); + + if ( (LA7_0=='\r') ) { + alt7=1; + } + switch (alt7) { + case 1 : + // InternalSolverLanguage.g:2571:41: '\\r' + { + match('\r'); + + } + break; + + } + + match('\n'); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_SL_COMMENT" + + // $ANTLR start "RULE_WS" + public final void mRULE_WS() throws RecognitionException { + try { + int _type = RULE_WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:2573:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalSolverLanguage.g:2573:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalSolverLanguage.g:2573:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt9=0; + loop9: + do { + int alt9=2; + int LA9_0 = input.LA(1); + + if ( ((LA9_0>='\t' && LA9_0<='\n')||LA9_0=='\r'||LA9_0==' ') ) { + alt9=1; + } + + + switch (alt9) { + case 1 : + // InternalSolverLanguage.g: + { + if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt9 >= 1 ) break loop9; + EarlyExitException eee = + new EarlyExitException(9, input); + throw eee; + } + cnt9++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_WS" + + // $ANTLR start "RULE_ANY_OTHER" + public final void mRULE_ANY_OTHER() throws RecognitionException { + try { + int _type = RULE_ANY_OTHER; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalSolverLanguage.g:2575:16: ( . ) + // InternalSolverLanguage.g:2575:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalSolverLanguage.g:1:8: ( T__11 | T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | RULE_STRING | RULE_ID | RULE_INT | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt10=37; + alt10 = dfa10.predict(input); + switch (alt10) { + case 1 : + // InternalSolverLanguage.g:1:10: T__11 + { + mT__11(); + + } + break; + case 2 : + // InternalSolverLanguage.g:1:16: T__12 + { + mT__12(); + + } + break; + case 3 : + // InternalSolverLanguage.g:1:22: T__13 + { + mT__13(); + + } + break; + case 4 : + // InternalSolverLanguage.g:1:28: T__14 + { + mT__14(); + + } + break; + case 5 : + // InternalSolverLanguage.g:1:34: T__15 + { + mT__15(); + + } + break; + case 6 : + // InternalSolverLanguage.g:1:40: T__16 + { + mT__16(); + + } + break; + case 7 : + // InternalSolverLanguage.g:1:46: T__17 + { + mT__17(); + + } + break; + case 8 : + // InternalSolverLanguage.g:1:52: T__18 + { + mT__18(); + + } + break; + case 9 : + // InternalSolverLanguage.g:1:58: T__19 + { + mT__19(); + + } + break; + case 10 : + // InternalSolverLanguage.g:1:64: T__20 + { + mT__20(); + + } + break; + case 11 : + // InternalSolverLanguage.g:1:70: T__21 + { + mT__21(); + + } + break; + case 12 : + // InternalSolverLanguage.g:1:76: T__22 + { + mT__22(); + + } + break; + case 13 : + // InternalSolverLanguage.g:1:82: T__23 + { + mT__23(); + + } + break; + case 14 : + // InternalSolverLanguage.g:1:88: T__24 + { + mT__24(); + + } + break; + case 15 : + // InternalSolverLanguage.g:1:94: T__25 + { + mT__25(); + + } + break; + case 16 : + // InternalSolverLanguage.g:1:100: T__26 + { + mT__26(); + + } + break; + case 17 : + // InternalSolverLanguage.g:1:106: T__27 + { + mT__27(); + + } + break; + case 18 : + // InternalSolverLanguage.g:1:112: T__28 + { + mT__28(); + + } + break; + case 19 : + // InternalSolverLanguage.g:1:118: T__29 + { + mT__29(); + + } + break; + case 20 : + // InternalSolverLanguage.g:1:124: T__30 + { + mT__30(); + + } + break; + case 21 : + // InternalSolverLanguage.g:1:130: T__31 + { + mT__31(); + + } + break; + case 22 : + // InternalSolverLanguage.g:1:136: T__32 + { + mT__32(); + + } + break; + case 23 : + // InternalSolverLanguage.g:1:142: T__33 + { + mT__33(); + + } + break; + case 24 : + // InternalSolverLanguage.g:1:148: T__34 + { + mT__34(); + + } + break; + case 25 : + // InternalSolverLanguage.g:1:154: T__35 + { + mT__35(); + + } + break; + case 26 : + // InternalSolverLanguage.g:1:160: T__36 + { + mT__36(); + + } + break; + case 27 : + // InternalSolverLanguage.g:1:166: T__37 + { + mT__37(); + + } + break; + case 28 : + // InternalSolverLanguage.g:1:172: T__38 + { + mT__38(); + + } + break; + case 29 : + // InternalSolverLanguage.g:1:178: T__39 + { + mT__39(); + + } + break; + case 30 : + // InternalSolverLanguage.g:1:184: T__40 + { + mT__40(); + + } + break; + case 31 : + // InternalSolverLanguage.g:1:190: RULE_STRING + { + mRULE_STRING(); + + } + break; + case 32 : + // InternalSolverLanguage.g:1:202: RULE_ID + { + mRULE_ID(); + + } + break; + case 33 : + // InternalSolverLanguage.g:1:210: RULE_INT + { + mRULE_INT(); + + } + break; + case 34 : + // InternalSolverLanguage.g:1:219: RULE_ML_COMMENT + { + mRULE_ML_COMMENT(); + + } + break; + case 35 : + // InternalSolverLanguage.g:1:235: RULE_SL_COMMENT + { + mRULE_SL_COMMENT(); + + } + break; + case 36 : + // InternalSolverLanguage.g:1:251: RULE_WS + { + mRULE_WS(); + + } + break; + case 37 : + // InternalSolverLanguage.g:1:259: RULE_ANY_OTHER + { + mRULE_ANY_OTHER(); + + } + break; + + } + + } + + + protected DFA10 dfa10 = new DFA10(this); + static final String DFA10_eotS = + "\2\uffff\1\41\4\43\3\uffff\4\43\1\uffff\1\43\3\uffff\3\43\2\uffff\2\36\2\uffff\1\36\5\uffff\1\43\1\uffff\6\43\3\uffff\4\43\1\uffff\1\43\3\uffff\4\43\7\uffff\11\43\1\134\10\43\1\145\6\43\1\154\1\155\1\uffff\1\156\7\43\1\uffff\1\166\1\43\1\170\3\43\3\uffff\5\43\1\u0081\1\43\1\uffff\1\43\1\uffff\1\u0084\1\43\1\u0086\1\43\1\u0088\3\43\1\uffff\1\43\1\u008d\1\uffff\1\u008e\1\uffff\1\43\1\uffff\1\43\1\u0091\2\43\2\uffff\1\u0094\1\43\1\uffff\1\u0096\1\43\1\uffff\1\u0098\1\uffff\1\43\1\uffff\1\43\1\u009b\1\uffff"; + static final String DFA10_eofS = + "\u009c\uffff"; + static final String DFA10_minS = + "\1\0\1\uffff\1\56\1\162\1\141\2\156\3\uffff\1\157\1\156\1\145\1\164\1\uffff\1\162\3\uffff\1\145\1\142\1\154\2\uffff\1\0\1\101\2\uffff\1\52\5\uffff\1\165\1\uffff\1\154\1\153\1\162\1\151\2\165\3\uffff\1\157\1\164\1\141\1\162\1\uffff\1\145\3\uffff\1\146\1\163\1\141\1\156\7\uffff\1\145\1\163\1\156\1\157\1\163\1\145\1\141\1\155\1\154\1\60\1\154\1\141\1\151\1\144\1\141\1\164\1\163\1\164\1\60\1\145\1\157\1\162\1\164\1\156\1\154\2\60\1\uffff\1\60\1\164\1\156\1\151\1\165\1\162\1\163\1\141\1\uffff\1\60\1\167\1\60\1\163\1\144\1\163\3\uffff\1\151\1\147\1\143\1\154\1\141\1\60\1\151\1\uffff\1\156\1\uffff\1\60\1\163\1\60\1\157\1\60\1\141\1\164\1\143\1\uffff\1\156\1\60\1\uffff\1\60\1\uffff\1\156\1\uffff\1\164\1\60\1\164\1\155\2\uffff\1\60\1\145\1\uffff\1\60\1\145\1\uffff\1\60\1\uffff\1\156\1\uffff\1\164\1\60\1\uffff"; + static final String DFA10_maxS = + "\1\uffff\1\uffff\1\56\1\162\1\141\1\156\1\170\3\uffff\1\157\1\156\1\145\1\164\1\uffff\1\162\3\uffff\1\145\1\142\1\157\2\uffff\1\uffff\1\172\2\uffff\1\57\5\uffff\1\165\1\uffff\1\154\1\153\1\162\1\164\2\165\3\uffff\1\157\1\164\1\154\1\162\1\uffff\1\145\3\uffff\1\146\1\163\1\141\1\156\7\uffff\1\145\1\163\1\156\1\157\1\163\1\145\1\141\1\155\1\154\1\172\1\154\1\141\1\151\1\144\1\141\1\164\1\163\1\164\1\172\1\145\1\157\1\162\1\164\1\156\1\154\2\172\1\uffff\1\172\1\164\1\156\1\151\1\165\1\162\1\163\1\141\1\uffff\1\172\1\167\1\172\1\163\1\144\1\163\3\uffff\1\151\1\147\1\143\1\154\1\141\1\172\1\151\1\uffff\1\156\1\uffff\1\172\1\163\1\172\1\157\1\172\1\141\1\164\1\143\1\uffff\1\156\1\172\1\uffff\1\172\1\uffff\1\156\1\uffff\1\164\1\172\1\164\1\155\2\uffff\1\172\1\145\1\uffff\1\172\1\145\1\uffff\1\172\1\uffff\1\156\1\uffff\1\164\1\172\1\uffff"; + static final String DFA10_acceptS = + "\1\uffff\1\1\5\uffff\1\7\1\10\1\11\4\uffff\1\20\1\uffff\1\22\1\23\1\24\3\uffff\1\31\1\32\2\uffff\1\40\1\41\1\uffff\1\44\1\45\1\1\1\36\1\2\1\uffff\1\40\6\uffff\1\7\1\10\1\11\4\uffff\1\20\1\uffff\1\22\1\23\1\24\4\uffff\1\31\1\32\1\37\1\41\1\42\1\43\1\44\33\uffff\1\15\10\uffff\1\3\6\uffff\1\33\1\14\1\16\7\uffff\1\4\1\uffff\1\6\10\uffff\1\27\2\uffff\1\12\1\uffff\1\13\1\uffff\1\17\4\uffff\1\5\1\30\2\uffff\1\25\2\uffff\1\35\1\uffff\1\26\1\uffff\1\21\2\uffff\1\34"; + static final String DFA10_specialS = + "\1\1\27\uffff\1\0\u0083\uffff}>"; + static final String[] DFA10_transitionS = { + "\11\36\2\35\2\36\1\35\22\36\1\35\1\36\1\30\4\36\1\16\1\7\1\10\1\22\1\21\1\36\1\1\1\2\1\34\12\33\1\11\6\36\32\32\3\36\1\31\1\32\1\36\1\24\1\12\1\25\1\23\1\6\1\4\2\32\1\13\6\32\1\17\1\32\1\14\1\15\1\3\1\5\5\32\1\26\1\20\1\27\uff82\36", + "", + "\1\40", + "\1\42", + "\1\44", + "\1\45", + "\1\51\2\uffff\1\50\1\46\5\uffff\1\47", + "", + "", + "", + "\1\55", + "\1\56", + "\1\57", + "\1\60", + "", + "\1\62", + "", + "", + "", + "\1\66", + "\1\67", + "\1\70\2\uffff\1\71", + "", + "", + "\0\74", + "\32\43\4\uffff\1\43\1\uffff\32\43", + "", + "", + "\1\76\4\uffff\1\77", + "", + "", + "", + "", + "", + "\1\101", + "", + "\1\102", + "\1\103", + "\1\104", + "\1\105\12\uffff\1\106", + "\1\107", + "\1\110", + "", + "", + "", + "\1\111", + "\1\112", + "\1\113\12\uffff\1\114", + "\1\115", + "", + "\1\116", + "", + "", + "", + "\1\117", + "\1\120", + "\1\121", + "\1\122", + "", + "", + "", + "", + "", + "", + "", + "\1\123", + "\1\124", + "\1\125", + "\1\126", + "\1\127", + "\1\130", + "\1\131", + "\1\132", + "\1\133", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\135", + "\1\136", + "\1\137", + "\1\140", + "\1\141", + "\1\142", + "\1\143", + "\1\144", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\146", + "\1\147", + "\1\150", + "\1\151", + "\1\152", + "\1\153", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\157", + "\1\160", + "\1\161", + "\1\162", + "\1\163", + "\1\164", + "\1\165", + "", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\167", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\171", + "\1\172", + "\1\173", + "", + "", + "", + "\1\174", + "\1\175", + "\1\176", + "\1\177", + "\1\u0080", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\u0082", + "", + "\1\u0083", + "", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\u0085", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\u0087", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\u0089", + "\1\u008a", + "\1\u008b", + "", + "\1\u008c", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "", + "\1\u008f", + "", + "\1\u0090", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\u0092", + "\1\u0093", + "", + "", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\u0095", + "", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "\1\u0097", + "", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "", + "\1\u0099", + "", + "\1\u009a", + "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", + "" + }; + + static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS); + static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS); + static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS); + static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS); + static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS); + static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS); + static final short[][] DFA10_transition; + + static { + int numStates = DFA10_transitionS.length; + DFA10_transition = new short[numStates][]; + for (int i=0; i='\u0000' && LA10_24<='\uFFFF')) ) {s = 60;} + + else s = 30; + + if ( s>=0 ) return s; + break; + case 1 : + int LA10_0 = input.LA(1); + + s = -1; + if ( (LA10_0=='-') ) {s = 1;} + + else if ( (LA10_0=='.') ) {s = 2;} + + else if ( (LA10_0=='t') ) {s = 3;} + + else if ( (LA10_0=='f') ) {s = 4;} + + else if ( (LA10_0=='u') ) {s = 5;} + + else if ( (LA10_0=='e') ) {s = 6;} + + else if ( (LA10_0=='(') ) {s = 7;} + + else if ( (LA10_0==')') ) {s = 8;} + + else if ( (LA10_0==':') ) {s = 9;} + + else if ( (LA10_0=='b') ) {s = 10;} + + else if ( (LA10_0=='i') ) {s = 11;} + + else if ( (LA10_0=='r') ) {s = 12;} + + else if ( (LA10_0=='s') ) {s = 13;} + + else if ( (LA10_0=='\'') ) {s = 14;} + + else if ( (LA10_0=='p') ) {s = 15;} + + else if ( (LA10_0=='|') ) {s = 16;} + + else if ( (LA10_0=='+') ) {s = 17;} + + else if ( (LA10_0=='*') ) {s = 18;} + + else if ( (LA10_0=='d') ) {s = 19;} + + else if ( (LA10_0=='a') ) {s = 20;} + + else if ( (LA10_0=='c') ) {s = 21;} + + else if ( (LA10_0=='{') ) {s = 22;} + + else if ( (LA10_0=='}') ) {s = 23;} + + else if ( (LA10_0=='\"') ) {s = 24;} + + else if ( (LA10_0=='^') ) {s = 25;} + + else if ( ((LA10_0>='A' && LA10_0<='Z')||LA10_0=='_'||(LA10_0>='g' && LA10_0<='h')||(LA10_0>='j' && LA10_0<='o')||LA10_0=='q'||(LA10_0>='v' && LA10_0<='z')) ) {s = 26;} + + else if ( ((LA10_0>='0' && LA10_0<='9')) ) {s = 27;} + + else if ( (LA10_0=='/') ) {s = 28;} + + else if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) {s = 29;} + + else if ( ((LA10_0>='\u0000' && LA10_0<='\b')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='\u001F')||LA10_0=='!'||(LA10_0>='#' && LA10_0<='&')||LA10_0==','||(LA10_0>=';' && LA10_0<='@')||(LA10_0>='[' && LA10_0<=']')||LA10_0=='`'||(LA10_0>='~' && LA10_0<='\uFFFF')) ) {s = 30;} + + if ( s>=0 ) return s; + break; + } + NoViableAltException nvae = + new NoViableAltException(getDescription(), 10, _s, input); + error(nvae); + throw nvae; + } + } + + +} \ No newline at end of file diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java new file mode 100644 index 00000000..c1c632f3 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/parser/antlr/internal/InternalSolverLanguageParser.java @@ -0,0 +1,7214 @@ +package org.eclipse.viatra.solver.language.parser.antlr.internal; + +import org.eclipse.xtext.*; +import org.eclipse.xtext.parser.*; +import org.eclipse.xtext.parser.impl.*; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser; +import org.eclipse.xtext.parser.antlr.XtextTokenStream; +import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens; +import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken; +import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; + + + +import org.antlr.runtime.*; +import java.util.Stack; +import java.util.List; +import java.util.ArrayList; + +@SuppressWarnings("all") +public class InternalSolverLanguageParser extends AbstractInternalAntlrParser { + public static final String[] tokenNames = new String[] { + "", "", "", "", "RULE_INT", "RULE_ID", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'-'", "'.'", "'true'", "'false'", "'unknown'", "'error'", "'('", "')'", "':'", "'exists'", "'equals'", "'bool'", "'int'", "'real'", "'string'", "'\\''", "'predicate'", "'|'", "'+'", "'*'", "'default'", "'abstract'", "'class'", "'extends'", "'{'", "'}'", "'enum'", "'containment'", "'relation'", "'..'" + }; + public static final int RULE_STRING=6; + public static final int RULE_SL_COMMENT=8; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__37=37; + public static final int T__16=16; + public static final int T__38=38; + public static final int T__17=17; + public static final int T__39=39; + public static final int T__18=18; + public static final int T__11=11; + public static final int T__33=33; + public static final int T__12=12; + public static final int T__34=34; + public static final int T__13=13; + public static final int T__35=35; + public static final int T__14=14; + public static final int T__36=36; + public static final int EOF=-1; + public static final int T__30=30; + public static final int T__31=31; + public static final int T__32=32; + public static final int RULE_ID=5; + public static final int RULE_WS=9; + public static final int RULE_ANY_OTHER=10; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int RULE_INT=4; + public static final int T__29=29; + public static final int T__22=22; + public static final int RULE_ML_COMMENT=7; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__40=40; + public static final int T__20=20; + public static final int T__21=21; + + // delegates + // delegators + + + public InternalSolverLanguageParser(TokenStream input) { + this(input, new RecognizerSharedState()); + } + public InternalSolverLanguageParser(TokenStream input, RecognizerSharedState state) { + super(input, state); + + } + + + public String[] getTokenNames() { return InternalSolverLanguageParser.tokenNames; } + public String getGrammarFileName() { return "InternalSolverLanguage.g"; } + + + + private SolverLanguageGrammarAccess grammarAccess; + + public InternalSolverLanguageParser(TokenStream input, SolverLanguageGrammarAccess grammarAccess) { + this(input); + this.grammarAccess = grammarAccess; + registerRules(grammarAccess.getGrammar()); + } + + @Override + protected String getFirstRuleName() { + return "Problem"; + } + + @Override + protected SolverLanguageGrammarAccess getGrammarAccess() { + return grammarAccess; + } + + + + + // $ANTLR start "entryRuleProblem" + // InternalSolverLanguage.g:64:1: entryRuleProblem returns [EObject current=null] : iv_ruleProblem= ruleProblem EOF ; + public final EObject entryRuleProblem() throws RecognitionException { + EObject current = null; + + EObject iv_ruleProblem = null; + + + try { + // InternalSolverLanguage.g:64:48: (iv_ruleProblem= ruleProblem EOF ) + // InternalSolverLanguage.g:65:2: iv_ruleProblem= ruleProblem EOF + { + newCompositeNode(grammarAccess.getProblemRule()); + pushFollow(FOLLOW_1); + iv_ruleProblem=ruleProblem(); + + state._fsp--; + + current =iv_ruleProblem; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleProblem" + + + // $ANTLR start "ruleProblem" + // InternalSolverLanguage.g:71:1: ruleProblem returns [EObject current=null] : ( (lv_statements_0_0= ruleStatement ) )* ; + public final EObject ruleProblem() throws RecognitionException { + EObject current = null; + + EObject lv_statements_0_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:77:2: ( ( (lv_statements_0_0= ruleStatement ) )* ) + // InternalSolverLanguage.g:78:2: ( (lv_statements_0_0= ruleStatement ) )* + { + // InternalSolverLanguage.g:78:2: ( (lv_statements_0_0= ruleStatement ) )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); + + if ( (LA1_0==RULE_ID||LA1_0==16||(LA1_0>=20 && LA1_0<=25)||LA1_0==27||(LA1_0>=31 && LA1_0<=32)||(LA1_0>=37 && LA1_0<=38)) ) { + alt1=1; + } + + + switch (alt1) { + case 1 : + // InternalSolverLanguage.g:79:3: (lv_statements_0_0= ruleStatement ) + { + // InternalSolverLanguage.g:79:3: (lv_statements_0_0= ruleStatement ) + // InternalSolverLanguage.g:80:4: lv_statements_0_0= ruleStatement + { + + newCompositeNode(grammarAccess.getProblemAccess().getStatementsStatementParserRuleCall_0()); + + pushFollow(FOLLOW_3); + lv_statements_0_0=ruleStatement(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getProblemRule()); + } + add( + current, + "statements", + lv_statements_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop1; + } + } while (true); + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleProblem" + + + // $ANTLR start "entryRuleStatement" + // InternalSolverLanguage.g:100:1: entryRuleStatement returns [EObject current=null] : iv_ruleStatement= ruleStatement EOF ; + public final EObject entryRuleStatement() throws RecognitionException { + EObject current = null; + + EObject iv_ruleStatement = null; + + + try { + // InternalSolverLanguage.g:100:50: (iv_ruleStatement= ruleStatement EOF ) + // InternalSolverLanguage.g:101:2: iv_ruleStatement= ruleStatement EOF + { + newCompositeNode(grammarAccess.getStatementRule()); + pushFollow(FOLLOW_1); + iv_ruleStatement=ruleStatement(); + + state._fsp--; + + current =iv_ruleStatement; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleStatement" + + + // $ANTLR start "ruleStatement" + // InternalSolverLanguage.g:107:1: ruleStatement returns [EObject current=null] : (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) ; + public final EObject ruleStatement() throws RecognitionException { + EObject current = null; + + EObject this_Interpretation_0 = null; + + EObject this_Predicate_1 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:113:2: ( (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) ) + // InternalSolverLanguage.g:114:2: (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) + { + // InternalSolverLanguage.g:114:2: (this_Interpretation_0= ruleInterpretation | this_Predicate_1= rulePredicate ) + int alt2=2; + int LA2_0 = input.LA(1); + + if ( (LA2_0==RULE_ID||(LA2_0>=20 && LA2_0<=25)||(LA2_0>=31 && LA2_0<=32)||(LA2_0>=37 && LA2_0<=38)) ) { + alt2=1; + } + else if ( (LA2_0==16||LA2_0==27) ) { + alt2=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 2, 0, input); + + throw nvae; + } + switch (alt2) { + case 1 : + // InternalSolverLanguage.g:115:3: this_Interpretation_0= ruleInterpretation + { + + newCompositeNode(grammarAccess.getStatementAccess().getInterpretationParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_Interpretation_0=ruleInterpretation(); + + state._fsp--; + + + current = this_Interpretation_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalSolverLanguage.g:124:3: this_Predicate_1= rulePredicate + { + + newCompositeNode(grammarAccess.getStatementAccess().getPredicateParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_Predicate_1=rulePredicate(); + + state._fsp--; + + + current = this_Predicate_1; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleStatement" + + + // $ANTLR start "entryRuleREALLiteral" + // InternalSolverLanguage.g:136:1: entryRuleREALLiteral returns [String current=null] : iv_ruleREALLiteral= ruleREALLiteral EOF ; + public final String entryRuleREALLiteral() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleREALLiteral = null; + + + try { + // InternalSolverLanguage.g:136:51: (iv_ruleREALLiteral= ruleREALLiteral EOF ) + // InternalSolverLanguage.g:137:2: iv_ruleREALLiteral= ruleREALLiteral EOF + { + newCompositeNode(grammarAccess.getREALLiteralRule()); + pushFollow(FOLLOW_1); + iv_ruleREALLiteral=ruleREALLiteral(); + + state._fsp--; + + current =iv_ruleREALLiteral.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleREALLiteral" + + + // $ANTLR start "ruleREALLiteral" + // InternalSolverLanguage.g:143:1: ruleREALLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) ; + public final AntlrDatatypeRuleToken ruleREALLiteral() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + Token this_INT_1=null; + Token this_INT_3=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:149:2: ( ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) ) + // InternalSolverLanguage.g:150:2: ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) + { + // InternalSolverLanguage.g:150:2: ( (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT ) + // InternalSolverLanguage.g:151:3: (kw= '-' )? this_INT_1= RULE_INT kw= '.' this_INT_3= RULE_INT + { + // InternalSolverLanguage.g:151:3: (kw= '-' )? + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0==11) ) { + alt3=1; + } + switch (alt3) { + case 1 : + // InternalSolverLanguage.g:152:4: kw= '-' + { + kw=(Token)match(input,11,FOLLOW_4); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getREALLiteralAccess().getHyphenMinusKeyword_0()); + + + } + break; + + } + + this_INT_1=(Token)match(input,RULE_INT,FOLLOW_5); + + current.merge(this_INT_1); + + + newLeafNode(this_INT_1, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_1()); + + kw=(Token)match(input,12,FOLLOW_4); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getREALLiteralAccess().getFullStopKeyword_2()); + + this_INT_3=(Token)match(input,RULE_INT,FOLLOW_2); + + current.merge(this_INT_3); + + + newLeafNode(this_INT_3, grammarAccess.getREALLiteralAccess().getINTTerminalRuleCall_3()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleREALLiteral" + + + // $ANTLR start "entryRuleINTLiteral" + // InternalSolverLanguage.g:181:1: entryRuleINTLiteral returns [String current=null] : iv_ruleINTLiteral= ruleINTLiteral EOF ; + public final String entryRuleINTLiteral() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleINTLiteral = null; + + + try { + // InternalSolverLanguage.g:181:50: (iv_ruleINTLiteral= ruleINTLiteral EOF ) + // InternalSolverLanguage.g:182:2: iv_ruleINTLiteral= ruleINTLiteral EOF + { + newCompositeNode(grammarAccess.getINTLiteralRule()); + pushFollow(FOLLOW_1); + iv_ruleINTLiteral=ruleINTLiteral(); + + state._fsp--; + + current =iv_ruleINTLiteral.getText(); + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleINTLiteral" + + + // $ANTLR start "ruleINTLiteral" + // InternalSolverLanguage.g:188:1: ruleINTLiteral returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : ( (kw= '-' )? this_INT_1= RULE_INT ) ; + public final AntlrDatatypeRuleToken ruleINTLiteral() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + Token this_INT_1=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:194:2: ( ( (kw= '-' )? this_INT_1= RULE_INT ) ) + // InternalSolverLanguage.g:195:2: ( (kw= '-' )? this_INT_1= RULE_INT ) + { + // InternalSolverLanguage.g:195:2: ( (kw= '-' )? this_INT_1= RULE_INT ) + // InternalSolverLanguage.g:196:3: (kw= '-' )? this_INT_1= RULE_INT + { + // InternalSolverLanguage.g:196:3: (kw= '-' )? + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0==11) ) { + alt4=1; + } + switch (alt4) { + case 1 : + // InternalSolverLanguage.g:197:4: kw= '-' + { + kw=(Token)match(input,11,FOLLOW_4); + + current.merge(kw); + newLeafNode(kw, grammarAccess.getINTLiteralAccess().getHyphenMinusKeyword_0()); + + + } + break; + + } + + this_INT_1=(Token)match(input,RULE_INT,FOLLOW_2); + + current.merge(this_INT_1); + + + newLeafNode(this_INT_1, grammarAccess.getINTLiteralAccess().getINTTerminalRuleCall_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleINTLiteral" + + + // $ANTLR start "entryRuleBooleanValue" + // InternalSolverLanguage.g:214:1: entryRuleBooleanValue returns [EObject current=null] : iv_ruleBooleanValue= ruleBooleanValue EOF ; + public final EObject entryRuleBooleanValue() throws RecognitionException { + EObject current = null; + + EObject iv_ruleBooleanValue = null; + + + try { + // InternalSolverLanguage.g:214:53: (iv_ruleBooleanValue= ruleBooleanValue EOF ) + // InternalSolverLanguage.g:215:2: iv_ruleBooleanValue= ruleBooleanValue EOF + { + newCompositeNode(grammarAccess.getBooleanValueRule()); + pushFollow(FOLLOW_1); + iv_ruleBooleanValue=ruleBooleanValue(); + + state._fsp--; + + current =iv_ruleBooleanValue; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleBooleanValue" + + + // $ANTLR start "ruleBooleanValue" + // InternalSolverLanguage.g:221:1: ruleBooleanValue returns [EObject current=null] : ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) ; + public final EObject ruleBooleanValue() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:227:2: ( ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) ) + // InternalSolverLanguage.g:228:2: ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) + { + // InternalSolverLanguage.g:228:2: ( ( () otherlv_1= 'true' ) | (otherlv_2= 'false' () ) ) + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0==13) ) { + alt5=1; + } + else if ( (LA5_0==14) ) { + alt5=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + + throw nvae; + } + switch (alt5) { + case 1 : + // InternalSolverLanguage.g:229:3: ( () otherlv_1= 'true' ) + { + // InternalSolverLanguage.g:229:3: ( () otherlv_1= 'true' ) + // InternalSolverLanguage.g:230:4: () otherlv_1= 'true' + { + // InternalSolverLanguage.g:230:4: () + // InternalSolverLanguage.g:231:5: + { + + current = forceCreateModelElement( + grammarAccess.getBooleanValueAccess().getBooleanTrueAction_0_0(), + current); + + + } + + otherlv_1=(Token)match(input,13,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getBooleanValueAccess().getTrueKeyword_0_1()); + + + } + + + } + break; + case 2 : + // InternalSolverLanguage.g:243:3: (otherlv_2= 'false' () ) + { + // InternalSolverLanguage.g:243:3: (otherlv_2= 'false' () ) + // InternalSolverLanguage.g:244:4: otherlv_2= 'false' () + { + otherlv_2=(Token)match(input,14,FOLLOW_2); + + newLeafNode(otherlv_2, grammarAccess.getBooleanValueAccess().getFalseKeyword_1_0()); + + // InternalSolverLanguage.g:248:4: () + // InternalSolverLanguage.g:249:5: + { + + current = forceCreateModelElement( + grammarAccess.getBooleanValueAccess().getBooleanFalseAction_1_1(), + current); + + + } + + + } + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleBooleanValue" + + + // $ANTLR start "entryRuleTruthValue" + // InternalSolverLanguage.g:260:1: entryRuleTruthValue returns [EObject current=null] : iv_ruleTruthValue= ruleTruthValue EOF ; + public final EObject entryRuleTruthValue() throws RecognitionException { + EObject current = null; + + EObject iv_ruleTruthValue = null; + + + try { + // InternalSolverLanguage.g:260:51: (iv_ruleTruthValue= ruleTruthValue EOF ) + // InternalSolverLanguage.g:261:2: iv_ruleTruthValue= ruleTruthValue EOF + { + newCompositeNode(grammarAccess.getTruthValueRule()); + pushFollow(FOLLOW_1); + iv_ruleTruthValue=ruleTruthValue(); + + state._fsp--; + + current =iv_ruleTruthValue; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleTruthValue" + + + // $ANTLR start "ruleTruthValue" + // InternalSolverLanguage.g:267:1: ruleTruthValue returns [EObject current=null] : ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) ; + public final EObject ruleTruthValue() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_7=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:273:2: ( ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) ) + // InternalSolverLanguage.g:274:2: ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) + { + // InternalSolverLanguage.g:274:2: ( ( () otherlv_1= 'true' ) | ( () otherlv_3= 'false' ) | ( () otherlv_5= 'unknown' ) | ( () otherlv_7= 'error' ) ) + int alt6=4; + switch ( input.LA(1) ) { + case 13: + { + alt6=1; + } + break; + case 14: + { + alt6=2; + } + break; + case 15: + { + alt6=3; + } + break; + case 16: + { + alt6=4; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; + } + + switch (alt6) { + case 1 : + // InternalSolverLanguage.g:275:3: ( () otherlv_1= 'true' ) + { + // InternalSolverLanguage.g:275:3: ( () otherlv_1= 'true' ) + // InternalSolverLanguage.g:276:4: () otherlv_1= 'true' + { + // InternalSolverLanguage.g:276:4: () + // InternalSolverLanguage.g:277:5: + { + + current = forceCreateModelElement( + grammarAccess.getTruthValueAccess().getTrueAction_0_0(), + current); + + + } + + otherlv_1=(Token)match(input,13,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getTruthValueAccess().getTrueKeyword_0_1()); + + + } + + + } + break; + case 2 : + // InternalSolverLanguage.g:289:3: ( () otherlv_3= 'false' ) + { + // InternalSolverLanguage.g:289:3: ( () otherlv_3= 'false' ) + // InternalSolverLanguage.g:290:4: () otherlv_3= 'false' + { + // InternalSolverLanguage.g:290:4: () + // InternalSolverLanguage.g:291:5: + { + + current = forceCreateModelElement( + grammarAccess.getTruthValueAccess().getFalseAction_1_0(), + current); + + + } + + otherlv_3=(Token)match(input,14,FOLLOW_2); + + newLeafNode(otherlv_3, grammarAccess.getTruthValueAccess().getFalseKeyword_1_1()); + + + } + + + } + break; + case 3 : + // InternalSolverLanguage.g:303:3: ( () otherlv_5= 'unknown' ) + { + // InternalSolverLanguage.g:303:3: ( () otherlv_5= 'unknown' ) + // InternalSolverLanguage.g:304:4: () otherlv_5= 'unknown' + { + // InternalSolverLanguage.g:304:4: () + // InternalSolverLanguage.g:305:5: + { + + current = forceCreateModelElement( + grammarAccess.getTruthValueAccess().getUnknownAction_2_0(), + current); + + + } + + otherlv_5=(Token)match(input,15,FOLLOW_2); + + newLeafNode(otherlv_5, grammarAccess.getTruthValueAccess().getUnknownKeyword_2_1()); + + + } + + + } + break; + case 4 : + // InternalSolverLanguage.g:317:3: ( () otherlv_7= 'error' ) + { + // InternalSolverLanguage.g:317:3: ( () otherlv_7= 'error' ) + // InternalSolverLanguage.g:318:4: () otherlv_7= 'error' + { + // InternalSolverLanguage.g:318:4: () + // InternalSolverLanguage.g:319:5: + { + + current = forceCreateModelElement( + grammarAccess.getTruthValueAccess().getErrorAction_3_0(), + current); + + + } + + otherlv_7=(Token)match(input,16,FOLLOW_2); + + newLeafNode(otherlv_7, grammarAccess.getTruthValueAccess().getErrorKeyword_3_1()); + + + } + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleTruthValue" + + + // $ANTLR start "entryRuleInterpretation" + // InternalSolverLanguage.g:334:1: entryRuleInterpretation returns [EObject current=null] : iv_ruleInterpretation= ruleInterpretation EOF ; + public final EObject entryRuleInterpretation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleInterpretation = null; + + + try { + // InternalSolverLanguage.g:334:55: (iv_ruleInterpretation= ruleInterpretation EOF ) + // InternalSolverLanguage.g:335:2: iv_ruleInterpretation= ruleInterpretation EOF + { + newCompositeNode(grammarAccess.getInterpretationRule()); + pushFollow(FOLLOW_1); + iv_ruleInterpretation=ruleInterpretation(); + + state._fsp--; + + current =iv_ruleInterpretation; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleInterpretation" + + + // $ANTLR start "ruleInterpretation" + // InternalSolverLanguage.g:341:1: ruleInterpretation returns [EObject current=null] : (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) ; + public final EObject ruleInterpretation() throws RecognitionException { + EObject current = null; + + EObject this_BasicInterpretation_0 = null; + + EObject this_DefaultInterpretation_1 = null; + + EObject this_CDInterpretation_2 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:347:2: ( (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) ) + // InternalSolverLanguage.g:348:2: (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) + { + // InternalSolverLanguage.g:348:2: (this_BasicInterpretation_0= ruleBasicInterpretation | this_DefaultInterpretation_1= ruleDefaultInterpretation | this_CDInterpretation_2= ruleCDInterpretation ) + int alt7=3; + switch ( input.LA(1) ) { + case RULE_ID: + case 20: + case 21: + case 22: + case 23: + case 24: + case 25: + { + alt7=1; + } + break; + case 31: + { + alt7=2; + } + break; + case 32: + case 37: + case 38: + { + alt7=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); + + throw nvae; + } + + switch (alt7) { + case 1 : + // InternalSolverLanguage.g:349:3: this_BasicInterpretation_0= ruleBasicInterpretation + { + + newCompositeNode(grammarAccess.getInterpretationAccess().getBasicInterpretationParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_BasicInterpretation_0=ruleBasicInterpretation(); + + state._fsp--; + + + current = this_BasicInterpretation_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalSolverLanguage.g:358:3: this_DefaultInterpretation_1= ruleDefaultInterpretation + { + + newCompositeNode(grammarAccess.getInterpretationAccess().getDefaultInterpretationParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_DefaultInterpretation_1=ruleDefaultInterpretation(); + + state._fsp--; + + + current = this_DefaultInterpretation_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalSolverLanguage.g:367:3: this_CDInterpretation_2= ruleCDInterpretation + { + + newCompositeNode(grammarAccess.getInterpretationAccess().getCDInterpretationParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_CDInterpretation_2=ruleCDInterpretation(); + + state._fsp--; + + + current = this_CDInterpretation_2; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleInterpretation" + + + // $ANTLR start "entryRuleBasicInterpretation" + // InternalSolverLanguage.g:379:1: entryRuleBasicInterpretation returns [EObject current=null] : iv_ruleBasicInterpretation= ruleBasicInterpretation EOF ; + public final EObject entryRuleBasicInterpretation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleBasicInterpretation = null; + + + try { + // InternalSolverLanguage.g:379:60: (iv_ruleBasicInterpretation= ruleBasicInterpretation EOF ) + // InternalSolverLanguage.g:380:2: iv_ruleBasicInterpretation= ruleBasicInterpretation EOF + { + newCompositeNode(grammarAccess.getBasicInterpretationRule()); + pushFollow(FOLLOW_1); + iv_ruleBasicInterpretation=ruleBasicInterpretation(); + + state._fsp--; + + current =iv_ruleBasicInterpretation; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleBasicInterpretation" + + + // $ANTLR start "ruleBasicInterpretation" + // InternalSolverLanguage.g:386:1: ruleBasicInterpretation returns [EObject current=null] : ( ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) ) ; + public final EObject ruleBasicInterpretation() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_4=null; + EObject lv_symbol_0_0 = null; + + EObject lv_objects_2_0 = null; + + EObject lv_value_5_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:392:2: ( ( ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) ) ) + // InternalSolverLanguage.g:393:2: ( ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) ) + { + // InternalSolverLanguage.g:393:2: ( ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) ) + // InternalSolverLanguage.g:394:3: ( (lv_symbol_0_0= ruleSymbol ) ) otherlv_1= '(' ( (lv_objects_2_0= ruleComplexObject ) )* otherlv_3= ')' otherlv_4= ':' ( (lv_value_5_0= ruleTruthValue ) ) + { + // InternalSolverLanguage.g:394:3: ( (lv_symbol_0_0= ruleSymbol ) ) + // InternalSolverLanguage.g:395:4: (lv_symbol_0_0= ruleSymbol ) + { + // InternalSolverLanguage.g:395:4: (lv_symbol_0_0= ruleSymbol ) + // InternalSolverLanguage.g:396:5: lv_symbol_0_0= ruleSymbol + { + + newCompositeNode(grammarAccess.getBasicInterpretationAccess().getSymbolSymbolParserRuleCall_0_0()); + + pushFollow(FOLLOW_6); + lv_symbol_0_0=ruleSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); + } + set( + current, + "symbol", + lv_symbol_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_1=(Token)match(input,17,FOLLOW_7); + + newLeafNode(otherlv_1, grammarAccess.getBasicInterpretationAccess().getLeftParenthesisKeyword_1()); + + // InternalSolverLanguage.g:417:3: ( (lv_objects_2_0= ruleComplexObject ) )* + loop8: + do { + int alt8=2; + int LA8_0 = input.LA(1); + + if ( ((LA8_0>=RULE_INT && LA8_0<=RULE_STRING)||LA8_0==11||(LA8_0>=13 && LA8_0<=14)||LA8_0==19||LA8_0==26||LA8_0==30) ) { + alt8=1; + } + + + switch (alt8) { + case 1 : + // InternalSolverLanguage.g:418:4: (lv_objects_2_0= ruleComplexObject ) + { + // InternalSolverLanguage.g:418:4: (lv_objects_2_0= ruleComplexObject ) + // InternalSolverLanguage.g:419:5: lv_objects_2_0= ruleComplexObject + { + + newCompositeNode(grammarAccess.getBasicInterpretationAccess().getObjectsComplexObjectParserRuleCall_2_0()); + + pushFollow(FOLLOW_7); + lv_objects_2_0=ruleComplexObject(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); + } + add( + current, + "objects", + lv_objects_2_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop8; + } + } while (true); + + otherlv_3=(Token)match(input,18,FOLLOW_8); + + newLeafNode(otherlv_3, grammarAccess.getBasicInterpretationAccess().getRightParenthesisKeyword_3()); + + otherlv_4=(Token)match(input,19,FOLLOW_9); + + newLeafNode(otherlv_4, grammarAccess.getBasicInterpretationAccess().getColonKeyword_4()); + + // InternalSolverLanguage.g:444:3: ( (lv_value_5_0= ruleTruthValue ) ) + // InternalSolverLanguage.g:445:4: (lv_value_5_0= ruleTruthValue ) + { + // InternalSolverLanguage.g:445:4: (lv_value_5_0= ruleTruthValue ) + // InternalSolverLanguage.g:446:5: lv_value_5_0= ruleTruthValue + { + + newCompositeNode(grammarAccess.getBasicInterpretationAccess().getValueTruthValueParserRuleCall_5_0()); + + pushFollow(FOLLOW_2); + lv_value_5_0=ruleTruthValue(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getBasicInterpretationRule()); + } + set( + current, + "value", + lv_value_5_0, + "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleBasicInterpretation" + + + // $ANTLR start "entryRuleSymbol" + // InternalSolverLanguage.g:467:1: entryRuleSymbol returns [EObject current=null] : iv_ruleSymbol= ruleSymbol EOF ; + public final EObject entryRuleSymbol() throws RecognitionException { + EObject current = null; + + EObject iv_ruleSymbol = null; + + + try { + // InternalSolverLanguage.g:467:47: (iv_ruleSymbol= ruleSymbol EOF ) + // InternalSolverLanguage.g:468:2: iv_ruleSymbol= ruleSymbol EOF + { + newCompositeNode(grammarAccess.getSymbolRule()); + pushFollow(FOLLOW_1); + iv_ruleSymbol=ruleSymbol(); + + state._fsp--; + + current =iv_ruleSymbol; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleSymbol" + + + // $ANTLR start "ruleSymbol" + // InternalSolverLanguage.g:474:1: ruleSymbol returns [EObject current=null] : (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) ; + public final EObject ruleSymbol() throws RecognitionException { + EObject current = null; + + EObject this_ModelSymbol_0 = null; + + EObject this_PartialitySymbol_1 = null; + + EObject this_DataSymbol_2 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:480:2: ( (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) ) + // InternalSolverLanguage.g:481:2: (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) + { + // InternalSolverLanguage.g:481:2: (this_ModelSymbol_0= ruleModelSymbol | this_PartialitySymbol_1= rulePartialitySymbol | this_DataSymbol_2= ruleDataSymbol ) + int alt9=3; + switch ( input.LA(1) ) { + case RULE_ID: + { + alt9=1; + } + break; + case 20: + case 21: + { + alt9=2; + } + break; + case 22: + case 23: + case 24: + case 25: + { + alt9=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + + throw nvae; + } + + switch (alt9) { + case 1 : + // InternalSolverLanguage.g:482:3: this_ModelSymbol_0= ruleModelSymbol + { + + newCompositeNode(grammarAccess.getSymbolAccess().getModelSymbolParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_ModelSymbol_0=ruleModelSymbol(); + + state._fsp--; + + + current = this_ModelSymbol_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalSolverLanguage.g:491:3: this_PartialitySymbol_1= rulePartialitySymbol + { + + newCompositeNode(grammarAccess.getSymbolAccess().getPartialitySymbolParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_PartialitySymbol_1=rulePartialitySymbol(); + + state._fsp--; + + + current = this_PartialitySymbol_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalSolverLanguage.g:500:3: this_DataSymbol_2= ruleDataSymbol + { + + newCompositeNode(grammarAccess.getSymbolAccess().getDataSymbolParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_DataSymbol_2=ruleDataSymbol(); + + state._fsp--; + + + current = this_DataSymbol_2; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleSymbol" + + + // $ANTLR start "entryRuleModelSymbol" + // InternalSolverLanguage.g:512:1: entryRuleModelSymbol returns [EObject current=null] : iv_ruleModelSymbol= ruleModelSymbol EOF ; + public final EObject entryRuleModelSymbol() throws RecognitionException { + EObject current = null; + + EObject iv_ruleModelSymbol = null; + + + try { + // InternalSolverLanguage.g:512:52: (iv_ruleModelSymbol= ruleModelSymbol EOF ) + // InternalSolverLanguage.g:513:2: iv_ruleModelSymbol= ruleModelSymbol EOF + { + newCompositeNode(grammarAccess.getModelSymbolRule()); + pushFollow(FOLLOW_1); + iv_ruleModelSymbol=ruleModelSymbol(); + + state._fsp--; + + current =iv_ruleModelSymbol; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleModelSymbol" + + + // $ANTLR start "ruleModelSymbol" + // InternalSolverLanguage.g:519:1: ruleModelSymbol returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; + public final EObject ruleModelSymbol() throws RecognitionException { + EObject current = null; + + Token lv_name_0_0=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:525:2: ( ( (lv_name_0_0= RULE_ID ) ) ) + // InternalSolverLanguage.g:526:2: ( (lv_name_0_0= RULE_ID ) ) + { + // InternalSolverLanguage.g:526:2: ( (lv_name_0_0= RULE_ID ) ) + // InternalSolverLanguage.g:527:3: (lv_name_0_0= RULE_ID ) + { + // InternalSolverLanguage.g:527:3: (lv_name_0_0= RULE_ID ) + // InternalSolverLanguage.g:528:4: lv_name_0_0= RULE_ID + { + lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); + + newLeafNode(lv_name_0_0, grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getModelSymbolRule()); + } + setWithLastConsumed( + current, + "name", + lv_name_0_0, + "org.eclipse.xtext.common.Terminals.ID"); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleModelSymbol" + + + // $ANTLR start "entryRulePartialitySymbol" + // InternalSolverLanguage.g:547:1: entryRulePartialitySymbol returns [EObject current=null] : iv_rulePartialitySymbol= rulePartialitySymbol EOF ; + public final EObject entryRulePartialitySymbol() throws RecognitionException { + EObject current = null; + + EObject iv_rulePartialitySymbol = null; + + + try { + // InternalSolverLanguage.g:547:57: (iv_rulePartialitySymbol= rulePartialitySymbol EOF ) + // InternalSolverLanguage.g:548:2: iv_rulePartialitySymbol= rulePartialitySymbol EOF + { + newCompositeNode(grammarAccess.getPartialitySymbolRule()); + pushFollow(FOLLOW_1); + iv_rulePartialitySymbol=rulePartialitySymbol(); + + state._fsp--; + + current =iv_rulePartialitySymbol; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePartialitySymbol" + + + // $ANTLR start "rulePartialitySymbol" + // InternalSolverLanguage.g:554:1: rulePartialitySymbol returns [EObject current=null] : (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) ; + public final EObject rulePartialitySymbol() throws RecognitionException { + EObject current = null; + + EObject this_ExistSymbol_0 = null; + + EObject this_EqualsSymbol_1 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:560:2: ( (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) ) + // InternalSolverLanguage.g:561:2: (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) + { + // InternalSolverLanguage.g:561:2: (this_ExistSymbol_0= ruleExistSymbol | this_EqualsSymbol_1= ruleEqualsSymbol ) + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0==20) ) { + alt10=1; + } + else if ( (LA10_0==21) ) { + alt10=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 10, 0, input); + + throw nvae; + } + switch (alt10) { + case 1 : + // InternalSolverLanguage.g:562:3: this_ExistSymbol_0= ruleExistSymbol + { + + newCompositeNode(grammarAccess.getPartialitySymbolAccess().getExistSymbolParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_ExistSymbol_0=ruleExistSymbol(); + + state._fsp--; + + + current = this_ExistSymbol_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalSolverLanguage.g:571:3: this_EqualsSymbol_1= ruleEqualsSymbol + { + + newCompositeNode(grammarAccess.getPartialitySymbolAccess().getEqualsSymbolParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_EqualsSymbol_1=ruleEqualsSymbol(); + + state._fsp--; + + + current = this_EqualsSymbol_1; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePartialitySymbol" + + + // $ANTLR start "entryRuleExistSymbol" + // InternalSolverLanguage.g:583:1: entryRuleExistSymbol returns [EObject current=null] : iv_ruleExistSymbol= ruleExistSymbol EOF ; + public final EObject entryRuleExistSymbol() throws RecognitionException { + EObject current = null; + + EObject iv_ruleExistSymbol = null; + + + try { + // InternalSolverLanguage.g:583:52: (iv_ruleExistSymbol= ruleExistSymbol EOF ) + // InternalSolverLanguage.g:584:2: iv_ruleExistSymbol= ruleExistSymbol EOF + { + newCompositeNode(grammarAccess.getExistSymbolRule()); + pushFollow(FOLLOW_1); + iv_ruleExistSymbol=ruleExistSymbol(); + + state._fsp--; + + current =iv_ruleExistSymbol; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleExistSymbol" + + + // $ANTLR start "ruleExistSymbol" + // InternalSolverLanguage.g:590:1: ruleExistSymbol returns [EObject current=null] : (otherlv_0= 'exists' () ) ; + public final EObject ruleExistSymbol() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:596:2: ( (otherlv_0= 'exists' () ) ) + // InternalSolverLanguage.g:597:2: (otherlv_0= 'exists' () ) + { + // InternalSolverLanguage.g:597:2: (otherlv_0= 'exists' () ) + // InternalSolverLanguage.g:598:3: otherlv_0= 'exists' () + { + otherlv_0=(Token)match(input,20,FOLLOW_2); + + newLeafNode(otherlv_0, grammarAccess.getExistSymbolAccess().getExistsKeyword_0()); + + // InternalSolverLanguage.g:602:3: () + // InternalSolverLanguage.g:603:4: + { + + current = forceCreateModelElement( + grammarAccess.getExistSymbolAccess().getExistSymbolAction_1(), + current); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleExistSymbol" + + + // $ANTLR start "entryRuleEqualsSymbol" + // InternalSolverLanguage.g:613:1: entryRuleEqualsSymbol returns [EObject current=null] : iv_ruleEqualsSymbol= ruleEqualsSymbol EOF ; + public final EObject entryRuleEqualsSymbol() throws RecognitionException { + EObject current = null; + + EObject iv_ruleEqualsSymbol = null; + + + try { + // InternalSolverLanguage.g:613:53: (iv_ruleEqualsSymbol= ruleEqualsSymbol EOF ) + // InternalSolverLanguage.g:614:2: iv_ruleEqualsSymbol= ruleEqualsSymbol EOF + { + newCompositeNode(grammarAccess.getEqualsSymbolRule()); + pushFollow(FOLLOW_1); + iv_ruleEqualsSymbol=ruleEqualsSymbol(); + + state._fsp--; + + current =iv_ruleEqualsSymbol; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleEqualsSymbol" + + + // $ANTLR start "ruleEqualsSymbol" + // InternalSolverLanguage.g:620:1: ruleEqualsSymbol returns [EObject current=null] : (otherlv_0= 'equals' () ) ; + public final EObject ruleEqualsSymbol() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:626:2: ( (otherlv_0= 'equals' () ) ) + // InternalSolverLanguage.g:627:2: (otherlv_0= 'equals' () ) + { + // InternalSolverLanguage.g:627:2: (otherlv_0= 'equals' () ) + // InternalSolverLanguage.g:628:3: otherlv_0= 'equals' () + { + otherlv_0=(Token)match(input,21,FOLLOW_2); + + newLeafNode(otherlv_0, grammarAccess.getEqualsSymbolAccess().getEqualsKeyword_0()); + + // InternalSolverLanguage.g:632:3: () + // InternalSolverLanguage.g:633:4: + { + + current = forceCreateModelElement( + grammarAccess.getEqualsSymbolAccess().getEqualsSymbolAction_1(), + current); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleEqualsSymbol" + + + // $ANTLR start "entryRuleDataSymbol" + // InternalSolverLanguage.g:643:1: entryRuleDataSymbol returns [EObject current=null] : iv_ruleDataSymbol= ruleDataSymbol EOF ; + public final EObject entryRuleDataSymbol() throws RecognitionException { + EObject current = null; + + EObject iv_ruleDataSymbol = null; + + + try { + // InternalSolverLanguage.g:643:51: (iv_ruleDataSymbol= ruleDataSymbol EOF ) + // InternalSolverLanguage.g:644:2: iv_ruleDataSymbol= ruleDataSymbol EOF + { + newCompositeNode(grammarAccess.getDataSymbolRule()); + pushFollow(FOLLOW_1); + iv_ruleDataSymbol=ruleDataSymbol(); + + state._fsp--; + + current =iv_ruleDataSymbol; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleDataSymbol" + + + // $ANTLR start "ruleDataSymbol" + // InternalSolverLanguage.g:650:1: ruleDataSymbol returns [EObject current=null] : (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) ; + public final EObject ruleDataSymbol() throws RecognitionException { + EObject current = null; + + EObject this_BooleanSymbol_0 = null; + + EObject this_IntegerSymbol_1 = null; + + EObject this_RealSymbol_2 = null; + + EObject this_StringSymbol_3 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:656:2: ( (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) ) + // InternalSolverLanguage.g:657:2: (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) + { + // InternalSolverLanguage.g:657:2: (this_BooleanSymbol_0= ruleBooleanSymbol | this_IntegerSymbol_1= ruleIntegerSymbol | this_RealSymbol_2= ruleRealSymbol | this_StringSymbol_3= ruleStringSymbol ) + int alt11=4; + switch ( input.LA(1) ) { + case 22: + { + alt11=1; + } + break; + case 23: + { + alt11=2; + } + break; + case 24: + { + alt11=3; + } + break; + case 25: + { + alt11=4; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 11, 0, input); + + throw nvae; + } + + switch (alt11) { + case 1 : + // InternalSolverLanguage.g:658:3: this_BooleanSymbol_0= ruleBooleanSymbol + { + + newCompositeNode(grammarAccess.getDataSymbolAccess().getBooleanSymbolParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_BooleanSymbol_0=ruleBooleanSymbol(); + + state._fsp--; + + + current = this_BooleanSymbol_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalSolverLanguage.g:667:3: this_IntegerSymbol_1= ruleIntegerSymbol + { + + newCompositeNode(grammarAccess.getDataSymbolAccess().getIntegerSymbolParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_IntegerSymbol_1=ruleIntegerSymbol(); + + state._fsp--; + + + current = this_IntegerSymbol_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalSolverLanguage.g:676:3: this_RealSymbol_2= ruleRealSymbol + { + + newCompositeNode(grammarAccess.getDataSymbolAccess().getRealSymbolParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_RealSymbol_2=ruleRealSymbol(); + + state._fsp--; + + + current = this_RealSymbol_2; + afterParserOrEnumRuleCall(); + + + } + break; + case 4 : + // InternalSolverLanguage.g:685:3: this_StringSymbol_3= ruleStringSymbol + { + + newCompositeNode(grammarAccess.getDataSymbolAccess().getStringSymbolParserRuleCall_3()); + + pushFollow(FOLLOW_2); + this_StringSymbol_3=ruleStringSymbol(); + + state._fsp--; + + + current = this_StringSymbol_3; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleDataSymbol" + + + // $ANTLR start "entryRuleBooleanSymbol" + // InternalSolverLanguage.g:697:1: entryRuleBooleanSymbol returns [EObject current=null] : iv_ruleBooleanSymbol= ruleBooleanSymbol EOF ; + public final EObject entryRuleBooleanSymbol() throws RecognitionException { + EObject current = null; + + EObject iv_ruleBooleanSymbol = null; + + + try { + // InternalSolverLanguage.g:697:54: (iv_ruleBooleanSymbol= ruleBooleanSymbol EOF ) + // InternalSolverLanguage.g:698:2: iv_ruleBooleanSymbol= ruleBooleanSymbol EOF + { + newCompositeNode(grammarAccess.getBooleanSymbolRule()); + pushFollow(FOLLOW_1); + iv_ruleBooleanSymbol=ruleBooleanSymbol(); + + state._fsp--; + + current =iv_ruleBooleanSymbol; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleBooleanSymbol" + + + // $ANTLR start "ruleBooleanSymbol" + // InternalSolverLanguage.g:704:1: ruleBooleanSymbol returns [EObject current=null] : (otherlv_0= 'bool' () ) ; + public final EObject ruleBooleanSymbol() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:710:2: ( (otherlv_0= 'bool' () ) ) + // InternalSolverLanguage.g:711:2: (otherlv_0= 'bool' () ) + { + // InternalSolverLanguage.g:711:2: (otherlv_0= 'bool' () ) + // InternalSolverLanguage.g:712:3: otherlv_0= 'bool' () + { + otherlv_0=(Token)match(input,22,FOLLOW_2); + + newLeafNode(otherlv_0, grammarAccess.getBooleanSymbolAccess().getBoolKeyword_0()); + + // InternalSolverLanguage.g:716:3: () + // InternalSolverLanguage.g:717:4: + { + + current = forceCreateModelElement( + grammarAccess.getBooleanSymbolAccess().getBooleanSymbolAction_1(), + current); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleBooleanSymbol" + + + // $ANTLR start "entryRuleIntegerSymbol" + // InternalSolverLanguage.g:727:1: entryRuleIntegerSymbol returns [EObject current=null] : iv_ruleIntegerSymbol= ruleIntegerSymbol EOF ; + public final EObject entryRuleIntegerSymbol() throws RecognitionException { + EObject current = null; + + EObject iv_ruleIntegerSymbol = null; + + + try { + // InternalSolverLanguage.g:727:54: (iv_ruleIntegerSymbol= ruleIntegerSymbol EOF ) + // InternalSolverLanguage.g:728:2: iv_ruleIntegerSymbol= ruleIntegerSymbol EOF + { + newCompositeNode(grammarAccess.getIntegerSymbolRule()); + pushFollow(FOLLOW_1); + iv_ruleIntegerSymbol=ruleIntegerSymbol(); + + state._fsp--; + + current =iv_ruleIntegerSymbol; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleIntegerSymbol" + + + // $ANTLR start "ruleIntegerSymbol" + // InternalSolverLanguage.g:734:1: ruleIntegerSymbol returns [EObject current=null] : (otherlv_0= 'int' () ) ; + public final EObject ruleIntegerSymbol() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:740:2: ( (otherlv_0= 'int' () ) ) + // InternalSolverLanguage.g:741:2: (otherlv_0= 'int' () ) + { + // InternalSolverLanguage.g:741:2: (otherlv_0= 'int' () ) + // InternalSolverLanguage.g:742:3: otherlv_0= 'int' () + { + otherlv_0=(Token)match(input,23,FOLLOW_2); + + newLeafNode(otherlv_0, grammarAccess.getIntegerSymbolAccess().getIntKeyword_0()); + + // InternalSolverLanguage.g:746:3: () + // InternalSolverLanguage.g:747:4: + { + + current = forceCreateModelElement( + grammarAccess.getIntegerSymbolAccess().getIntegerSymbolAction_1(), + current); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleIntegerSymbol" + + + // $ANTLR start "entryRuleRealSymbol" + // InternalSolverLanguage.g:757:1: entryRuleRealSymbol returns [EObject current=null] : iv_ruleRealSymbol= ruleRealSymbol EOF ; + public final EObject entryRuleRealSymbol() throws RecognitionException { + EObject current = null; + + EObject iv_ruleRealSymbol = null; + + + try { + // InternalSolverLanguage.g:757:51: (iv_ruleRealSymbol= ruleRealSymbol EOF ) + // InternalSolverLanguage.g:758:2: iv_ruleRealSymbol= ruleRealSymbol EOF + { + newCompositeNode(grammarAccess.getRealSymbolRule()); + pushFollow(FOLLOW_1); + iv_ruleRealSymbol=ruleRealSymbol(); + + state._fsp--; + + current =iv_ruleRealSymbol; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleRealSymbol" + + + // $ANTLR start "ruleRealSymbol" + // InternalSolverLanguage.g:764:1: ruleRealSymbol returns [EObject current=null] : (otherlv_0= 'real' () ) ; + public final EObject ruleRealSymbol() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:770:2: ( (otherlv_0= 'real' () ) ) + // InternalSolverLanguage.g:771:2: (otherlv_0= 'real' () ) + { + // InternalSolverLanguage.g:771:2: (otherlv_0= 'real' () ) + // InternalSolverLanguage.g:772:3: otherlv_0= 'real' () + { + otherlv_0=(Token)match(input,24,FOLLOW_2); + + newLeafNode(otherlv_0, grammarAccess.getRealSymbolAccess().getRealKeyword_0()); + + // InternalSolverLanguage.g:776:3: () + // InternalSolverLanguage.g:777:4: + { + + current = forceCreateModelElement( + grammarAccess.getRealSymbolAccess().getRealSymbolAction_1(), + current); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleRealSymbol" + + + // $ANTLR start "entryRuleStringSymbol" + // InternalSolverLanguage.g:787:1: entryRuleStringSymbol returns [EObject current=null] : iv_ruleStringSymbol= ruleStringSymbol EOF ; + public final EObject entryRuleStringSymbol() throws RecognitionException { + EObject current = null; + + EObject iv_ruleStringSymbol = null; + + + try { + // InternalSolverLanguage.g:787:53: (iv_ruleStringSymbol= ruleStringSymbol EOF ) + // InternalSolverLanguage.g:788:2: iv_ruleStringSymbol= ruleStringSymbol EOF + { + newCompositeNode(grammarAccess.getStringSymbolRule()); + pushFollow(FOLLOW_1); + iv_ruleStringSymbol=ruleStringSymbol(); + + state._fsp--; + + current =iv_ruleStringSymbol; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleStringSymbol" + + + // $ANTLR start "ruleStringSymbol" + // InternalSolverLanguage.g:794:1: ruleStringSymbol returns [EObject current=null] : (otherlv_0= 'string' () ) ; + public final EObject ruleStringSymbol() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:800:2: ( (otherlv_0= 'string' () ) ) + // InternalSolverLanguage.g:801:2: (otherlv_0= 'string' () ) + { + // InternalSolverLanguage.g:801:2: (otherlv_0= 'string' () ) + // InternalSolverLanguage.g:802:3: otherlv_0= 'string' () + { + otherlv_0=(Token)match(input,25,FOLLOW_2); + + newLeafNode(otherlv_0, grammarAccess.getStringSymbolAccess().getStringKeyword_0()); + + // InternalSolverLanguage.g:806:3: () + // InternalSolverLanguage.g:807:4: + { + + current = forceCreateModelElement( + grammarAccess.getStringSymbolAccess().getStringSymbolAction_1(), + current); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleStringSymbol" + + + // $ANTLR start "entryRuleComplexObject" + // InternalSolverLanguage.g:817:1: entryRuleComplexObject returns [EObject current=null] : iv_ruleComplexObject= ruleComplexObject EOF ; + public final EObject entryRuleComplexObject() throws RecognitionException { + EObject current = null; + + EObject iv_ruleComplexObject = null; + + + try { + // InternalSolverLanguage.g:817:54: (iv_ruleComplexObject= ruleComplexObject EOF ) + // InternalSolverLanguage.g:818:2: iv_ruleComplexObject= ruleComplexObject EOF + { + newCompositeNode(grammarAccess.getComplexObjectRule()); + pushFollow(FOLLOW_1); + iv_ruleComplexObject=ruleComplexObject(); + + state._fsp--; + + current =iv_ruleComplexObject; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleComplexObject" + + + // $ANTLR start "ruleComplexObject" + // InternalSolverLanguage.g:824:1: ruleComplexObject returns [EObject current=null] : (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) ; + public final EObject ruleComplexObject() throws RecognitionException { + EObject current = null; + + EObject this_Object_0 = null; + + EObject this_AllInstances_1 = null; + + EObject this_AllObjects_2 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:830:2: ( (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) ) + // InternalSolverLanguage.g:831:2: (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) + { + // InternalSolverLanguage.g:831:2: (this_Object_0= ruleObject | this_AllInstances_1= ruleAllInstances | this_AllObjects_2= ruleAllObjects ) + int alt12=3; + switch ( input.LA(1) ) { + case RULE_INT: + case RULE_ID: + case RULE_STRING: + case 11: + case 13: + case 14: + case 26: + { + alt12=1; + } + break; + case 19: + { + alt12=2; + } + break; + case 30: + { + alt12=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 12, 0, input); + + throw nvae; + } + + switch (alt12) { + case 1 : + // InternalSolverLanguage.g:832:3: this_Object_0= ruleObject + { + + newCompositeNode(grammarAccess.getComplexObjectAccess().getObjectParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_Object_0=ruleObject(); + + state._fsp--; + + + current = this_Object_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalSolverLanguage.g:841:3: this_AllInstances_1= ruleAllInstances + { + + newCompositeNode(grammarAccess.getComplexObjectAccess().getAllInstancesParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_AllInstances_1=ruleAllInstances(); + + state._fsp--; + + + current = this_AllInstances_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalSolverLanguage.g:850:3: this_AllObjects_2= ruleAllObjects + { + + newCompositeNode(grammarAccess.getComplexObjectAccess().getAllObjectsParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_AllObjects_2=ruleAllObjects(); + + state._fsp--; + + + current = this_AllObjects_2; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleComplexObject" + + + // $ANTLR start "entryRuleObject" + // InternalSolverLanguage.g:862:1: entryRuleObject returns [EObject current=null] : iv_ruleObject= ruleObject EOF ; + public final EObject entryRuleObject() throws RecognitionException { + EObject current = null; + + EObject iv_ruleObject = null; + + + try { + // InternalSolverLanguage.g:862:47: (iv_ruleObject= ruleObject EOF ) + // InternalSolverLanguage.g:863:2: iv_ruleObject= ruleObject EOF + { + newCompositeNode(grammarAccess.getObjectRule()); + pushFollow(FOLLOW_1); + iv_ruleObject=ruleObject(); + + state._fsp--; + + current =iv_ruleObject; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleObject" + + + // $ANTLR start "ruleObject" + // InternalSolverLanguage.g:869:1: ruleObject returns [EObject current=null] : (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) ; + public final EObject ruleObject() throws RecognitionException { + EObject current = null; + + EObject this_NamedObject_0 = null; + + EObject this_UnnamedObject_1 = null; + + EObject this_DataObject_2 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:875:2: ( (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) ) + // InternalSolverLanguage.g:876:2: (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) + { + // InternalSolverLanguage.g:876:2: (this_NamedObject_0= ruleNamedObject | this_UnnamedObject_1= ruleUnnamedObject | this_DataObject_2= ruleDataObject ) + int alt13=3; + switch ( input.LA(1) ) { + case 26: + { + alt13=1; + } + break; + case RULE_ID: + { + alt13=2; + } + break; + case RULE_INT: + case RULE_STRING: + case 11: + case 13: + case 14: + { + alt13=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 13, 0, input); + + throw nvae; + } + + switch (alt13) { + case 1 : + // InternalSolverLanguage.g:877:3: this_NamedObject_0= ruleNamedObject + { + + newCompositeNode(grammarAccess.getObjectAccess().getNamedObjectParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_NamedObject_0=ruleNamedObject(); + + state._fsp--; + + + current = this_NamedObject_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalSolverLanguage.g:886:3: this_UnnamedObject_1= ruleUnnamedObject + { + + newCompositeNode(grammarAccess.getObjectAccess().getUnnamedObjectParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_UnnamedObject_1=ruleUnnamedObject(); + + state._fsp--; + + + current = this_UnnamedObject_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalSolverLanguage.g:895:3: this_DataObject_2= ruleDataObject + { + + newCompositeNode(grammarAccess.getObjectAccess().getDataObjectParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_DataObject_2=ruleDataObject(); + + state._fsp--; + + + current = this_DataObject_2; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleObject" + + + // $ANTLR start "entryRuleNamedObject" + // InternalSolverLanguage.g:907:1: entryRuleNamedObject returns [EObject current=null] : iv_ruleNamedObject= ruleNamedObject EOF ; + public final EObject entryRuleNamedObject() throws RecognitionException { + EObject current = null; + + EObject iv_ruleNamedObject = null; + + + try { + // InternalSolverLanguage.g:907:52: (iv_ruleNamedObject= ruleNamedObject EOF ) + // InternalSolverLanguage.g:908:2: iv_ruleNamedObject= ruleNamedObject EOF + { + newCompositeNode(grammarAccess.getNamedObjectRule()); + pushFollow(FOLLOW_1); + iv_ruleNamedObject=ruleNamedObject(); + + state._fsp--; + + current =iv_ruleNamedObject; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleNamedObject" + + + // $ANTLR start "ruleNamedObject" + // InternalSolverLanguage.g:914:1: ruleNamedObject returns [EObject current=null] : (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) ; + public final EObject ruleNamedObject() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token lv_name_1_0=null; + Token otherlv_2=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:920:2: ( (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) ) + // InternalSolverLanguage.g:921:2: (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) + { + // InternalSolverLanguage.g:921:2: (otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' ) + // InternalSolverLanguage.g:922:3: otherlv_0= '\\'' ( (lv_name_1_0= RULE_ID ) ) otherlv_2= '\\'' + { + otherlv_0=(Token)match(input,26,FOLLOW_10); + + newLeafNode(otherlv_0, grammarAccess.getNamedObjectAccess().getApostropheKeyword_0()); + + // InternalSolverLanguage.g:926:3: ( (lv_name_1_0= RULE_ID ) ) + // InternalSolverLanguage.g:927:4: (lv_name_1_0= RULE_ID ) + { + // InternalSolverLanguage.g:927:4: (lv_name_1_0= RULE_ID ) + // InternalSolverLanguage.g:928:5: lv_name_1_0= RULE_ID + { + lv_name_1_0=(Token)match(input,RULE_ID,FOLLOW_11); + + newLeafNode(lv_name_1_0, grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getNamedObjectRule()); + } + setWithLastConsumed( + current, + "name", + lv_name_1_0, + "org.eclipse.xtext.common.Terminals.ID"); + + + } + + + } + + otherlv_2=(Token)match(input,26,FOLLOW_2); + + newLeafNode(otherlv_2, grammarAccess.getNamedObjectAccess().getApostropheKeyword_2()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleNamedObject" + + + // $ANTLR start "entryRuleUnnamedObject" + // InternalSolverLanguage.g:952:1: entryRuleUnnamedObject returns [EObject current=null] : iv_ruleUnnamedObject= ruleUnnamedObject EOF ; + public final EObject entryRuleUnnamedObject() throws RecognitionException { + EObject current = null; + + EObject iv_ruleUnnamedObject = null; + + + try { + // InternalSolverLanguage.g:952:54: (iv_ruleUnnamedObject= ruleUnnamedObject EOF ) + // InternalSolverLanguage.g:953:2: iv_ruleUnnamedObject= ruleUnnamedObject EOF + { + newCompositeNode(grammarAccess.getUnnamedObjectRule()); + pushFollow(FOLLOW_1); + iv_ruleUnnamedObject=ruleUnnamedObject(); + + state._fsp--; + + current =iv_ruleUnnamedObject; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleUnnamedObject" + + + // $ANTLR start "ruleUnnamedObject" + // InternalSolverLanguage.g:959:1: ruleUnnamedObject returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; + public final EObject ruleUnnamedObject() throws RecognitionException { + EObject current = null; + + Token lv_name_0_0=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:965:2: ( ( (lv_name_0_0= RULE_ID ) ) ) + // InternalSolverLanguage.g:966:2: ( (lv_name_0_0= RULE_ID ) ) + { + // InternalSolverLanguage.g:966:2: ( (lv_name_0_0= RULE_ID ) ) + // InternalSolverLanguage.g:967:3: (lv_name_0_0= RULE_ID ) + { + // InternalSolverLanguage.g:967:3: (lv_name_0_0= RULE_ID ) + // InternalSolverLanguage.g:968:4: lv_name_0_0= RULE_ID + { + lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); + + newLeafNode(lv_name_0_0, grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getUnnamedObjectRule()); + } + setWithLastConsumed( + current, + "name", + lv_name_0_0, + "org.eclipse.xtext.common.Terminals.ID"); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleUnnamedObject" + + + // $ANTLR start "entryRuleDataObject" + // InternalSolverLanguage.g:987:1: entryRuleDataObject returns [EObject current=null] : iv_ruleDataObject= ruleDataObject EOF ; + public final EObject entryRuleDataObject() throws RecognitionException { + EObject current = null; + + EObject iv_ruleDataObject = null; + + + try { + // InternalSolverLanguage.g:987:51: (iv_ruleDataObject= ruleDataObject EOF ) + // InternalSolverLanguage.g:988:2: iv_ruleDataObject= ruleDataObject EOF + { + newCompositeNode(grammarAccess.getDataObjectRule()); + pushFollow(FOLLOW_1); + iv_ruleDataObject=ruleDataObject(); + + state._fsp--; + + current =iv_ruleDataObject; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleDataObject" + + + // $ANTLR start "ruleDataObject" + // InternalSolverLanguage.g:994:1: ruleDataObject returns [EObject current=null] : (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) ; + public final EObject ruleDataObject() throws RecognitionException { + EObject current = null; + + EObject this_BooleanObject_0 = null; + + EObject this_IntObject_1 = null; + + EObject this_RealObject_2 = null; + + EObject this_StringObject_3 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:1000:2: ( (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) ) + // InternalSolverLanguage.g:1001:2: (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) + { + // InternalSolverLanguage.g:1001:2: (this_BooleanObject_0= ruleBooleanObject | this_IntObject_1= ruleIntObject | this_RealObject_2= ruleRealObject | this_StringObject_3= ruleStringObject ) + int alt14=4; + switch ( input.LA(1) ) { + case 13: + case 14: + { + alt14=1; + } + break; + case 11: + { + int LA14_2 = input.LA(2); + + if ( (LA14_2==RULE_INT) ) { + int LA14_3 = input.LA(3); + + if ( (LA14_3==12) ) { + alt14=3; + } + else if ( (LA14_3==EOF||(LA14_3>=RULE_INT && LA14_3<=RULE_STRING)||LA14_3==11||(LA14_3>=13 && LA14_3<=14)||(LA14_3>=18 && LA14_3<=19)||LA14_3==26||LA14_3==30) ) { + alt14=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 14, 3, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 14, 2, input); + + throw nvae; + } + } + break; + case RULE_INT: + { + int LA14_3 = input.LA(2); + + if ( (LA14_3==12) ) { + alt14=3; + } + else if ( (LA14_3==EOF||(LA14_3>=RULE_INT && LA14_3<=RULE_STRING)||LA14_3==11||(LA14_3>=13 && LA14_3<=14)||(LA14_3>=18 && LA14_3<=19)||LA14_3==26||LA14_3==30) ) { + alt14=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 14, 3, input); + + throw nvae; + } + } + break; + case RULE_STRING: + { + alt14=4; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + + throw nvae; + } + + switch (alt14) { + case 1 : + // InternalSolverLanguage.g:1002:3: this_BooleanObject_0= ruleBooleanObject + { + + newCompositeNode(grammarAccess.getDataObjectAccess().getBooleanObjectParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_BooleanObject_0=ruleBooleanObject(); + + state._fsp--; + + + current = this_BooleanObject_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalSolverLanguage.g:1011:3: this_IntObject_1= ruleIntObject + { + + newCompositeNode(grammarAccess.getDataObjectAccess().getIntObjectParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_IntObject_1=ruleIntObject(); + + state._fsp--; + + + current = this_IntObject_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalSolverLanguage.g:1020:3: this_RealObject_2= ruleRealObject + { + + newCompositeNode(grammarAccess.getDataObjectAccess().getRealObjectParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_RealObject_2=ruleRealObject(); + + state._fsp--; + + + current = this_RealObject_2; + afterParserOrEnumRuleCall(); + + + } + break; + case 4 : + // InternalSolverLanguage.g:1029:3: this_StringObject_3= ruleStringObject + { + + newCompositeNode(grammarAccess.getDataObjectAccess().getStringObjectParserRuleCall_3()); + + pushFollow(FOLLOW_2); + this_StringObject_3=ruleStringObject(); + + state._fsp--; + + + current = this_StringObject_3; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleDataObject" + + + // $ANTLR start "entryRuleBooleanObject" + // InternalSolverLanguage.g:1041:1: entryRuleBooleanObject returns [EObject current=null] : iv_ruleBooleanObject= ruleBooleanObject EOF ; + public final EObject entryRuleBooleanObject() throws RecognitionException { + EObject current = null; + + EObject iv_ruleBooleanObject = null; + + + try { + // InternalSolverLanguage.g:1041:54: (iv_ruleBooleanObject= ruleBooleanObject EOF ) + // InternalSolverLanguage.g:1042:2: iv_ruleBooleanObject= ruleBooleanObject EOF + { + newCompositeNode(grammarAccess.getBooleanObjectRule()); + pushFollow(FOLLOW_1); + iv_ruleBooleanObject=ruleBooleanObject(); + + state._fsp--; + + current =iv_ruleBooleanObject; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleBooleanObject" + + + // $ANTLR start "ruleBooleanObject" + // InternalSolverLanguage.g:1048:1: ruleBooleanObject returns [EObject current=null] : ( (lv_value_0_0= ruleBooleanValue ) ) ; + public final EObject ruleBooleanObject() throws RecognitionException { + EObject current = null; + + EObject lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:1054:2: ( ( (lv_value_0_0= ruleBooleanValue ) ) ) + // InternalSolverLanguage.g:1055:2: ( (lv_value_0_0= ruleBooleanValue ) ) + { + // InternalSolverLanguage.g:1055:2: ( (lv_value_0_0= ruleBooleanValue ) ) + // InternalSolverLanguage.g:1056:3: (lv_value_0_0= ruleBooleanValue ) + { + // InternalSolverLanguage.g:1056:3: (lv_value_0_0= ruleBooleanValue ) + // InternalSolverLanguage.g:1057:4: lv_value_0_0= ruleBooleanValue + { + + newCompositeNode(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleBooleanValue(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getBooleanObjectRule()); + } + set( + current, + "value", + lv_value_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleBooleanObject" + + + // $ANTLR start "entryRuleIntObject" + // InternalSolverLanguage.g:1077:1: entryRuleIntObject returns [EObject current=null] : iv_ruleIntObject= ruleIntObject EOF ; + public final EObject entryRuleIntObject() throws RecognitionException { + EObject current = null; + + EObject iv_ruleIntObject = null; + + + try { + // InternalSolverLanguage.g:1077:50: (iv_ruleIntObject= ruleIntObject EOF ) + // InternalSolverLanguage.g:1078:2: iv_ruleIntObject= ruleIntObject EOF + { + newCompositeNode(grammarAccess.getIntObjectRule()); + pushFollow(FOLLOW_1); + iv_ruleIntObject=ruleIntObject(); + + state._fsp--; + + current =iv_ruleIntObject; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleIntObject" + + + // $ANTLR start "ruleIntObject" + // InternalSolverLanguage.g:1084:1: ruleIntObject returns [EObject current=null] : ( (lv_value_0_0= ruleINTLiteral ) ) ; + public final EObject ruleIntObject() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:1090:2: ( ( (lv_value_0_0= ruleINTLiteral ) ) ) + // InternalSolverLanguage.g:1091:2: ( (lv_value_0_0= ruleINTLiteral ) ) + { + // InternalSolverLanguage.g:1091:2: ( (lv_value_0_0= ruleINTLiteral ) ) + // InternalSolverLanguage.g:1092:3: (lv_value_0_0= ruleINTLiteral ) + { + // InternalSolverLanguage.g:1092:3: (lv_value_0_0= ruleINTLiteral ) + // InternalSolverLanguage.g:1093:4: lv_value_0_0= ruleINTLiteral + { + + newCompositeNode(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleINTLiteral(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getIntObjectRule()); + } + set( + current, + "value", + lv_value_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleIntObject" + + + // $ANTLR start "entryRuleRealObject" + // InternalSolverLanguage.g:1113:1: entryRuleRealObject returns [EObject current=null] : iv_ruleRealObject= ruleRealObject EOF ; + public final EObject entryRuleRealObject() throws RecognitionException { + EObject current = null; + + EObject iv_ruleRealObject = null; + + + try { + // InternalSolverLanguage.g:1113:51: (iv_ruleRealObject= ruleRealObject EOF ) + // InternalSolverLanguage.g:1114:2: iv_ruleRealObject= ruleRealObject EOF + { + newCompositeNode(grammarAccess.getRealObjectRule()); + pushFollow(FOLLOW_1); + iv_ruleRealObject=ruleRealObject(); + + state._fsp--; + + current =iv_ruleRealObject; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleRealObject" + + + // $ANTLR start "ruleRealObject" + // InternalSolverLanguage.g:1120:1: ruleRealObject returns [EObject current=null] : ( (lv_value_0_0= ruleREALLiteral ) ) ; + public final EObject ruleRealObject() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_0_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:1126:2: ( ( (lv_value_0_0= ruleREALLiteral ) ) ) + // InternalSolverLanguage.g:1127:2: ( (lv_value_0_0= ruleREALLiteral ) ) + { + // InternalSolverLanguage.g:1127:2: ( (lv_value_0_0= ruleREALLiteral ) ) + // InternalSolverLanguage.g:1128:3: (lv_value_0_0= ruleREALLiteral ) + { + // InternalSolverLanguage.g:1128:3: (lv_value_0_0= ruleREALLiteral ) + // InternalSolverLanguage.g:1129:4: lv_value_0_0= ruleREALLiteral + { + + newCompositeNode(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0()); + + pushFollow(FOLLOW_2); + lv_value_0_0=ruleREALLiteral(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getRealObjectRule()); + } + set( + current, + "value", + lv_value_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleRealObject" + + + // $ANTLR start "entryRuleStringObject" + // InternalSolverLanguage.g:1149:1: entryRuleStringObject returns [EObject current=null] : iv_ruleStringObject= ruleStringObject EOF ; + public final EObject entryRuleStringObject() throws RecognitionException { + EObject current = null; + + EObject iv_ruleStringObject = null; + + + try { + // InternalSolverLanguage.g:1149:53: (iv_ruleStringObject= ruleStringObject EOF ) + // InternalSolverLanguage.g:1150:2: iv_ruleStringObject= ruleStringObject EOF + { + newCompositeNode(grammarAccess.getStringObjectRule()); + pushFollow(FOLLOW_1); + iv_ruleStringObject=ruleStringObject(); + + state._fsp--; + + current =iv_ruleStringObject; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleStringObject" + + + // $ANTLR start "ruleStringObject" + // InternalSolverLanguage.g:1156:1: ruleStringObject returns [EObject current=null] : ( (lv_value_0_0= RULE_STRING ) ) ; + public final EObject ruleStringObject() throws RecognitionException { + EObject current = null; + + Token lv_value_0_0=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:1162:2: ( ( (lv_value_0_0= RULE_STRING ) ) ) + // InternalSolverLanguage.g:1163:2: ( (lv_value_0_0= RULE_STRING ) ) + { + // InternalSolverLanguage.g:1163:2: ( (lv_value_0_0= RULE_STRING ) ) + // InternalSolverLanguage.g:1164:3: (lv_value_0_0= RULE_STRING ) + { + // InternalSolverLanguage.g:1164:3: (lv_value_0_0= RULE_STRING ) + // InternalSolverLanguage.g:1165:4: lv_value_0_0= RULE_STRING + { + lv_value_0_0=(Token)match(input,RULE_STRING,FOLLOW_2); + + newLeafNode(lv_value_0_0, grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getStringObjectRule()); + } + setWithLastConsumed( + current, + "value", + lv_value_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleStringObject" + + + // $ANTLR start "entryRulePredicate" + // InternalSolverLanguage.g:1184:1: entryRulePredicate returns [EObject current=null] : iv_rulePredicate= rulePredicate EOF ; + public final EObject entryRulePredicate() throws RecognitionException { + EObject current = null; + + EObject iv_rulePredicate = null; + + + try { + // InternalSolverLanguage.g:1184:50: (iv_rulePredicate= rulePredicate EOF ) + // InternalSolverLanguage.g:1185:2: iv_rulePredicate= rulePredicate EOF + { + newCompositeNode(grammarAccess.getPredicateRule()); + pushFollow(FOLLOW_1); + iv_rulePredicate=rulePredicate(); + + state._fsp--; + + current =iv_rulePredicate; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePredicate" + + + // $ANTLR start "rulePredicate" + // InternalSolverLanguage.g:1191:1: rulePredicate returns [EObject current=null] : (this_PredicateSymbol_0= rulePredicateSymbol | this_ErrorPredicate_1= ruleErrorPredicate ) ; + public final EObject rulePredicate() throws RecognitionException { + EObject current = null; + + EObject this_PredicateSymbol_0 = null; + + EObject this_ErrorPredicate_1 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:1197:2: ( (this_PredicateSymbol_0= rulePredicateSymbol | this_ErrorPredicate_1= ruleErrorPredicate ) ) + // InternalSolverLanguage.g:1198:2: (this_PredicateSymbol_0= rulePredicateSymbol | this_ErrorPredicate_1= ruleErrorPredicate ) + { + // InternalSolverLanguage.g:1198:2: (this_PredicateSymbol_0= rulePredicateSymbol | this_ErrorPredicate_1= ruleErrorPredicate ) + int alt15=2; + int LA15_0 = input.LA(1); + + if ( (LA15_0==27) ) { + alt15=1; + } + else if ( (LA15_0==16) ) { + alt15=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + + throw nvae; + } + switch (alt15) { + case 1 : + // InternalSolverLanguage.g:1199:3: this_PredicateSymbol_0= rulePredicateSymbol + { + + newCompositeNode(grammarAccess.getPredicateAccess().getPredicateSymbolParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_PredicateSymbol_0=rulePredicateSymbol(); + + state._fsp--; + + + current = this_PredicateSymbol_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalSolverLanguage.g:1208:3: this_ErrorPredicate_1= ruleErrorPredicate + { + + newCompositeNode(grammarAccess.getPredicateAccess().getErrorPredicateParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_ErrorPredicate_1=ruleErrorPredicate(); + + state._fsp--; + + + current = this_ErrorPredicate_1; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePredicate" + + + // $ANTLR start "entryRulePredicateSymbol" + // InternalSolverLanguage.g:1220:1: entryRulePredicateSymbol returns [EObject current=null] : iv_rulePredicateSymbol= rulePredicateSymbol EOF ; + public final EObject entryRulePredicateSymbol() throws RecognitionException { + EObject current = null; + + EObject iv_rulePredicateSymbol = null; + + + try { + // InternalSolverLanguage.g:1220:56: (iv_rulePredicateSymbol= rulePredicateSymbol EOF ) + // InternalSolverLanguage.g:1221:2: iv_rulePredicateSymbol= rulePredicateSymbol EOF + { + newCompositeNode(grammarAccess.getPredicateSymbolRule()); + pushFollow(FOLLOW_1); + iv_rulePredicateSymbol=rulePredicateSymbol(); + + state._fsp--; + + current =iv_rulePredicateSymbol; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePredicateSymbol" + + + // $ANTLR start "rulePredicateSymbol" + // InternalSolverLanguage.g:1227:1: rulePredicateSymbol returns [EObject current=null] : (otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' ) ; + public final EObject rulePredicateSymbol() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_5=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token otherlv_10=null; + EObject lv_symbol_1_0 = null; + + EObject lv_parameters_3_0 = null; + + EObject lv_bodies_7_0 = null; + + EObject lv_bodies_9_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:1233:2: ( (otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' ) ) + // InternalSolverLanguage.g:1234:2: (otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' ) + { + // InternalSolverLanguage.g:1234:2: (otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' ) + // InternalSolverLanguage.g:1235:3: otherlv_0= 'predicate' ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= '(' ( (lv_parameters_3_0= ruleParameter ) )* otherlv_4= ')' otherlv_5= ':' (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) otherlv_10= '.' + { + otherlv_0=(Token)match(input,27,FOLLOW_10); + + newLeafNode(otherlv_0, grammarAccess.getPredicateSymbolAccess().getPredicateKeyword_0()); + + // InternalSolverLanguage.g:1239:3: ( (lv_symbol_1_0= ruleModelSymbol ) ) + // InternalSolverLanguage.g:1240:4: (lv_symbol_1_0= ruleModelSymbol ) + { + // InternalSolverLanguage.g:1240:4: (lv_symbol_1_0= ruleModelSymbol ) + // InternalSolverLanguage.g:1241:5: lv_symbol_1_0= ruleModelSymbol + { + + newCompositeNode(grammarAccess.getPredicateSymbolAccess().getSymbolModelSymbolParserRuleCall_1_0()); + + pushFollow(FOLLOW_6); + lv_symbol_1_0=ruleModelSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPredicateSymbolRule()); + } + set( + current, + "symbol", + lv_symbol_1_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,17,FOLLOW_12); + + newLeafNode(otherlv_2, grammarAccess.getPredicateSymbolAccess().getLeftParenthesisKeyword_2()); + + // InternalSolverLanguage.g:1262:3: ( (lv_parameters_3_0= ruleParameter ) )* + loop16: + do { + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0==RULE_ID) ) { + alt16=1; + } + + + switch (alt16) { + case 1 : + // InternalSolverLanguage.g:1263:4: (lv_parameters_3_0= ruleParameter ) + { + // InternalSolverLanguage.g:1263:4: (lv_parameters_3_0= ruleParameter ) + // InternalSolverLanguage.g:1264:5: lv_parameters_3_0= ruleParameter + { + + newCompositeNode(grammarAccess.getPredicateSymbolAccess().getParametersParameterParserRuleCall_3_0()); + + pushFollow(FOLLOW_12); + lv_parameters_3_0=ruleParameter(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPredicateSymbolRule()); + } + add( + current, + "parameters", + lv_parameters_3_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop16; + } + } while (true); + + otherlv_4=(Token)match(input,18,FOLLOW_8); + + newLeafNode(otherlv_4, grammarAccess.getPredicateSymbolAccess().getRightParenthesisKeyword_4()); + + otherlv_5=(Token)match(input,19,FOLLOW_13); + + newLeafNode(otherlv_5, grammarAccess.getPredicateSymbolAccess().getColonKeyword_5()); + + // InternalSolverLanguage.g:1289:3: (otherlv_6= 'false' | ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) ) + int alt18=2; + int LA18_0 = input.LA(1); + + if ( (LA18_0==14) ) { + alt18=1; + } + else if ( (LA18_0==EOF||LA18_0==RULE_ID||(LA18_0>=11 && LA18_0<=13)||(LA18_0>=28 && LA18_0<=29)) ) { + alt18=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); + + throw nvae; + } + switch (alt18) { + case 1 : + // InternalSolverLanguage.g:1290:4: otherlv_6= 'false' + { + otherlv_6=(Token)match(input,14,FOLLOW_5); + + newLeafNode(otherlv_6, grammarAccess.getPredicateSymbolAccess().getFalseKeyword_6_0()); + + + } + break; + case 2 : + // InternalSolverLanguage.g:1295:4: ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) + { + // InternalSolverLanguage.g:1295:4: ( ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* ) + // InternalSolverLanguage.g:1296:5: ( (lv_bodies_7_0= rulePatternBody ) ) (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* + { + // InternalSolverLanguage.g:1296:5: ( (lv_bodies_7_0= rulePatternBody ) ) + // InternalSolverLanguage.g:1297:6: (lv_bodies_7_0= rulePatternBody ) + { + // InternalSolverLanguage.g:1297:6: (lv_bodies_7_0= rulePatternBody ) + // InternalSolverLanguage.g:1298:7: lv_bodies_7_0= rulePatternBody + { + + newCompositeNode(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_0_0()); + + pushFollow(FOLLOW_14); + lv_bodies_7_0=rulePatternBody(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPredicateSymbolRule()); + } + add( + current, + "bodies", + lv_bodies_7_0, + "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalSolverLanguage.g:1315:5: (otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) )* + loop17: + do { + int alt17=2; + int LA17_0 = input.LA(1); + + if ( (LA17_0==28) ) { + alt17=1; + } + + + switch (alt17) { + case 1 : + // InternalSolverLanguage.g:1316:6: otherlv_8= '|' ( (lv_bodies_9_0= rulePatternBody ) ) + { + otherlv_8=(Token)match(input,28,FOLLOW_15); + + newLeafNode(otherlv_8, grammarAccess.getPredicateSymbolAccess().getVerticalLineKeyword_6_1_1_0()); + + // InternalSolverLanguage.g:1320:6: ( (lv_bodies_9_0= rulePatternBody ) ) + // InternalSolverLanguage.g:1321:7: (lv_bodies_9_0= rulePatternBody ) + { + // InternalSolverLanguage.g:1321:7: (lv_bodies_9_0= rulePatternBody ) + // InternalSolverLanguage.g:1322:8: lv_bodies_9_0= rulePatternBody + { + + newCompositeNode(grammarAccess.getPredicateSymbolAccess().getBodiesPatternBodyParserRuleCall_6_1_1_1_0()); + + pushFollow(FOLLOW_14); + lv_bodies_9_0=rulePatternBody(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPredicateSymbolRule()); + } + add( + current, + "bodies", + lv_bodies_9_0, + "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop17; + } + } while (true); + + + } + + + } + break; + + } + + otherlv_10=(Token)match(input,12,FOLLOW_2); + + newLeafNode(otherlv_10, grammarAccess.getPredicateSymbolAccess().getFullStopKeyword_7()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePredicateSymbol" + + + // $ANTLR start "entryRuleErrorPredicate" + // InternalSolverLanguage.g:1350:1: entryRuleErrorPredicate returns [EObject current=null] : iv_ruleErrorPredicate= ruleErrorPredicate EOF ; + public final EObject entryRuleErrorPredicate() throws RecognitionException { + EObject current = null; + + EObject iv_ruleErrorPredicate = null; + + + try { + // InternalSolverLanguage.g:1350:55: (iv_ruleErrorPredicate= ruleErrorPredicate EOF ) + // InternalSolverLanguage.g:1351:2: iv_ruleErrorPredicate= ruleErrorPredicate EOF + { + newCompositeNode(grammarAccess.getErrorPredicateRule()); + pushFollow(FOLLOW_1); + iv_ruleErrorPredicate=ruleErrorPredicate(); + + state._fsp--; + + current =iv_ruleErrorPredicate; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleErrorPredicate" + + + // $ANTLR start "ruleErrorPredicate" + // InternalSolverLanguage.g:1357:1: ruleErrorPredicate returns [EObject current=null] : ( () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' ) ; + public final EObject ruleErrorPredicate() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token lv_name_2_0=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_6=null; + Token otherlv_7=null; + Token otherlv_9=null; + Token otherlv_11=null; + EObject lv_parameters_4_0 = null; + + EObject lv_bodies_8_0 = null; + + EObject lv_bodies_10_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:1363:2: ( ( () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' ) ) + // InternalSolverLanguage.g:1364:2: ( () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' ) + { + // InternalSolverLanguage.g:1364:2: ( () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' ) + // InternalSolverLanguage.g:1365:3: () otherlv_1= 'error' ( (lv_name_2_0= RULE_ID ) )? (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) otherlv_6= ':' (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) otherlv_11= '.' + { + // InternalSolverLanguage.g:1365:3: () + // InternalSolverLanguage.g:1366:4: + { + + current = forceCreateModelElement( + grammarAccess.getErrorPredicateAccess().getErrorPredicateAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,16,FOLLOW_16); + + newLeafNode(otherlv_1, grammarAccess.getErrorPredicateAccess().getErrorKeyword_1()); + + // InternalSolverLanguage.g:1376:3: ( (lv_name_2_0= RULE_ID ) )? + int alt19=2; + int LA19_0 = input.LA(1); + + if ( (LA19_0==RULE_ID) ) { + alt19=1; + } + switch (alt19) { + case 1 : + // InternalSolverLanguage.g:1377:4: (lv_name_2_0= RULE_ID ) + { + // InternalSolverLanguage.g:1377:4: (lv_name_2_0= RULE_ID ) + // InternalSolverLanguage.g:1378:5: lv_name_2_0= RULE_ID + { + lv_name_2_0=(Token)match(input,RULE_ID,FOLLOW_6); + + newLeafNode(lv_name_2_0, grammarAccess.getErrorPredicateAccess().getNameIDTerminalRuleCall_2_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getErrorPredicateRule()); + } + setWithLastConsumed( + current, + "name", + lv_name_2_0, + "org.eclipse.xtext.common.Terminals.ID"); + + + } + + + } + break; + + } + + // InternalSolverLanguage.g:1394:3: (otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' ) + // InternalSolverLanguage.g:1395:4: otherlv_3= '(' ( (lv_parameters_4_0= ruleParameter ) )* otherlv_5= ')' + { + otherlv_3=(Token)match(input,17,FOLLOW_12); + + newLeafNode(otherlv_3, grammarAccess.getErrorPredicateAccess().getLeftParenthesisKeyword_3_0()); + + // InternalSolverLanguage.g:1399:4: ( (lv_parameters_4_0= ruleParameter ) )* + loop20: + do { + int alt20=2; + int LA20_0 = input.LA(1); + + if ( (LA20_0==RULE_ID) ) { + alt20=1; + } + + + switch (alt20) { + case 1 : + // InternalSolverLanguage.g:1400:5: (lv_parameters_4_0= ruleParameter ) + { + // InternalSolverLanguage.g:1400:5: (lv_parameters_4_0= ruleParameter ) + // InternalSolverLanguage.g:1401:6: lv_parameters_4_0= ruleParameter + { + + newCompositeNode(grammarAccess.getErrorPredicateAccess().getParametersParameterParserRuleCall_3_1_0()); + + pushFollow(FOLLOW_12); + lv_parameters_4_0=ruleParameter(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getErrorPredicateRule()); + } + add( + current, + "parameters", + lv_parameters_4_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop20; + } + } while (true); + + otherlv_5=(Token)match(input,18,FOLLOW_8); + + newLeafNode(otherlv_5, grammarAccess.getErrorPredicateAccess().getRightParenthesisKeyword_3_2()); + + + } + + otherlv_6=(Token)match(input,19,FOLLOW_13); + + newLeafNode(otherlv_6, grammarAccess.getErrorPredicateAccess().getColonKeyword_4()); + + // InternalSolverLanguage.g:1427:3: (otherlv_7= 'false' | ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) ) + int alt22=2; + int LA22_0 = input.LA(1); + + if ( (LA22_0==14) ) { + alt22=1; + } + else if ( (LA22_0==EOF||LA22_0==RULE_ID||(LA22_0>=11 && LA22_0<=13)||(LA22_0>=28 && LA22_0<=29)) ) { + alt22=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 22, 0, input); + + throw nvae; + } + switch (alt22) { + case 1 : + // InternalSolverLanguage.g:1428:4: otherlv_7= 'false' + { + otherlv_7=(Token)match(input,14,FOLLOW_5); + + newLeafNode(otherlv_7, grammarAccess.getErrorPredicateAccess().getFalseKeyword_5_0()); + + + } + break; + case 2 : + // InternalSolverLanguage.g:1433:4: ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) + { + // InternalSolverLanguage.g:1433:4: ( ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* ) + // InternalSolverLanguage.g:1434:5: ( (lv_bodies_8_0= rulePatternBody ) ) (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* + { + // InternalSolverLanguage.g:1434:5: ( (lv_bodies_8_0= rulePatternBody ) ) + // InternalSolverLanguage.g:1435:6: (lv_bodies_8_0= rulePatternBody ) + { + // InternalSolverLanguage.g:1435:6: (lv_bodies_8_0= rulePatternBody ) + // InternalSolverLanguage.g:1436:7: lv_bodies_8_0= rulePatternBody + { + + newCompositeNode(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_0_0()); + + pushFollow(FOLLOW_14); + lv_bodies_8_0=rulePatternBody(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getErrorPredicateRule()); + } + add( + current, + "bodies", + lv_bodies_8_0, + "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalSolverLanguage.g:1453:5: (otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) )* + loop21: + do { + int alt21=2; + int LA21_0 = input.LA(1); + + if ( (LA21_0==28) ) { + alt21=1; + } + + + switch (alt21) { + case 1 : + // InternalSolverLanguage.g:1454:6: otherlv_9= '|' ( (lv_bodies_10_0= rulePatternBody ) ) + { + otherlv_9=(Token)match(input,28,FOLLOW_15); + + newLeafNode(otherlv_9, grammarAccess.getErrorPredicateAccess().getVerticalLineKeyword_5_1_1_0()); + + // InternalSolverLanguage.g:1458:6: ( (lv_bodies_10_0= rulePatternBody ) ) + // InternalSolverLanguage.g:1459:7: (lv_bodies_10_0= rulePatternBody ) + { + // InternalSolverLanguage.g:1459:7: (lv_bodies_10_0= rulePatternBody ) + // InternalSolverLanguage.g:1460:8: lv_bodies_10_0= rulePatternBody + { + + newCompositeNode(grammarAccess.getErrorPredicateAccess().getBodiesPatternBodyParserRuleCall_5_1_1_1_0()); + + pushFollow(FOLLOW_14); + lv_bodies_10_0=rulePatternBody(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getErrorPredicateRule()); + } + add( + current, + "bodies", + lv_bodies_10_0, + "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + default : + break loop21; + } + } while (true); + + + } + + + } + break; + + } + + otherlv_11=(Token)match(input,12,FOLLOW_2); + + newLeafNode(otherlv_11, grammarAccess.getErrorPredicateAccess().getFullStopKeyword_6()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleErrorPredicate" + + + // $ANTLR start "entryRuleParameter" + // InternalSolverLanguage.g:1488:1: entryRuleParameter returns [EObject current=null] : iv_ruleParameter= ruleParameter EOF ; + public final EObject entryRuleParameter() throws RecognitionException { + EObject current = null; + + EObject iv_ruleParameter = null; + + + try { + // InternalSolverLanguage.g:1488:50: (iv_ruleParameter= ruleParameter EOF ) + // InternalSolverLanguage.g:1489:2: iv_ruleParameter= ruleParameter EOF + { + newCompositeNode(grammarAccess.getParameterRule()); + pushFollow(FOLLOW_1); + iv_ruleParameter=ruleParameter(); + + state._fsp--; + + current =iv_ruleParameter; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleParameter" + + + // $ANTLR start "ruleParameter" + // InternalSolverLanguage.g:1495:1: ruleParameter returns [EObject current=null] : ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) ; + public final EObject ruleParameter() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_variable_0_0 = null; + + EObject lv_type_2_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:1501:2: ( ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) ) + // InternalSolverLanguage.g:1502:2: ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) + { + // InternalSolverLanguage.g:1502:2: ( ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? ) + // InternalSolverLanguage.g:1503:3: ( (lv_variable_0_0= ruleVariable ) ) (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? + { + // InternalSolverLanguage.g:1503:3: ( (lv_variable_0_0= ruleVariable ) ) + // InternalSolverLanguage.g:1504:4: (lv_variable_0_0= ruleVariable ) + { + // InternalSolverLanguage.g:1504:4: (lv_variable_0_0= ruleVariable ) + // InternalSolverLanguage.g:1505:5: lv_variable_0_0= ruleVariable + { + + newCompositeNode(grammarAccess.getParameterAccess().getVariableVariableParserRuleCall_0_0()); + + pushFollow(FOLLOW_17); + lv_variable_0_0=ruleVariable(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + current, + "variable", + lv_variable_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Variable"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalSolverLanguage.g:1522:3: (otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) )? + int alt23=2; + int LA23_0 = input.LA(1); + + if ( (LA23_0==19) ) { + alt23=1; + } + switch (alt23) { + case 1 : + // InternalSolverLanguage.g:1523:4: otherlv_1= ':' ( (lv_type_2_0= ruleSymbol ) ) + { + otherlv_1=(Token)match(input,19,FOLLOW_18); + + newLeafNode(otherlv_1, grammarAccess.getParameterAccess().getColonKeyword_1_0()); + + // InternalSolverLanguage.g:1527:4: ( (lv_type_2_0= ruleSymbol ) ) + // InternalSolverLanguage.g:1528:5: (lv_type_2_0= ruleSymbol ) + { + // InternalSolverLanguage.g:1528:5: (lv_type_2_0= ruleSymbol ) + // InternalSolverLanguage.g:1529:6: lv_type_2_0= ruleSymbol + { + + newCompositeNode(grammarAccess.getParameterAccess().getTypeSymbolParserRuleCall_1_1_0()); + + pushFollow(FOLLOW_2); + lv_type_2_0=ruleSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getParameterRule()); + } + set( + current, + "type", + lv_type_2_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleParameter" + + + // $ANTLR start "entryRulePatternBody" + // InternalSolverLanguage.g:1551:1: entryRulePatternBody returns [EObject current=null] : iv_rulePatternBody= rulePatternBody EOF ; + public final EObject entryRulePatternBody() throws RecognitionException { + EObject current = null; + + EObject iv_rulePatternBody = null; + + + try { + // InternalSolverLanguage.g:1551:52: (iv_rulePatternBody= rulePatternBody EOF ) + // InternalSolverLanguage.g:1552:2: iv_rulePatternBody= rulePatternBody EOF + { + newCompositeNode(grammarAccess.getPatternBodyRule()); + pushFollow(FOLLOW_1); + iv_rulePatternBody=rulePatternBody(); + + state._fsp--; + + current =iv_rulePatternBody; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePatternBody" + + + // $ANTLR start "rulePatternBody" + // InternalSolverLanguage.g:1558:1: rulePatternBody returns [EObject current=null] : ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) ; + public final EObject rulePatternBody() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_constraints_2_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:1564:2: ( ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) ) + // InternalSolverLanguage.g:1565:2: ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) + { + // InternalSolverLanguage.g:1565:2: ( () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) ) + // InternalSolverLanguage.g:1566:3: () (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) + { + // InternalSolverLanguage.g:1566:3: () + // InternalSolverLanguage.g:1567:4: + { + + current = forceCreateModelElement( + grammarAccess.getPatternBodyAccess().getPatternBodyAction_0(), + current); + + + } + + // InternalSolverLanguage.g:1573:3: (otherlv_1= 'true' | ( (lv_constraints_2_0= ruleConstraint ) )* ) + int alt25=2; + int LA25_0 = input.LA(1); + + if ( (LA25_0==13) ) { + alt25=1; + } + else if ( (LA25_0==EOF||LA25_0==RULE_ID||(LA25_0>=11 && LA25_0<=12)||(LA25_0>=28 && LA25_0<=29)) ) { + alt25=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 25, 0, input); + + throw nvae; + } + switch (alt25) { + case 1 : + // InternalSolverLanguage.g:1574:4: otherlv_1= 'true' + { + otherlv_1=(Token)match(input,13,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); + + + } + break; + case 2 : + // InternalSolverLanguage.g:1579:4: ( (lv_constraints_2_0= ruleConstraint ) )* + { + // InternalSolverLanguage.g:1579:4: ( (lv_constraints_2_0= ruleConstraint ) )* + loop24: + do { + int alt24=2; + int LA24_0 = input.LA(1); + + if ( (LA24_0==RULE_ID||LA24_0==11||LA24_0==29) ) { + alt24=1; + } + + + switch (alt24) { + case 1 : + // InternalSolverLanguage.g:1580:5: (lv_constraints_2_0= ruleConstraint ) + { + // InternalSolverLanguage.g:1580:5: (lv_constraints_2_0= ruleConstraint ) + // InternalSolverLanguage.g:1581:6: lv_constraints_2_0= ruleConstraint + { + + newCompositeNode(grammarAccess.getPatternBodyAccess().getConstraintsConstraintParserRuleCall_1_1_0()); + + pushFollow(FOLLOW_19); + lv_constraints_2_0=ruleConstraint(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getPatternBodyRule()); + } + add( + current, + "constraints", + lv_constraints_2_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Constraint"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop24; + } + } while (true); + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePatternBody" + + + // $ANTLR start "entryRulePolarity" + // InternalSolverLanguage.g:1603:1: entryRulePolarity returns [EObject current=null] : iv_rulePolarity= rulePolarity EOF ; + public final EObject entryRulePolarity() throws RecognitionException { + EObject current = null; + + EObject iv_rulePolarity = null; + + + try { + // InternalSolverLanguage.g:1603:49: (iv_rulePolarity= rulePolarity EOF ) + // InternalSolverLanguage.g:1604:2: iv_rulePolarity= rulePolarity EOF + { + newCompositeNode(grammarAccess.getPolarityRule()); + pushFollow(FOLLOW_1); + iv_rulePolarity=rulePolarity(); + + state._fsp--; + + current =iv_rulePolarity; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRulePolarity" + + + // $ANTLR start "rulePolarity" + // InternalSolverLanguage.g:1610:1: rulePolarity returns [EObject current=null] : ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) ; + public final EObject rulePolarity() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:1616:2: ( ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) ) + // InternalSolverLanguage.g:1617:2: ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) + { + // InternalSolverLanguage.g:1617:2: ( ( () otherlv_1= '+' ) | ( () otherlv_3= '-' ) ) + int alt26=2; + int LA26_0 = input.LA(1); + + if ( (LA26_0==29) ) { + alt26=1; + } + else if ( (LA26_0==11) ) { + alt26=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 26, 0, input); + + throw nvae; + } + switch (alt26) { + case 1 : + // InternalSolverLanguage.g:1618:3: ( () otherlv_1= '+' ) + { + // InternalSolverLanguage.g:1618:3: ( () otherlv_1= '+' ) + // InternalSolverLanguage.g:1619:4: () otherlv_1= '+' + { + // InternalSolverLanguage.g:1619:4: () + // InternalSolverLanguage.g:1620:5: + { + + current = forceCreateModelElement( + grammarAccess.getPolarityAccess().getPositiveAction_0_0(), + current); + + + } + + otherlv_1=(Token)match(input,29,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getPolarityAccess().getPlusSignKeyword_0_1()); + + + } + + + } + break; + case 2 : + // InternalSolverLanguage.g:1632:3: ( () otherlv_3= '-' ) + { + // InternalSolverLanguage.g:1632:3: ( () otherlv_3= '-' ) + // InternalSolverLanguage.g:1633:4: () otherlv_3= '-' + { + // InternalSolverLanguage.g:1633:4: () + // InternalSolverLanguage.g:1634:5: + { + + current = forceCreateModelElement( + grammarAccess.getPolarityAccess().getNegativeAction_1_0(), + current); + + + } + + otherlv_3=(Token)match(input,11,FOLLOW_2); + + newLeafNode(otherlv_3, grammarAccess.getPolarityAccess().getHyphenMinusKeyword_1_1()); + + + } + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "rulePolarity" + + + // $ANTLR start "entryRuleConstraint" + // InternalSolverLanguage.g:1649:1: entryRuleConstraint returns [EObject current=null] : iv_ruleConstraint= ruleConstraint EOF ; + public final EObject entryRuleConstraint() throws RecognitionException { + EObject current = null; + + EObject iv_ruleConstraint = null; + + + try { + // InternalSolverLanguage.g:1649:51: (iv_ruleConstraint= ruleConstraint EOF ) + // InternalSolverLanguage.g:1650:2: iv_ruleConstraint= ruleConstraint EOF + { + newCompositeNode(grammarAccess.getConstraintRule()); + pushFollow(FOLLOW_1); + iv_ruleConstraint=ruleConstraint(); + + state._fsp--; + + current =iv_ruleConstraint; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleConstraint" + + + // $ANTLR start "ruleConstraint" + // InternalSolverLanguage.g:1656:1: ruleConstraint returns [EObject current=null] : ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) ) ; + public final EObject ruleConstraint() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_9=null; + EObject lv_polarity_0_0 = null; + + EObject lv_symbol_1_0 = null; + + EObject lv_params_3_0 = null; + + EObject lv_closureType_5_0 = null; + + EObject lv_params_7_0 = null; + + EObject lv_params_8_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:1662:2: ( ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) ) ) + // InternalSolverLanguage.g:1663:2: ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) ) + { + // InternalSolverLanguage.g:1663:2: ( ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) ) + // InternalSolverLanguage.g:1664:3: ( (lv_polarity_0_0= rulePolarity ) )? ( (lv_symbol_1_0= ruleModelSymbol ) ) ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) + { + // InternalSolverLanguage.g:1664:3: ( (lv_polarity_0_0= rulePolarity ) )? + int alt27=2; + int LA27_0 = input.LA(1); + + if ( (LA27_0==11||LA27_0==29) ) { + alt27=1; + } + switch (alt27) { + case 1 : + // InternalSolverLanguage.g:1665:4: (lv_polarity_0_0= rulePolarity ) + { + // InternalSolverLanguage.g:1665:4: (lv_polarity_0_0= rulePolarity ) + // InternalSolverLanguage.g:1666:5: lv_polarity_0_0= rulePolarity + { + + newCompositeNode(grammarAccess.getConstraintAccess().getPolarityPolarityParserRuleCall_0_0()); + + pushFollow(FOLLOW_10); + lv_polarity_0_0=rulePolarity(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getConstraintRule()); + } + set( + current, + "polarity", + lv_polarity_0_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Polarity"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + } + + // InternalSolverLanguage.g:1683:3: ( (lv_symbol_1_0= ruleModelSymbol ) ) + // InternalSolverLanguage.g:1684:4: (lv_symbol_1_0= ruleModelSymbol ) + { + // InternalSolverLanguage.g:1684:4: (lv_symbol_1_0= ruleModelSymbol ) + // InternalSolverLanguage.g:1685:5: lv_symbol_1_0= ruleModelSymbol + { + + newCompositeNode(grammarAccess.getConstraintAccess().getSymbolModelSymbolParserRuleCall_1_0()); + + pushFollow(FOLLOW_20); + lv_symbol_1_0=ruleModelSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getConstraintRule()); + } + set( + current, + "symbol", + lv_symbol_1_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalSolverLanguage.g:1702:3: ( (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) | ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) ) + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0==17) ) { + alt29=1; + } + else if ( ((LA29_0>=29 && LA29_0<=30)) ) { + alt29=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 29, 0, input); + + throw nvae; + } + switch (alt29) { + case 1 : + // InternalSolverLanguage.g:1703:4: (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) + { + // InternalSolverLanguage.g:1703:4: (otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' ) + // InternalSolverLanguage.g:1704:5: otherlv_2= '(' ( (lv_params_3_0= ruleLiteral ) )* otherlv_4= ')' + { + otherlv_2=(Token)match(input,17,FOLLOW_21); + + newLeafNode(otherlv_2, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_0_0()); + + // InternalSolverLanguage.g:1708:5: ( (lv_params_3_0= ruleLiteral ) )* + loop28: + do { + int alt28=2; + int LA28_0 = input.LA(1); + + if ( ((LA28_0>=RULE_INT && LA28_0<=RULE_STRING)||LA28_0==11||(LA28_0>=13 && LA28_0<=14)) ) { + alt28=1; + } + + + switch (alt28) { + case 1 : + // InternalSolverLanguage.g:1709:6: (lv_params_3_0= ruleLiteral ) + { + // InternalSolverLanguage.g:1709:6: (lv_params_3_0= ruleLiteral ) + // InternalSolverLanguage.g:1710:7: lv_params_3_0= ruleLiteral + { + + newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_0_1_0()); + + pushFollow(FOLLOW_21); + lv_params_3_0=ruleLiteral(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getConstraintRule()); + } + add( + current, + "params", + lv_params_3_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop28; + } + } while (true); + + otherlv_4=(Token)match(input,18,FOLLOW_2); + + newLeafNode(otherlv_4, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_0_2()); + + + } + + + } + break; + case 2 : + // InternalSolverLanguage.g:1733:4: ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) + { + // InternalSolverLanguage.g:1733:4: ( ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' ) + // InternalSolverLanguage.g:1734:5: ( (lv_closureType_5_0= ruleClosureType ) ) otherlv_6= '(' ( (lv_params_7_0= ruleLiteral ) ) ( (lv_params_8_0= ruleLiteral ) ) otherlv_9= ')' + { + // InternalSolverLanguage.g:1734:5: ( (lv_closureType_5_0= ruleClosureType ) ) + // InternalSolverLanguage.g:1735:6: (lv_closureType_5_0= ruleClosureType ) + { + // InternalSolverLanguage.g:1735:6: (lv_closureType_5_0= ruleClosureType ) + // InternalSolverLanguage.g:1736:7: lv_closureType_5_0= ruleClosureType + { + + newCompositeNode(grammarAccess.getConstraintAccess().getClosureTypeClosureTypeParserRuleCall_2_1_0_0()); + + pushFollow(FOLLOW_6); + lv_closureType_5_0=ruleClosureType(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getConstraintRule()); + } + set( + current, + "closureType", + lv_closureType_5_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_6=(Token)match(input,17,FOLLOW_22); + + newLeafNode(otherlv_6, grammarAccess.getConstraintAccess().getLeftParenthesisKeyword_2_1_1()); + + // InternalSolverLanguage.g:1757:5: ( (lv_params_7_0= ruleLiteral ) ) + // InternalSolverLanguage.g:1758:6: (lv_params_7_0= ruleLiteral ) + { + // InternalSolverLanguage.g:1758:6: (lv_params_7_0= ruleLiteral ) + // InternalSolverLanguage.g:1759:7: lv_params_7_0= ruleLiteral + { + + newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_2_0()); + + pushFollow(FOLLOW_22); + lv_params_7_0=ruleLiteral(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getConstraintRule()); + } + add( + current, + "params", + lv_params_7_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalSolverLanguage.g:1776:5: ( (lv_params_8_0= ruleLiteral ) ) + // InternalSolverLanguage.g:1777:6: (lv_params_8_0= ruleLiteral ) + { + // InternalSolverLanguage.g:1777:6: (lv_params_8_0= ruleLiteral ) + // InternalSolverLanguage.g:1778:7: lv_params_8_0= ruleLiteral + { + + newCompositeNode(grammarAccess.getConstraintAccess().getParamsLiteralParserRuleCall_2_1_3_0()); + + pushFollow(FOLLOW_23); + lv_params_8_0=ruleLiteral(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getConstraintRule()); + } + add( + current, + "params", + lv_params_8_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_9=(Token)match(input,18,FOLLOW_2); + + newLeafNode(otherlv_9, grammarAccess.getConstraintAccess().getRightParenthesisKeyword_2_1_4()); + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleConstraint" + + + // $ANTLR start "entryRuleClosureType" + // InternalSolverLanguage.g:1805:1: entryRuleClosureType returns [EObject current=null] : iv_ruleClosureType= ruleClosureType EOF ; + public final EObject entryRuleClosureType() throws RecognitionException { + EObject current = null; + + EObject iv_ruleClosureType = null; + + + try { + // InternalSolverLanguage.g:1805:52: (iv_ruleClosureType= ruleClosureType EOF ) + // InternalSolverLanguage.g:1806:2: iv_ruleClosureType= ruleClosureType EOF + { + newCompositeNode(grammarAccess.getClosureTypeRule()); + pushFollow(FOLLOW_1); + iv_ruleClosureType=ruleClosureType(); + + state._fsp--; + + current =iv_ruleClosureType; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleClosureType" + + + // $ANTLR start "ruleClosureType" + // InternalSolverLanguage.g:1812:1: ruleClosureType returns [EObject current=null] : ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) ; + public final EObject ruleClosureType() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:1818:2: ( ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) ) + // InternalSolverLanguage.g:1819:2: ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) + { + // InternalSolverLanguage.g:1819:2: ( ( () otherlv_1= '*' ) | ( () otherlv_3= '+' ) ) + int alt30=2; + int LA30_0 = input.LA(1); + + if ( (LA30_0==30) ) { + alt30=1; + } + else if ( (LA30_0==29) ) { + alt30=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 30, 0, input); + + throw nvae; + } + switch (alt30) { + case 1 : + // InternalSolverLanguage.g:1820:3: ( () otherlv_1= '*' ) + { + // InternalSolverLanguage.g:1820:3: ( () otherlv_1= '*' ) + // InternalSolverLanguage.g:1821:4: () otherlv_1= '*' + { + // InternalSolverLanguage.g:1821:4: () + // InternalSolverLanguage.g:1822:5: + { + + current = forceCreateModelElement( + grammarAccess.getClosureTypeAccess().getReflexiveClosureAction_0_0(), + current); + + + } + + otherlv_1=(Token)match(input,30,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getClosureTypeAccess().getAsteriskKeyword_0_1()); + + + } + + + } + break; + case 2 : + // InternalSolverLanguage.g:1834:3: ( () otherlv_3= '+' ) + { + // InternalSolverLanguage.g:1834:3: ( () otherlv_3= '+' ) + // InternalSolverLanguage.g:1835:4: () otherlv_3= '+' + { + // InternalSolverLanguage.g:1835:4: () + // InternalSolverLanguage.g:1836:5: + { + + current = forceCreateModelElement( + grammarAccess.getClosureTypeAccess().getIrreflexiveClosureAction_1_0(), + current); + + + } + + otherlv_3=(Token)match(input,29,FOLLOW_2); + + newLeafNode(otherlv_3, grammarAccess.getClosureTypeAccess().getPlusSignKeyword_1_1()); + + + } + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleClosureType" + + + // $ANTLR start "entryRuleLiteral" + // InternalSolverLanguage.g:1851:1: entryRuleLiteral returns [EObject current=null] : iv_ruleLiteral= ruleLiteral EOF ; + public final EObject entryRuleLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleLiteral = null; + + + try { + // InternalSolverLanguage.g:1851:48: (iv_ruleLiteral= ruleLiteral EOF ) + // InternalSolverLanguage.g:1852:2: iv_ruleLiteral= ruleLiteral EOF + { + newCompositeNode(grammarAccess.getLiteralRule()); + pushFollow(FOLLOW_1); + iv_ruleLiteral=ruleLiteral(); + + state._fsp--; + + current =iv_ruleLiteral; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleLiteral" + + + // $ANTLR start "ruleLiteral" + // InternalSolverLanguage.g:1858:1: ruleLiteral returns [EObject current=null] : (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject ) ; + public final EObject ruleLiteral() throws RecognitionException { + EObject current = null; + + EObject this_Variable_0 = null; + + EObject this_DataObject_1 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:1864:2: ( (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject ) ) + // InternalSolverLanguage.g:1865:2: (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject ) + { + // InternalSolverLanguage.g:1865:2: (this_Variable_0= ruleVariable | this_DataObject_1= ruleDataObject ) + int alt31=2; + int LA31_0 = input.LA(1); + + if ( (LA31_0==RULE_ID) ) { + alt31=1; + } + else if ( (LA31_0==RULE_INT||LA31_0==RULE_STRING||LA31_0==11||(LA31_0>=13 && LA31_0<=14)) ) { + alt31=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 31, 0, input); + + throw nvae; + } + switch (alt31) { + case 1 : + // InternalSolverLanguage.g:1866:3: this_Variable_0= ruleVariable + { + + newCompositeNode(grammarAccess.getLiteralAccess().getVariableParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_Variable_0=ruleVariable(); + + state._fsp--; + + + current = this_Variable_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalSolverLanguage.g:1875:3: this_DataObject_1= ruleDataObject + { + + newCompositeNode(grammarAccess.getLiteralAccess().getDataObjectParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_DataObject_1=ruleDataObject(); + + state._fsp--; + + + current = this_DataObject_1; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleLiteral" + + + // $ANTLR start "entryRuleVariable" + // InternalSolverLanguage.g:1887:1: entryRuleVariable returns [EObject current=null] : iv_ruleVariable= ruleVariable EOF ; + public final EObject entryRuleVariable() throws RecognitionException { + EObject current = null; + + EObject iv_ruleVariable = null; + + + try { + // InternalSolverLanguage.g:1887:49: (iv_ruleVariable= ruleVariable EOF ) + // InternalSolverLanguage.g:1888:2: iv_ruleVariable= ruleVariable EOF + { + newCompositeNode(grammarAccess.getVariableRule()); + pushFollow(FOLLOW_1); + iv_ruleVariable=ruleVariable(); + + state._fsp--; + + current =iv_ruleVariable; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleVariable" + + + // $ANTLR start "ruleVariable" + // InternalSolverLanguage.g:1894:1: ruleVariable returns [EObject current=null] : ( (lv_name_0_0= RULE_ID ) ) ; + public final EObject ruleVariable() throws RecognitionException { + EObject current = null; + + Token lv_name_0_0=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:1900:2: ( ( (lv_name_0_0= RULE_ID ) ) ) + // InternalSolverLanguage.g:1901:2: ( (lv_name_0_0= RULE_ID ) ) + { + // InternalSolverLanguage.g:1901:2: ( (lv_name_0_0= RULE_ID ) ) + // InternalSolverLanguage.g:1902:3: (lv_name_0_0= RULE_ID ) + { + // InternalSolverLanguage.g:1902:3: (lv_name_0_0= RULE_ID ) + // InternalSolverLanguage.g:1903:4: lv_name_0_0= RULE_ID + { + lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_2); + + newLeafNode(lv_name_0_0, grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getVariableRule()); + } + setWithLastConsumed( + current, + "name", + lv_name_0_0, + "org.eclipse.xtext.common.Terminals.ID"); + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleVariable" + + + // $ANTLR start "entryRuleAllInstances" + // InternalSolverLanguage.g:1922:1: entryRuleAllInstances returns [EObject current=null] : iv_ruleAllInstances= ruleAllInstances EOF ; + public final EObject entryRuleAllInstances() throws RecognitionException { + EObject current = null; + + EObject iv_ruleAllInstances = null; + + + try { + // InternalSolverLanguage.g:1922:53: (iv_ruleAllInstances= ruleAllInstances EOF ) + // InternalSolverLanguage.g:1923:2: iv_ruleAllInstances= ruleAllInstances EOF + { + newCompositeNode(grammarAccess.getAllInstancesRule()); + pushFollow(FOLLOW_1); + iv_ruleAllInstances=ruleAllInstances(); + + state._fsp--; + + current =iv_ruleAllInstances; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleAllInstances" + + + // $ANTLR start "ruleAllInstances" + // InternalSolverLanguage.g:1929:1: ruleAllInstances returns [EObject current=null] : (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) ; + public final EObject ruleAllInstances() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_symbol_1_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:1935:2: ( (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) ) + // InternalSolverLanguage.g:1936:2: (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) + { + // InternalSolverLanguage.g:1936:2: (otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) ) + // InternalSolverLanguage.g:1937:3: otherlv_0= ':' ( (lv_symbol_1_0= ruleSymbol ) ) + { + otherlv_0=(Token)match(input,19,FOLLOW_18); + + newLeafNode(otherlv_0, grammarAccess.getAllInstancesAccess().getColonKeyword_0()); + + // InternalSolverLanguage.g:1941:3: ( (lv_symbol_1_0= ruleSymbol ) ) + // InternalSolverLanguage.g:1942:4: (lv_symbol_1_0= ruleSymbol ) + { + // InternalSolverLanguage.g:1942:4: (lv_symbol_1_0= ruleSymbol ) + // InternalSolverLanguage.g:1943:5: lv_symbol_1_0= ruleSymbol + { + + newCompositeNode(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0()); + + pushFollow(FOLLOW_2); + lv_symbol_1_0=ruleSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getAllInstancesRule()); + } + set( + current, + "symbol", + lv_symbol_1_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleAllInstances" + + + // $ANTLR start "entryRuleAllObjects" + // InternalSolverLanguage.g:1964:1: entryRuleAllObjects returns [EObject current=null] : iv_ruleAllObjects= ruleAllObjects EOF ; + public final EObject entryRuleAllObjects() throws RecognitionException { + EObject current = null; + + EObject iv_ruleAllObjects = null; + + + try { + // InternalSolverLanguage.g:1964:51: (iv_ruleAllObjects= ruleAllObjects EOF ) + // InternalSolverLanguage.g:1965:2: iv_ruleAllObjects= ruleAllObjects EOF + { + newCompositeNode(grammarAccess.getAllObjectsRule()); + pushFollow(FOLLOW_1); + iv_ruleAllObjects=ruleAllObjects(); + + state._fsp--; + + current =iv_ruleAllObjects; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleAllObjects" + + + // $ANTLR start "ruleAllObjects" + // InternalSolverLanguage.g:1971:1: ruleAllObjects returns [EObject current=null] : ( () otherlv_1= '*' ) ; + public final EObject ruleAllObjects() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:1977:2: ( ( () otherlv_1= '*' ) ) + // InternalSolverLanguage.g:1978:2: ( () otherlv_1= '*' ) + { + // InternalSolverLanguage.g:1978:2: ( () otherlv_1= '*' ) + // InternalSolverLanguage.g:1979:3: () otherlv_1= '*' + { + // InternalSolverLanguage.g:1979:3: () + // InternalSolverLanguage.g:1980:4: + { + + current = forceCreateModelElement( + grammarAccess.getAllObjectsAccess().getAllObjectsAction_0(), + current); + + + } + + otherlv_1=(Token)match(input,30,FOLLOW_2); + + newLeafNode(otherlv_1, grammarAccess.getAllObjectsAccess().getAsteriskKeyword_1()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleAllObjects" + + + // $ANTLR start "entryRuleDefaultInterpretation" + // InternalSolverLanguage.g:1994:1: entryRuleDefaultInterpretation returns [EObject current=null] : iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF ; + public final EObject entryRuleDefaultInterpretation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleDefaultInterpretation = null; + + + try { + // InternalSolverLanguage.g:1994:62: (iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF ) + // InternalSolverLanguage.g:1995:2: iv_ruleDefaultInterpretation= ruleDefaultInterpretation EOF + { + newCompositeNode(grammarAccess.getDefaultInterpretationRule()); + pushFollow(FOLLOW_1); + iv_ruleDefaultInterpretation=ruleDefaultInterpretation(); + + state._fsp--; + + current =iv_ruleDefaultInterpretation; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleDefaultInterpretation" + + + // $ANTLR start "ruleDefaultInterpretation" + // InternalSolverLanguage.g:2001:1: ruleDefaultInterpretation returns [EObject current=null] : (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) ; + public final EObject ruleDefaultInterpretation() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_interpretation_1_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:2007:2: ( (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) ) + // InternalSolverLanguage.g:2008:2: (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) + { + // InternalSolverLanguage.g:2008:2: (otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) ) + // InternalSolverLanguage.g:2009:3: otherlv_0= 'default' ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) + { + otherlv_0=(Token)match(input,31,FOLLOW_18); + + newLeafNode(otherlv_0, grammarAccess.getDefaultInterpretationAccess().getDefaultKeyword_0()); + + // InternalSolverLanguage.g:2013:3: ( (lv_interpretation_1_0= ruleBasicInterpretation ) ) + // InternalSolverLanguage.g:2014:4: (lv_interpretation_1_0= ruleBasicInterpretation ) + { + // InternalSolverLanguage.g:2014:4: (lv_interpretation_1_0= ruleBasicInterpretation ) + // InternalSolverLanguage.g:2015:5: lv_interpretation_1_0= ruleBasicInterpretation + { + + newCompositeNode(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0()); + + pushFollow(FOLLOW_2); + lv_interpretation_1_0=ruleBasicInterpretation(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getDefaultInterpretationRule()); + } + set( + current, + "interpretation", + lv_interpretation_1_0, + "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleDefaultInterpretation" + + + // $ANTLR start "entryRuleCDInterpretation" + // InternalSolverLanguage.g:2036:1: entryRuleCDInterpretation returns [EObject current=null] : iv_ruleCDInterpretation= ruleCDInterpretation EOF ; + public final EObject entryRuleCDInterpretation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleCDInterpretation = null; + + + try { + // InternalSolverLanguage.g:2036:57: (iv_ruleCDInterpretation= ruleCDInterpretation EOF ) + // InternalSolverLanguage.g:2037:2: iv_ruleCDInterpretation= ruleCDInterpretation EOF + { + newCompositeNode(grammarAccess.getCDInterpretationRule()); + pushFollow(FOLLOW_1); + iv_ruleCDInterpretation=ruleCDInterpretation(); + + state._fsp--; + + current =iv_ruleCDInterpretation; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleCDInterpretation" + + + // $ANTLR start "ruleCDInterpretation" + // InternalSolverLanguage.g:2043:1: ruleCDInterpretation returns [EObject current=null] : (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) ; + public final EObject ruleCDInterpretation() throws RecognitionException { + EObject current = null; + + EObject this_ClassInterpretation_0 = null; + + EObject this_EnumInterpretation_1 = null; + + EObject this_GlobalRelationInterpretation_2 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:2049:2: ( (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) ) + // InternalSolverLanguage.g:2050:2: (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) + { + // InternalSolverLanguage.g:2050:2: (this_ClassInterpretation_0= ruleClassInterpretation | this_EnumInterpretation_1= ruleEnumInterpretation | this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation ) + int alt32=3; + switch ( input.LA(1) ) { + case 32: + { + alt32=1; + } + break; + case 37: + { + alt32=2; + } + break; + case 38: + { + alt32=3; + } + break; + default: + NoViableAltException nvae = + new NoViableAltException("", 32, 0, input); + + throw nvae; + } + + switch (alt32) { + case 1 : + // InternalSolverLanguage.g:2051:3: this_ClassInterpretation_0= ruleClassInterpretation + { + + newCompositeNode(grammarAccess.getCDInterpretationAccess().getClassInterpretationParserRuleCall_0()); + + pushFollow(FOLLOW_2); + this_ClassInterpretation_0=ruleClassInterpretation(); + + state._fsp--; + + + current = this_ClassInterpretation_0; + afterParserOrEnumRuleCall(); + + + } + break; + case 2 : + // InternalSolverLanguage.g:2060:3: this_EnumInterpretation_1= ruleEnumInterpretation + { + + newCompositeNode(grammarAccess.getCDInterpretationAccess().getEnumInterpretationParserRuleCall_1()); + + pushFollow(FOLLOW_2); + this_EnumInterpretation_1=ruleEnumInterpretation(); + + state._fsp--; + + + current = this_EnumInterpretation_1; + afterParserOrEnumRuleCall(); + + + } + break; + case 3 : + // InternalSolverLanguage.g:2069:3: this_GlobalRelationInterpretation_2= ruleGlobalRelationInterpretation + { + + newCompositeNode(grammarAccess.getCDInterpretationAccess().getGlobalRelationInterpretationParserRuleCall_2()); + + pushFollow(FOLLOW_2); + this_GlobalRelationInterpretation_2=ruleGlobalRelationInterpretation(); + + state._fsp--; + + + current = this_GlobalRelationInterpretation_2; + afterParserOrEnumRuleCall(); + + + } + break; + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleCDInterpretation" + + + // $ANTLR start "entryRuleClassInterpretation" + // InternalSolverLanguage.g:2081:1: entryRuleClassInterpretation returns [EObject current=null] : iv_ruleClassInterpretation= ruleClassInterpretation EOF ; + public final EObject entryRuleClassInterpretation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleClassInterpretation = null; + + + try { + // InternalSolverLanguage.g:2081:60: (iv_ruleClassInterpretation= ruleClassInterpretation EOF ) + // InternalSolverLanguage.g:2082:2: iv_ruleClassInterpretation= ruleClassInterpretation EOF + { + newCompositeNode(grammarAccess.getClassInterpretationRule()); + pushFollow(FOLLOW_1); + iv_ruleClassInterpretation=ruleClassInterpretation(); + + state._fsp--; + + current =iv_ruleClassInterpretation; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleClassInterpretation" + + + // $ANTLR start "ruleClassInterpretation" + // InternalSolverLanguage.g:2088:1: ruleClassInterpretation returns [EObject current=null] : ( ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' ) ; + public final EObject ruleClassInterpretation() throws RecognitionException { + EObject current = null; + + Token lv_abstract_0_0=null; + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_7=null; + EObject lv_symbol_2_0 = null; + + EObject lv_supertypes_4_0 = null; + + EObject lv_fielt_6_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:2094:2: ( ( ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' ) ) + // InternalSolverLanguage.g:2095:2: ( ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' ) + { + // InternalSolverLanguage.g:2095:2: ( ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' ) + // InternalSolverLanguage.g:2096:3: ( (lv_abstract_0_0= 'abstract' ) ) otherlv_1= 'class' ( (lv_symbol_2_0= ruleModelSymbol ) ) (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? otherlv_5= '{' ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* otherlv_7= '}' + { + // InternalSolverLanguage.g:2096:3: ( (lv_abstract_0_0= 'abstract' ) ) + // InternalSolverLanguage.g:2097:4: (lv_abstract_0_0= 'abstract' ) + { + // InternalSolverLanguage.g:2097:4: (lv_abstract_0_0= 'abstract' ) + // InternalSolverLanguage.g:2098:5: lv_abstract_0_0= 'abstract' + { + lv_abstract_0_0=(Token)match(input,32,FOLLOW_24); + + newLeafNode(lv_abstract_0_0, grammarAccess.getClassInterpretationAccess().getAbstractAbstractKeyword_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getClassInterpretationRule()); + } + setWithLastConsumed(current, "abstract", true, "abstract"); + + + } + + + } + + otherlv_1=(Token)match(input,33,FOLLOW_10); + + newLeafNode(otherlv_1, grammarAccess.getClassInterpretationAccess().getClassKeyword_1()); + + // InternalSolverLanguage.g:2114:3: ( (lv_symbol_2_0= ruleModelSymbol ) ) + // InternalSolverLanguage.g:2115:4: (lv_symbol_2_0= ruleModelSymbol ) + { + // InternalSolverLanguage.g:2115:4: (lv_symbol_2_0= ruleModelSymbol ) + // InternalSolverLanguage.g:2116:5: lv_symbol_2_0= ruleModelSymbol + { + + newCompositeNode(grammarAccess.getClassInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); + + pushFollow(FOLLOW_25); + lv_symbol_2_0=ruleModelSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); + } + set( + current, + "symbol", + lv_symbol_2_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalSolverLanguage.g:2133:3: (otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ )? + int alt34=2; + int LA34_0 = input.LA(1); + + if ( (LA34_0==34) ) { + alt34=1; + } + switch (alt34) { + case 1 : + // InternalSolverLanguage.g:2134:4: otherlv_3= 'extends' ( (lv_supertypes_4_0= ruleModelSymbol ) )+ + { + otherlv_3=(Token)match(input,34,FOLLOW_10); + + newLeafNode(otherlv_3, grammarAccess.getClassInterpretationAccess().getExtendsKeyword_3_0()); + + // InternalSolverLanguage.g:2138:4: ( (lv_supertypes_4_0= ruleModelSymbol ) )+ + int cnt33=0; + loop33: + do { + int alt33=2; + int LA33_0 = input.LA(1); + + if ( (LA33_0==RULE_ID) ) { + alt33=1; + } + + + switch (alt33) { + case 1 : + // InternalSolverLanguage.g:2139:5: (lv_supertypes_4_0= ruleModelSymbol ) + { + // InternalSolverLanguage.g:2139:5: (lv_supertypes_4_0= ruleModelSymbol ) + // InternalSolverLanguage.g:2140:6: lv_supertypes_4_0= ruleModelSymbol + { + + newCompositeNode(grammarAccess.getClassInterpretationAccess().getSupertypesModelSymbolParserRuleCall_3_1_0()); + + pushFollow(FOLLOW_26); + lv_supertypes_4_0=ruleModelSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); + } + add( + current, + "supertypes", + lv_supertypes_4_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + if ( cnt33 >= 1 ) break loop33; + EarlyExitException eee = + new EarlyExitException(33, input); + throw eee; + } + cnt33++; + } while (true); + + + } + break; + + } + + otherlv_5=(Token)match(input,35,FOLLOW_27); + + newLeafNode(otherlv_5, grammarAccess.getClassInterpretationAccess().getLeftCurlyBracketKeyword_4()); + + // InternalSolverLanguage.g:2162:3: ( (lv_fielt_6_0= ruleFieldRelationInterpretation ) )* + loop35: + do { + int alt35=2; + int LA35_0 = input.LA(1); + + if ( (LA35_0==38) ) { + alt35=1; + } + + + switch (alt35) { + case 1 : + // InternalSolverLanguage.g:2163:4: (lv_fielt_6_0= ruleFieldRelationInterpretation ) + { + // InternalSolverLanguage.g:2163:4: (lv_fielt_6_0= ruleFieldRelationInterpretation ) + // InternalSolverLanguage.g:2164:5: lv_fielt_6_0= ruleFieldRelationInterpretation + { + + newCompositeNode(grammarAccess.getClassInterpretationAccess().getFieltFieldRelationInterpretationParserRuleCall_5_0()); + + pushFollow(FOLLOW_27); + lv_fielt_6_0=ruleFieldRelationInterpretation(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getClassInterpretationRule()); + } + add( + current, + "fielt", + lv_fielt_6_0, + "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + break loop35; + } + } while (true); + + otherlv_7=(Token)match(input,36,FOLLOW_2); + + newLeafNode(otherlv_7, grammarAccess.getClassInterpretationAccess().getRightCurlyBracketKeyword_6()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleClassInterpretation" + + + // $ANTLR start "entryRuleEnumInterpretation" + // InternalSolverLanguage.g:2189:1: entryRuleEnumInterpretation returns [EObject current=null] : iv_ruleEnumInterpretation= ruleEnumInterpretation EOF ; + public final EObject entryRuleEnumInterpretation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleEnumInterpretation = null; + + + try { + // InternalSolverLanguage.g:2189:59: (iv_ruleEnumInterpretation= ruleEnumInterpretation EOF ) + // InternalSolverLanguage.g:2190:2: iv_ruleEnumInterpretation= ruleEnumInterpretation EOF + { + newCompositeNode(grammarAccess.getEnumInterpretationRule()); + pushFollow(FOLLOW_1); + iv_ruleEnumInterpretation=ruleEnumInterpretation(); + + state._fsp--; + + current =iv_ruleEnumInterpretation; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleEnumInterpretation" + + + // $ANTLR start "ruleEnumInterpretation" + // InternalSolverLanguage.g:2196:1: ruleEnumInterpretation returns [EObject current=null] : (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) ; + public final EObject ruleEnumInterpretation() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + Token otherlv_4=null; + EObject lv_Symbol_1_0 = null; + + EObject lv_objects_3_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:2202:2: ( (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) ) + // InternalSolverLanguage.g:2203:2: (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) + { + // InternalSolverLanguage.g:2203:2: (otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' ) + // InternalSolverLanguage.g:2204:3: otherlv_0= 'enum' ( (lv_Symbol_1_0= ruleModelSymbol ) ) otherlv_2= '{' ( (lv_objects_3_0= ruleNamedObject ) )+ otherlv_4= '}' + { + otherlv_0=(Token)match(input,37,FOLLOW_10); + + newLeafNode(otherlv_0, grammarAccess.getEnumInterpretationAccess().getEnumKeyword_0()); + + // InternalSolverLanguage.g:2208:3: ( (lv_Symbol_1_0= ruleModelSymbol ) ) + // InternalSolverLanguage.g:2209:4: (lv_Symbol_1_0= ruleModelSymbol ) + { + // InternalSolverLanguage.g:2209:4: (lv_Symbol_1_0= ruleModelSymbol ) + // InternalSolverLanguage.g:2210:5: lv_Symbol_1_0= ruleModelSymbol + { + + newCompositeNode(grammarAccess.getEnumInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); + + pushFollow(FOLLOW_28); + lv_Symbol_1_0=ruleModelSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); + } + set( + current, + "Symbol", + lv_Symbol_1_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,35,FOLLOW_11); + + newLeafNode(otherlv_2, grammarAccess.getEnumInterpretationAccess().getLeftCurlyBracketKeyword_2()); + + // InternalSolverLanguage.g:2231:3: ( (lv_objects_3_0= ruleNamedObject ) )+ + int cnt36=0; + loop36: + do { + int alt36=2; + int LA36_0 = input.LA(1); + + if ( (LA36_0==26) ) { + alt36=1; + } + + + switch (alt36) { + case 1 : + // InternalSolverLanguage.g:2232:4: (lv_objects_3_0= ruleNamedObject ) + { + // InternalSolverLanguage.g:2232:4: (lv_objects_3_0= ruleNamedObject ) + // InternalSolverLanguage.g:2233:5: lv_objects_3_0= ruleNamedObject + { + + newCompositeNode(grammarAccess.getEnumInterpretationAccess().getObjectsNamedObjectParserRuleCall_3_0()); + + pushFollow(FOLLOW_29); + lv_objects_3_0=ruleNamedObject(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getEnumInterpretationRule()); + } + add( + current, + "objects", + lv_objects_3_0, + "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + default : + if ( cnt36 >= 1 ) break loop36; + EarlyExitException eee = + new EarlyExitException(36, input); + throw eee; + } + cnt36++; + } while (true); + + otherlv_4=(Token)match(input,36,FOLLOW_2); + + newLeafNode(otherlv_4, grammarAccess.getEnumInterpretationAccess().getRightCurlyBracketKeyword_4()); + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleEnumInterpretation" + + + // $ANTLR start "entryRuleFieldRelationInterpretation" + // InternalSolverLanguage.g:2258:1: entryRuleFieldRelationInterpretation returns [EObject current=null] : iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF ; + public final EObject entryRuleFieldRelationInterpretation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleFieldRelationInterpretation = null; + + + try { + // InternalSolverLanguage.g:2258:68: (iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF ) + // InternalSolverLanguage.g:2259:2: iv_ruleFieldRelationInterpretation= ruleFieldRelationInterpretation EOF + { + newCompositeNode(grammarAccess.getFieldRelationInterpretationRule()); + pushFollow(FOLLOW_1); + iv_ruleFieldRelationInterpretation=ruleFieldRelationInterpretation(); + + state._fsp--; + + current =iv_ruleFieldRelationInterpretation; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleFieldRelationInterpretation" + + + // $ANTLR start "ruleFieldRelationInterpretation" + // InternalSolverLanguage.g:2265:1: ruleFieldRelationInterpretation returns [EObject current=null] : ( ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) ; + public final EObject ruleFieldRelationInterpretation() throws RecognitionException { + EObject current = null; + + Token lv_containment_0_0=null; + Token otherlv_2=null; + EObject lv_symbol_1_0 = null; + + EObject lv_multiplicity_3_0 = null; + + EObject lv_target_4_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:2271:2: ( ( ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) ) + // InternalSolverLanguage.g:2272:2: ( ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) + { + // InternalSolverLanguage.g:2272:2: ( ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) ) + // InternalSolverLanguage.g:2273:3: ( (lv_containment_0_0= 'containment' ) ) ( (lv_symbol_1_0= ruleModelSymbol ) ) otherlv_2= ':' ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? ( (lv_target_4_0= ruleSymbol ) ) + { + // InternalSolverLanguage.g:2273:3: ( (lv_containment_0_0= 'containment' ) ) + // InternalSolverLanguage.g:2274:4: (lv_containment_0_0= 'containment' ) + { + // InternalSolverLanguage.g:2274:4: (lv_containment_0_0= 'containment' ) + // InternalSolverLanguage.g:2275:5: lv_containment_0_0= 'containment' + { + lv_containment_0_0=(Token)match(input,38,FOLLOW_10); + + newLeafNode(lv_containment_0_0, grammarAccess.getFieldRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getFieldRelationInterpretationRule()); + } + setWithLastConsumed(current, "containment", true, "containment"); + + + } + + + } + + // InternalSolverLanguage.g:2287:3: ( (lv_symbol_1_0= ruleModelSymbol ) ) + // InternalSolverLanguage.g:2288:4: (lv_symbol_1_0= ruleModelSymbol ) + { + // InternalSolverLanguage.g:2288:4: (lv_symbol_1_0= ruleModelSymbol ) + // InternalSolverLanguage.g:2289:5: lv_symbol_1_0= ruleModelSymbol + { + + newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_1_0()); + + pushFollow(FOLLOW_8); + lv_symbol_1_0=ruleModelSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); + } + set( + current, + "symbol", + lv_symbol_1_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_2=(Token)match(input,19,FOLLOW_30); + + newLeafNode(otherlv_2, grammarAccess.getFieldRelationInterpretationAccess().getColonKeyword_2()); + + // InternalSolverLanguage.g:2310:3: ( (lv_multiplicity_3_0= ruleMultiplicityDefinition ) )? + int alt37=2; + int LA37_0 = input.LA(1); + + if ( (LA37_0==RULE_INT) ) { + alt37=1; + } + switch (alt37) { + case 1 : + // InternalSolverLanguage.g:2311:4: (lv_multiplicity_3_0= ruleMultiplicityDefinition ) + { + // InternalSolverLanguage.g:2311:4: (lv_multiplicity_3_0= ruleMultiplicityDefinition ) + // InternalSolverLanguage.g:2312:5: lv_multiplicity_3_0= ruleMultiplicityDefinition + { + + newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getMultiplicityMultiplicityDefinitionParserRuleCall_3_0()); + + pushFollow(FOLLOW_18); + lv_multiplicity_3_0=ruleMultiplicityDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); + } + set( + current, + "multiplicity", + lv_multiplicity_3_0, + "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + } + + // InternalSolverLanguage.g:2329:3: ( (lv_target_4_0= ruleSymbol ) ) + // InternalSolverLanguage.g:2330:4: (lv_target_4_0= ruleSymbol ) + { + // InternalSolverLanguage.g:2330:4: (lv_target_4_0= ruleSymbol ) + // InternalSolverLanguage.g:2331:5: lv_target_4_0= ruleSymbol + { + + newCompositeNode(grammarAccess.getFieldRelationInterpretationAccess().getTargetSymbolParserRuleCall_4_0()); + + pushFollow(FOLLOW_2); + lv_target_4_0=ruleSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getFieldRelationInterpretationRule()); + } + set( + current, + "target", + lv_target_4_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleFieldRelationInterpretation" + + + // $ANTLR start "entryRuleGlobalRelationInterpretation" + // InternalSolverLanguage.g:2352:1: entryRuleGlobalRelationInterpretation returns [EObject current=null] : iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF ; + public final EObject entryRuleGlobalRelationInterpretation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleGlobalRelationInterpretation = null; + + + try { + // InternalSolverLanguage.g:2352:69: (iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF ) + // InternalSolverLanguage.g:2353:2: iv_ruleGlobalRelationInterpretation= ruleGlobalRelationInterpretation EOF + { + newCompositeNode(grammarAccess.getGlobalRelationInterpretationRule()); + pushFollow(FOLLOW_1); + iv_ruleGlobalRelationInterpretation=ruleGlobalRelationInterpretation(); + + state._fsp--; + + current =iv_ruleGlobalRelationInterpretation; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleGlobalRelationInterpretation" + + + // $ANTLR start "ruleGlobalRelationInterpretation" + // InternalSolverLanguage.g:2359:1: ruleGlobalRelationInterpretation returns [EObject current=null] : ( ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) ) ; + public final EObject ruleGlobalRelationInterpretation() throws RecognitionException { + EObject current = null; + + Token lv_containment_0_0=null; + Token otherlv_1=null; + Token otherlv_3=null; + EObject lv_symbol_2_0 = null; + + EObject lv_sourceMultiplicity_4_0 = null; + + EObject lv_source_5_0 = null; + + EObject lv_targetMultiplicity_6_0 = null; + + EObject lv_target_7_0 = null; + + + + enterRule(); + + try { + // InternalSolverLanguage.g:2365:2: ( ( ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) ) ) + // InternalSolverLanguage.g:2366:2: ( ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) ) + { + // InternalSolverLanguage.g:2366:2: ( ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) ) + // InternalSolverLanguage.g:2367:3: ( (lv_containment_0_0= 'containment' ) ) otherlv_1= 'relation' ( (lv_symbol_2_0= ruleModelSymbol ) ) otherlv_3= ':' ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? ( (lv_source_5_0= ruleSymbol ) ) ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? ( (lv_target_7_0= ruleSymbol ) ) + { + // InternalSolverLanguage.g:2367:3: ( (lv_containment_0_0= 'containment' ) ) + // InternalSolverLanguage.g:2368:4: (lv_containment_0_0= 'containment' ) + { + // InternalSolverLanguage.g:2368:4: (lv_containment_0_0= 'containment' ) + // InternalSolverLanguage.g:2369:5: lv_containment_0_0= 'containment' + { + lv_containment_0_0=(Token)match(input,38,FOLLOW_31); + + newLeafNode(lv_containment_0_0, grammarAccess.getGlobalRelationInterpretationAccess().getContainmentContainmentKeyword_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getGlobalRelationInterpretationRule()); + } + setWithLastConsumed(current, "containment", true, "containment"); + + + } + + + } + + otherlv_1=(Token)match(input,39,FOLLOW_10); + + newLeafNode(otherlv_1, grammarAccess.getGlobalRelationInterpretationAccess().getRelationKeyword_1()); + + // InternalSolverLanguage.g:2385:3: ( (lv_symbol_2_0= ruleModelSymbol ) ) + // InternalSolverLanguage.g:2386:4: (lv_symbol_2_0= ruleModelSymbol ) + { + // InternalSolverLanguage.g:2386:4: (lv_symbol_2_0= ruleModelSymbol ) + // InternalSolverLanguage.g:2387:5: lv_symbol_2_0= ruleModelSymbol + { + + newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSymbolModelSymbolParserRuleCall_2_0()); + + pushFollow(FOLLOW_8); + lv_symbol_2_0=ruleModelSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); + } + set( + current, + "symbol", + lv_symbol_2_0, + "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + + otherlv_3=(Token)match(input,19,FOLLOW_30); + + newLeafNode(otherlv_3, grammarAccess.getGlobalRelationInterpretationAccess().getColonKeyword_3()); + + // InternalSolverLanguage.g:2408:3: ( (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) )? + int alt38=2; + int LA38_0 = input.LA(1); + + if ( (LA38_0==RULE_INT) ) { + alt38=1; + } + switch (alt38) { + case 1 : + // InternalSolverLanguage.g:2409:4: (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) + { + // InternalSolverLanguage.g:2409:4: (lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition ) + // InternalSolverLanguage.g:2410:5: lv_sourceMultiplicity_4_0= ruleMultiplicityDefinition + { + + newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0()); + + pushFollow(FOLLOW_18); + lv_sourceMultiplicity_4_0=ruleMultiplicityDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); + } + set( + current, + "sourceMultiplicity", + lv_sourceMultiplicity_4_0, + "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + } + + // InternalSolverLanguage.g:2427:3: ( (lv_source_5_0= ruleSymbol ) ) + // InternalSolverLanguage.g:2428:4: (lv_source_5_0= ruleSymbol ) + { + // InternalSolverLanguage.g:2428:4: (lv_source_5_0= ruleSymbol ) + // InternalSolverLanguage.g:2429:5: lv_source_5_0= ruleSymbol + { + + newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getSourceSymbolParserRuleCall_5_0()); + + pushFollow(FOLLOW_30); + lv_source_5_0=ruleSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); + } + set( + current, + "source", + lv_source_5_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + + // InternalSolverLanguage.g:2446:3: ( (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) )? + int alt39=2; + int LA39_0 = input.LA(1); + + if ( (LA39_0==RULE_INT) ) { + alt39=1; + } + switch (alt39) { + case 1 : + // InternalSolverLanguage.g:2447:4: (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) + { + // InternalSolverLanguage.g:2447:4: (lv_targetMultiplicity_6_0= ruleMultiplicityDefinition ) + // InternalSolverLanguage.g:2448:5: lv_targetMultiplicity_6_0= ruleMultiplicityDefinition + { + + newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0()); + + pushFollow(FOLLOW_18); + lv_targetMultiplicity_6_0=ruleMultiplicityDefinition(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); + } + set( + current, + "targetMultiplicity", + lv_targetMultiplicity_6_0, + "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); + afterParserOrEnumRuleCall(); + + + } + + + } + break; + + } + + // InternalSolverLanguage.g:2465:3: ( (lv_target_7_0= ruleSymbol ) ) + // InternalSolverLanguage.g:2466:4: (lv_target_7_0= ruleSymbol ) + { + // InternalSolverLanguage.g:2466:4: (lv_target_7_0= ruleSymbol ) + // InternalSolverLanguage.g:2467:5: lv_target_7_0= ruleSymbol + { + + newCompositeNode(grammarAccess.getGlobalRelationInterpretationAccess().getTargetSymbolParserRuleCall_7_0()); + + pushFollow(FOLLOW_2); + lv_target_7_0=ruleSymbol(); + + state._fsp--; + + + if (current==null) { + current = createModelElementForParent(grammarAccess.getGlobalRelationInterpretationRule()); + } + set( + current, + "target", + lv_target_7_0, + "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + afterParserOrEnumRuleCall(); + + + } + + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleGlobalRelationInterpretation" + + + // $ANTLR start "entryRuleMultiplicityDefinition" + // InternalSolverLanguage.g:2488:1: entryRuleMultiplicityDefinition returns [EObject current=null] : iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF ; + public final EObject entryRuleMultiplicityDefinition() throws RecognitionException { + EObject current = null; + + EObject iv_ruleMultiplicityDefinition = null; + + + try { + // InternalSolverLanguage.g:2488:63: (iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF ) + // InternalSolverLanguage.g:2489:2: iv_ruleMultiplicityDefinition= ruleMultiplicityDefinition EOF + { + newCompositeNode(grammarAccess.getMultiplicityDefinitionRule()); + pushFollow(FOLLOW_1); + iv_ruleMultiplicityDefinition=ruleMultiplicityDefinition(); + + state._fsp--; + + current =iv_ruleMultiplicityDefinition; + match(input,EOF,FOLLOW_2); + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleMultiplicityDefinition" + + + // $ANTLR start "ruleMultiplicityDefinition" + // InternalSolverLanguage.g:2495:1: ruleMultiplicityDefinition returns [EObject current=null] : ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) ; + public final EObject ruleMultiplicityDefinition() throws RecognitionException { + EObject current = null; + + Token lv_lower_0_0=null; + Token otherlv_1=null; + Token lv_upper_2_0=null; + Token lv_unlimitedUpper_3_0=null; + + + enterRule(); + + try { + // InternalSolverLanguage.g:2501:2: ( ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) ) + // InternalSolverLanguage.g:2502:2: ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) + { + // InternalSolverLanguage.g:2502:2: ( ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) ) + // InternalSolverLanguage.g:2503:3: ( (lv_lower_0_0= RULE_INT ) ) otherlv_1= '..' ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) + { + // InternalSolverLanguage.g:2503:3: ( (lv_lower_0_0= RULE_INT ) ) + // InternalSolverLanguage.g:2504:4: (lv_lower_0_0= RULE_INT ) + { + // InternalSolverLanguage.g:2504:4: (lv_lower_0_0= RULE_INT ) + // InternalSolverLanguage.g:2505:5: lv_lower_0_0= RULE_INT + { + lv_lower_0_0=(Token)match(input,RULE_INT,FOLLOW_32); + + newLeafNode(lv_lower_0_0, grammarAccess.getMultiplicityDefinitionAccess().getLowerINTTerminalRuleCall_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); + } + setWithLastConsumed( + current, + "lower", + lv_lower_0_0, + "org.eclipse.xtext.common.Terminals.INT"); + + + } + + + } + + otherlv_1=(Token)match(input,40,FOLLOW_33); + + newLeafNode(otherlv_1, grammarAccess.getMultiplicityDefinitionAccess().getFullStopFullStopKeyword_1()); + + // InternalSolverLanguage.g:2525:3: ( ( (lv_upper_2_0= RULE_INT ) ) | ( (lv_unlimitedUpper_3_0= '*' ) ) ) + int alt40=2; + int LA40_0 = input.LA(1); + + if ( (LA40_0==RULE_INT) ) { + alt40=1; + } + else if ( (LA40_0==30) ) { + alt40=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 40, 0, input); + + throw nvae; + } + switch (alt40) { + case 1 : + // InternalSolverLanguage.g:2526:4: ( (lv_upper_2_0= RULE_INT ) ) + { + // InternalSolverLanguage.g:2526:4: ( (lv_upper_2_0= RULE_INT ) ) + // InternalSolverLanguage.g:2527:5: (lv_upper_2_0= RULE_INT ) + { + // InternalSolverLanguage.g:2527:5: (lv_upper_2_0= RULE_INT ) + // InternalSolverLanguage.g:2528:6: lv_upper_2_0= RULE_INT + { + lv_upper_2_0=(Token)match(input,RULE_INT,FOLLOW_2); + + newLeafNode(lv_upper_2_0, grammarAccess.getMultiplicityDefinitionAccess().getUpperINTTerminalRuleCall_2_0_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); + } + setWithLastConsumed( + current, + "upper", + lv_upper_2_0, + "org.eclipse.xtext.common.Terminals.INT"); + + + } + + + } + + + } + break; + case 2 : + // InternalSolverLanguage.g:2545:4: ( (lv_unlimitedUpper_3_0= '*' ) ) + { + // InternalSolverLanguage.g:2545:4: ( (lv_unlimitedUpper_3_0= '*' ) ) + // InternalSolverLanguage.g:2546:5: (lv_unlimitedUpper_3_0= '*' ) + { + // InternalSolverLanguage.g:2546:5: (lv_unlimitedUpper_3_0= '*' ) + // InternalSolverLanguage.g:2547:6: lv_unlimitedUpper_3_0= '*' + { + lv_unlimitedUpper_3_0=(Token)match(input,30,FOLLOW_2); + + newLeafNode(lv_unlimitedUpper_3_0, grammarAccess.getMultiplicityDefinitionAccess().getUnlimitedUpperAsteriskKeyword_2_1_0()); + + + if (current==null) { + current = createModelElement(grammarAccess.getMultiplicityDefinitionRule()); + } + setWithLastConsumed(current, "unlimitedUpper", true, "*"); + + + } + + + } + + + } + break; + + } + + + } + + + } + + + leaveRule(); + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleMultiplicityDefinition" + + // Delegated rules + + + + + public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); + public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); + public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x000000618BF10022L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000001000L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000020000L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x00000000440C6870L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000080000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x000000000001E000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000020L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000004000000L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000040020L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000030007820L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000010001000L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000030003820L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000020020L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000080002L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000003F00020L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000020000822L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000060020000L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000004046870L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000004006870L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000040000L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000200000000L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000C00000000L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000800000020L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000005000000000L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000800000000L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000001004000000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000003F00030L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000008000000000L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000010000000000L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000040000010L}); + +} \ No newline at end of file diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java new file mode 100644 index 00000000..52cb01b5 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/scoping/AbstractSolverLanguageScopeProvider.java @@ -0,0 +1,9 @@ +/* + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.scoping; + +import org.eclipse.xtext.scoping.impl.DelegatingScopeProvider; + +public abstract class AbstractSolverLanguageScopeProvider extends DelegatingScopeProvider { +} diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java new file mode 100644 index 00000000..80f9a02e --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java @@ -0,0 +1,781 @@ +/* + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.serializer; + +import com.google.inject.Inject; +import java.util.Set; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; +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.ClassInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.Constraint; +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.IrreflexiveClosure; +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.PatternBody; +import org.eclipse.viatra.solver.language.solverLanguage.Positive; +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.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.StringObject; +import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.True; +import org.eclipse.viatra.solver.language.solverLanguage.Unknown; +import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject; +import org.eclipse.viatra.solver.language.solverLanguage.Variable; +import org.eclipse.xtext.Action; +import org.eclipse.xtext.Parameter; +import org.eclipse.xtext.ParserRule; +import org.eclipse.xtext.serializer.ISerializationContext; +import org.eclipse.xtext.serializer.acceptor.SequenceFeeder; +import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer; +import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient; + +@SuppressWarnings("all") +public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticSequencer { + + @Inject + private SolverLanguageGrammarAccess grammarAccess; + + @Override + public void sequence(ISerializationContext context, EObject semanticObject) { + EPackage epackage = semanticObject.eClass().getEPackage(); + ParserRule rule = context.getParserRule(); + Action action = context.getAssignedAction(); + Set parameters = context.getEnabledBooleanParameters(); + if (epackage == SolverLanguagePackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case SolverLanguagePackage.ALL_INSTANCES: + sequence_AllInstances(context, (AllInstances) semanticObject); + return; + case SolverLanguagePackage.ALL_OBJECTS: + sequence_AllObjects(context, (AllObjects) semanticObject); + return; + case SolverLanguagePackage.BASIC_INTERPRETATION: + sequence_BasicInterpretation(context, (BasicInterpretation) semanticObject); + return; + case SolverLanguagePackage.BOOLEAN_FALSE: + sequence_BooleanValue(context, (BooleanFalse) semanticObject); + return; + case SolverLanguagePackage.BOOLEAN_OBJECT: + sequence_BooleanObject(context, (BooleanObject) semanticObject); + return; + case SolverLanguagePackage.BOOLEAN_SYMBOL: + sequence_BooleanSymbol(context, (BooleanSymbol) semanticObject); + return; + case SolverLanguagePackage.BOOLEAN_TRUE: + sequence_BooleanValue(context, (BooleanTrue) semanticObject); + return; + case SolverLanguagePackage.CLASS_INTERPRETATION: + sequence_ClassInterpretation(context, (ClassInterpretation) semanticObject); + return; + case SolverLanguagePackage.CONSTRAINT: + sequence_Constraint(context, (Constraint) semanticObject); + return; + case SolverLanguagePackage.DEFAULT_INTERPRETATION: + sequence_DefaultInterpretation(context, (DefaultInterpretation) semanticObject); + return; + case SolverLanguagePackage.ENUM_INTERPRETATION: + sequence_EnumInterpretation(context, (EnumInterpretation) semanticObject); + return; + case SolverLanguagePackage.EQUALS_SYMBOL: + sequence_EqualsSymbol(context, (EqualsSymbol) semanticObject); + return; + case SolverLanguagePackage.ERROR: + sequence_TruthValue(context, (org.eclipse.viatra.solver.language.solverLanguage.Error) semanticObject); + return; + case SolverLanguagePackage.ERROR_PREDICATE: + sequence_ErrorPredicate(context, (ErrorPredicate) semanticObject); + return; + case SolverLanguagePackage.EXIST_SYMBOL: + sequence_ExistSymbol(context, (ExistSymbol) semanticObject); + return; + case SolverLanguagePackage.FALSE: + sequence_TruthValue(context, (False) semanticObject); + return; + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION: + sequence_FieldRelationInterpretation(context, (FieldRelationInterpretation) semanticObject); + return; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION: + sequence_GlobalRelationInterpretation(context, (GlobalRelationInterpretation) semanticObject); + return; + case SolverLanguagePackage.INT_OBJECT: + sequence_IntObject(context, (IntObject) semanticObject); + return; + case SolverLanguagePackage.INTEGER_SYMBOL: + sequence_IntegerSymbol(context, (IntegerSymbol) semanticObject); + return; + case SolverLanguagePackage.IRREFLEXIVE_CLOSURE: + sequence_ClosureType(context, (IrreflexiveClosure) semanticObject); + return; + case SolverLanguagePackage.MODEL_SYMBOL: + sequence_ModelSymbol(context, (ModelSymbol) semanticObject); + return; + case SolverLanguagePackage.MULTIPLICITY_DEFINITION: + sequence_MultiplicityDefinition(context, (MultiplicityDefinition) semanticObject); + return; + case SolverLanguagePackage.NAMED_OBJECT: + sequence_NamedObject(context, (NamedObject) semanticObject); + return; + case SolverLanguagePackage.NEGATIVE: + sequence_Polarity(context, (Negative) semanticObject); + return; + case SolverLanguagePackage.PARAMETER: + sequence_Parameter(context, (org.eclipse.viatra.solver.language.solverLanguage.Parameter) semanticObject); + return; + case SolverLanguagePackage.PATTERN_BODY: + sequence_PatternBody(context, (PatternBody) semanticObject); + return; + case SolverLanguagePackage.POSITIVE: + sequence_Polarity(context, (Positive) semanticObject); + return; + case SolverLanguagePackage.PREDICATE_SYMBOL: + sequence_PredicateSymbol(context, (PredicateSymbol) semanticObject); + return; + case SolverLanguagePackage.PROBLEM: + sequence_Problem(context, (Problem) semanticObject); + return; + case SolverLanguagePackage.REAL_OBJECT: + sequence_RealObject(context, (RealObject) semanticObject); + return; + case SolverLanguagePackage.REAL_SYMBOL: + sequence_RealSymbol(context, (RealSymbol) semanticObject); + return; + case SolverLanguagePackage.REFLEXIVE_CLOSURE: + sequence_ClosureType(context, (ReflexiveClosure) semanticObject); + return; + case SolverLanguagePackage.STRING_OBJECT: + sequence_StringObject(context, (StringObject) semanticObject); + return; + case SolverLanguagePackage.STRING_SYMBOL: + sequence_StringSymbol(context, (StringSymbol) semanticObject); + return; + case SolverLanguagePackage.TRUE: + sequence_TruthValue(context, (True) semanticObject); + return; + case SolverLanguagePackage.UNKNOWN: + sequence_TruthValue(context, (Unknown) semanticObject); + return; + case SolverLanguagePackage.UNNAMED_OBJECT: + sequence_UnnamedObject(context, (UnnamedObject) semanticObject); + return; + case SolverLanguagePackage.VARIABLE: + sequence_Variable(context, (Variable) semanticObject); + return; + } + if (errorAcceptor != null) + errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); + } + + /** + * Contexts: + * ComplexObject returns AllInstances + * AllInstances returns AllInstances + * + * Constraint: + * symbol=Symbol + */ + protected void sequence_AllInstances(ISerializationContext context, AllInstances semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.ALL_INSTANCES__SYMBOL) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.ALL_INSTANCES__SYMBOL)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0(), semanticObject.getSymbol()); + feeder.finish(); + } + + + /** + * Contexts: + * ComplexObject returns AllObjects + * AllObjects returns AllObjects + * + * Constraint: + * {AllObjects} + */ + protected void sequence_AllObjects(ISerializationContext context, AllObjects semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Statement returns BasicInterpretation + * Interpretation returns BasicInterpretation + * BasicInterpretation returns BasicInterpretation + * + * Constraint: + * (symbol=Symbol objects+=ComplexObject* value=TruthValue) + */ + protected void sequence_BasicInterpretation(ISerializationContext context, BasicInterpretation semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * ComplexObject returns BooleanObject + * Object returns BooleanObject + * DataObject returns BooleanObject + * BooleanObject returns BooleanObject + * Literal returns BooleanObject + * + * Constraint: + * value=BooleanValue + */ + protected void sequence_BooleanObject(ISerializationContext context, BooleanObject semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOOLEAN_OBJECT__VALUE) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOOLEAN_OBJECT__VALUE)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0(), semanticObject.getValue()); + feeder.finish(); + } + + + /** + * Contexts: + * Symbol returns BooleanSymbol + * DataSymbol returns BooleanSymbol + * BooleanSymbol returns BooleanSymbol + * + * Constraint: + * {BooleanSymbol} + */ + protected void sequence_BooleanSymbol(ISerializationContext context, BooleanSymbol semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * BooleanValue returns BooleanFalse + * + * Constraint: + * {BooleanFalse} + */ + protected void sequence_BooleanValue(ISerializationContext context, BooleanFalse semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * BooleanValue returns BooleanTrue + * + * Constraint: + * {BooleanTrue} + */ + protected void sequence_BooleanValue(ISerializationContext context, BooleanTrue semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Statement returns ClassInterpretation + * Interpretation returns ClassInterpretation + * CDInterpretation returns ClassInterpretation + * ClassInterpretation returns ClassInterpretation + * + * Constraint: + * (abstract?='abstract' symbol=ModelSymbol supertypes+=ModelSymbol* fielt+=FieldRelationInterpretation*) + */ + protected void sequence_ClassInterpretation(ISerializationContext context, ClassInterpretation semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * ClosureType returns IrreflexiveClosure + * + * Constraint: + * {IrreflexiveClosure} + */ + protected void sequence_ClosureType(ISerializationContext context, IrreflexiveClosure semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * ClosureType returns ReflexiveClosure + * + * Constraint: + * {ReflexiveClosure} + */ + protected void sequence_ClosureType(ISerializationContext context, ReflexiveClosure semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Constraint returns Constraint + * + * Constraint: + * (polarity=Polarity? symbol=ModelSymbol (params+=Literal+ | (closureType=ClosureType params+=Literal params+=Literal))?) + */ + protected void sequence_Constraint(ISerializationContext context, Constraint semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Statement returns DefaultInterpretation + * Interpretation returns DefaultInterpretation + * DefaultInterpretation returns DefaultInterpretation + * + * Constraint: + * interpretation=BasicInterpretation + */ + protected void sequence_DefaultInterpretation(ISerializationContext context, DefaultInterpretation semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION__INTERPRETATION) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION__INTERPRETATION)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0(), semanticObject.getInterpretation()); + feeder.finish(); + } + + + /** + * Contexts: + * Statement returns EnumInterpretation + * Interpretation returns EnumInterpretation + * CDInterpretation returns EnumInterpretation + * EnumInterpretation returns EnumInterpretation + * + * Constraint: + * (Symbol=ModelSymbol objects+=NamedObject+) + */ + protected void sequence_EnumInterpretation(ISerializationContext context, EnumInterpretation semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Symbol returns EqualsSymbol + * PartialitySymbol returns EqualsSymbol + * EqualsSymbol returns EqualsSymbol + * + * Constraint: + * {EqualsSymbol} + */ + protected void sequence_EqualsSymbol(ISerializationContext context, EqualsSymbol semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Statement returns ErrorPredicate + * Predicate returns ErrorPredicate + * ErrorPredicate returns ErrorPredicate + * + * Constraint: + * (name=ID? parameters+=Parameter* (bodies+=PatternBody bodies+=PatternBody*)?) + */ + protected void sequence_ErrorPredicate(ISerializationContext context, ErrorPredicate semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Symbol returns ExistSymbol + * PartialitySymbol returns ExistSymbol + * ExistSymbol returns ExistSymbol + * + * Constraint: + * {ExistSymbol} + */ + protected void sequence_ExistSymbol(ISerializationContext context, ExistSymbol semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * FieldRelationInterpretation returns FieldRelationInterpretation + * + * Constraint: + * (containment?='containment' symbol=ModelSymbol multiplicity=MultiplicityDefinition? target=Symbol) + */ + protected void sequence_FieldRelationInterpretation(ISerializationContext context, FieldRelationInterpretation semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Statement returns GlobalRelationInterpretation + * Interpretation returns GlobalRelationInterpretation + * CDInterpretation returns GlobalRelationInterpretation + * GlobalRelationInterpretation returns GlobalRelationInterpretation + * + * Constraint: + * ( + * containment?='containment' + * symbol=ModelSymbol + * sourceMultiplicity=MultiplicityDefinition? + * source=Symbol + * targetMultiplicity=MultiplicityDefinition? + * target=Symbol + * ) + */ + protected void sequence_GlobalRelationInterpretation(ISerializationContext context, GlobalRelationInterpretation semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * ComplexObject returns IntObject + * Object returns IntObject + * DataObject returns IntObject + * IntObject returns IntObject + * Literal returns IntObject + * + * Constraint: + * value=INTLiteral + */ + protected void sequence_IntObject(ISerializationContext context, IntObject semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INT_OBJECT__VALUE) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INT_OBJECT__VALUE)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0(), semanticObject.getValue()); + feeder.finish(); + } + + + /** + * Contexts: + * Symbol returns IntegerSymbol + * DataSymbol returns IntegerSymbol + * IntegerSymbol returns IntegerSymbol + * + * Constraint: + * {IntegerSymbol} + */ + protected void sequence_IntegerSymbol(ISerializationContext context, IntegerSymbol semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Symbol returns ModelSymbol + * ModelSymbol returns ModelSymbol + * + * Constraint: + * name=ID + */ + protected void sequence_ModelSymbol(ISerializationContext context, ModelSymbol semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.MODEL_SYMBOL__NAME) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.MODEL_SYMBOL__NAME)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); + feeder.finish(); + } + + + /** + * Contexts: + * MultiplicityDefinition returns MultiplicityDefinition + * + * Constraint: + * (lower=INT (upper=INT | unlimitedUpper?='*')) + */ + protected void sequence_MultiplicityDefinition(ISerializationContext context, MultiplicityDefinition semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * ComplexObject returns NamedObject + * Object returns NamedObject + * NamedObject returns NamedObject + * + * Constraint: + * name=ID + */ + protected void sequence_NamedObject(ISerializationContext context, NamedObject semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NAMED_OBJECT__NAME) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NAMED_OBJECT__NAME)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName()); + feeder.finish(); + } + + + /** + * Contexts: + * Parameter returns Parameter + * + * Constraint: + * (variable=Variable type=Symbol?) + */ + protected void sequence_Parameter(ISerializationContext context, org.eclipse.viatra.solver.language.solverLanguage.Parameter semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * PatternBody returns PatternBody + * + * Constraint: + * constraints+=Constraint* + */ + protected void sequence_PatternBody(ISerializationContext context, PatternBody semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Polarity returns Negative + * + * Constraint: + * {Negative} + */ + protected void sequence_Polarity(ISerializationContext context, Negative semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Polarity returns Positive + * + * Constraint: + * {Positive} + */ + protected void sequence_Polarity(ISerializationContext context, Positive semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Statement returns PredicateSymbol + * Predicate returns PredicateSymbol + * PredicateSymbol returns PredicateSymbol + * + * Constraint: + * (symbol=ModelSymbol parameters+=Parameter* (bodies+=PatternBody bodies+=PatternBody*)?) + */ + protected void sequence_PredicateSymbol(ISerializationContext context, PredicateSymbol semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * Problem returns Problem + * + * Constraint: + * statements+=Statement+ + */ + protected void sequence_Problem(ISerializationContext context, Problem semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * ComplexObject returns RealObject + * Object returns RealObject + * DataObject returns RealObject + * RealObject returns RealObject + * Literal returns RealObject + * + * Constraint: + * value=REALLiteral + */ + protected void sequence_RealObject(ISerializationContext context, RealObject semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.REAL_OBJECT__VALUE) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.REAL_OBJECT__VALUE)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0(), semanticObject.getValue()); + feeder.finish(); + } + + + /** + * Contexts: + * Symbol returns RealSymbol + * DataSymbol returns RealSymbol + * RealSymbol returns RealSymbol + * + * Constraint: + * {RealSymbol} + */ + protected void sequence_RealSymbol(ISerializationContext context, RealSymbol semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * ComplexObject returns StringObject + * Object returns StringObject + * DataObject returns StringObject + * StringObject returns StringObject + * Literal returns StringObject + * + * Constraint: + * value=STRING + */ + protected void sequence_StringObject(ISerializationContext context, StringObject semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.STRING_OBJECT__VALUE) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.STRING_OBJECT__VALUE)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue()); + feeder.finish(); + } + + + /** + * Contexts: + * Symbol returns StringSymbol + * DataSymbol returns StringSymbol + * StringSymbol returns StringSymbol + * + * Constraint: + * {StringSymbol} + */ + protected void sequence_StringSymbol(ISerializationContext context, StringSymbol semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * TruthValue returns Error + * + * Constraint: + * {Error} + */ + protected void sequence_TruthValue(ISerializationContext context, org.eclipse.viatra.solver.language.solverLanguage.Error semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * TruthValue returns False + * + * Constraint: + * {False} + */ + protected void sequence_TruthValue(ISerializationContext context, False semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * TruthValue returns True + * + * Constraint: + * {True} + */ + protected void sequence_TruthValue(ISerializationContext context, True semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * TruthValue returns Unknown + * + * Constraint: + * {Unknown} + */ + protected void sequence_TruthValue(ISerializationContext context, Unknown semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * ComplexObject returns UnnamedObject + * Object returns UnnamedObject + * UnnamedObject returns UnnamedObject + * + * Constraint: + * name=ID + */ + protected void sequence_UnnamedObject(ISerializationContext context, UnnamedObject semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_OBJECT__NAME) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_OBJECT__NAME)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); + feeder.finish(); + } + + + /** + * Contexts: + * Literal returns Variable + * Variable returns Variable + * + * Constraint: + * name=ID + */ + protected void sequence_Variable(ISerializationContext context, Variable semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.VARIABLE__NAME) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.VARIABLE__NAME)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); + feeder.finish(); + } + + +} diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java new file mode 100644 index 00000000..5145bfac --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSyntacticSequencer.java @@ -0,0 +1,60 @@ +/* + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.serializer; + +import com.google.inject.Inject; +import java.util.List; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; +import org.eclipse.xtext.IGrammarAccess; +import org.eclipse.xtext.RuleCall; +import org.eclipse.xtext.nodemodel.INode; +import org.eclipse.xtext.serializer.analysis.GrammarAlias.AbstractElementAlias; +import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias; +import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable; +import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition; +import org.eclipse.xtext.serializer.sequencer.AbstractSyntacticSequencer; + +@SuppressWarnings("all") +public class SolverLanguageSyntacticSequencer extends AbstractSyntacticSequencer { + + protected SolverLanguageGrammarAccess grammarAccess; + protected AbstractElementAlias match_PatternBody_TrueKeyword_1_0_q; + + @Inject + protected void init(IGrammarAccess access) { + grammarAccess = (SolverLanguageGrammarAccess) access; + match_PatternBody_TrueKeyword_1_0_q = new TokenAlias(false, true, grammarAccess.getPatternBodyAccess().getTrueKeyword_1_0()); + } + + @Override + protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) { + return ""; + } + + + @Override + protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) { + if (transition.getAmbiguousSyntaxes().isEmpty()) return; + List transitionNodes = collectNodes(fromNode, toNode); + for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) { + List syntaxNodes = getNodesFor(transitionNodes, syntax); + if (match_PatternBody_TrueKeyword_1_0_q.equals(syntax)) + emit_PatternBody_TrueKeyword_1_0_q(semanticObject, getLastNavigableState(), syntaxNodes); + else acceptNodes(getLastNavigableState(), syntaxNodes); + } + } + + /** + * Ambiguous syntax: + * 'true'? + * + * This ambiguous syntax occurs at: + * (rule start) (ambiguity) (rule start) + */ + protected void emit_PatternBody_TrueKeyword_1_0_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + +} diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java new file mode 100644 index 00000000..fb5ea124 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/services/SolverLanguageGrammarAccess.java @@ -0,0 +1,2124 @@ +/* + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.services; + +import com.google.inject.Inject; +import com.google.inject.Singleton; +import java.util.List; +import org.eclipse.xtext.Action; +import org.eclipse.xtext.Alternatives; +import org.eclipse.xtext.Assignment; +import org.eclipse.xtext.Grammar; +import org.eclipse.xtext.GrammarUtil; +import org.eclipse.xtext.Group; +import org.eclipse.xtext.Keyword; +import org.eclipse.xtext.ParserRule; +import org.eclipse.xtext.RuleCall; +import org.eclipse.xtext.TerminalRule; +import org.eclipse.xtext.common.services.TerminalsGrammarAccess; +import org.eclipse.xtext.service.AbstractElementFinder.AbstractGrammarElementFinder; +import org.eclipse.xtext.service.GrammarProvider; + +@Singleton +public class SolverLanguageGrammarAccess extends AbstractGrammarElementFinder { + + public class ProblemElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Problem"); + private final Assignment cStatementsAssignment = (Assignment)rule.eContents().get(1); + private final RuleCall cStatementsStatementParserRuleCall_0 = (RuleCall)cStatementsAssignment.eContents().get(0); + + //Problem: + // statements+=Statement*; + @Override public ParserRule getRule() { return rule; } + + //statements+=Statement* + public Assignment getStatementsAssignment() { return cStatementsAssignment; } + + //Statement + public RuleCall getStatementsStatementParserRuleCall_0() { return cStatementsStatementParserRuleCall_0; } + } + public class StatementElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Statement"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cInterpretationParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cPredicateParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + + //Statement: + // Interpretation | Predicate; + @Override public ParserRule getRule() { return rule; } + + //Interpretation | Predicate + public Alternatives getAlternatives() { return cAlternatives; } + + //Interpretation + public RuleCall getInterpretationParserRuleCall_0() { return cInterpretationParserRuleCall_0; } + + //Predicate + public RuleCall getPredicateParserRuleCall_1() { return cPredicateParserRuleCall_1; } + } + public class REALLiteralElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.REALLiteral"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cHyphenMinusKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final RuleCall cINTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1); + private final Keyword cFullStopKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final RuleCall cINTTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3); + + //REALLiteral ecore::EBigDecimal: + // '-'? INT '.' INT; + @Override public ParserRule getRule() { return rule; } + + //'-'? INT '.' INT + public Group getGroup() { return cGroup; } + + //'-'? + public Keyword getHyphenMinusKeyword_0() { return cHyphenMinusKeyword_0; } + + //INT + public RuleCall getINTTerminalRuleCall_1() { return cINTTerminalRuleCall_1; } + + //'.' + public Keyword getFullStopKeyword_2() { return cFullStopKeyword_2; } + + //INT + public RuleCall getINTTerminalRuleCall_3() { return cINTTerminalRuleCall_3; } + } + public class INTLiteralElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.INTLiteral"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cHyphenMinusKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final RuleCall cINTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1); + + //INTLiteral ecore::EInt: + // '-'? INT; + @Override public ParserRule getRule() { return rule; } + + //'-'? INT + public Group getGroup() { return cGroup; } + + //'-'? + public Keyword getHyphenMinusKeyword_0() { return cHyphenMinusKeyword_0; } + + //INT + public RuleCall getINTTerminalRuleCall_1() { return cINTTerminalRuleCall_1; } + } + public class BooleanValueElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BooleanValue"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0); + private final Action cBooleanTrueAction_0_0 = (Action)cGroup_0.eContents().get(0); + private final Keyword cTrueKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1); + private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); + private final Keyword cFalseKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); + private final Action cBooleanFalseAction_1_1 = (Action)cGroup_1.eContents().get(1); + + //BooleanValue: + // {BooleanTrue} 'true' | 'false' {BooleanFalse}; + @Override public ParserRule getRule() { return rule; } + + //{BooleanTrue} 'true' | 'false' {BooleanFalse} + public Alternatives getAlternatives() { return cAlternatives; } + + //{BooleanTrue} 'true' + public Group getGroup_0() { return cGroup_0; } + + //{BooleanTrue} + public Action getBooleanTrueAction_0_0() { return cBooleanTrueAction_0_0; } + + //'true' + public Keyword getTrueKeyword_0_1() { return cTrueKeyword_0_1; } + + //'false' {BooleanFalse} + public Group getGroup_1() { return cGroup_1; } + + //'false' + public Keyword getFalseKeyword_1_0() { return cFalseKeyword_1_0; } + + //{BooleanFalse} + public Action getBooleanFalseAction_1_1() { return cBooleanFalseAction_1_1; } + } + public class TruthValueElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.TruthValue"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0); + private final Action cTrueAction_0_0 = (Action)cGroup_0.eContents().get(0); + private final Keyword cTrueKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1); + private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); + private final Action cFalseAction_1_0 = (Action)cGroup_1.eContents().get(0); + private final Keyword cFalseKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1); + private final Group cGroup_2 = (Group)cAlternatives.eContents().get(2); + private final Action cUnknownAction_2_0 = (Action)cGroup_2.eContents().get(0); + private final Keyword cUnknownKeyword_2_1 = (Keyword)cGroup_2.eContents().get(1); + private final Group cGroup_3 = (Group)cAlternatives.eContents().get(3); + private final Action cErrorAction_3_0 = (Action)cGroup_3.eContents().get(0); + private final Keyword cErrorKeyword_3_1 = (Keyword)cGroup_3.eContents().get(1); + + //TruthValue: + // {True} 'true' | {False} 'false' | {Unknown} 'unknown' | {Error} 'error'; + @Override public ParserRule getRule() { return rule; } + + //{True} 'true' | {False} 'false' | {Unknown} 'unknown' | {Error} 'error' + public Alternatives getAlternatives() { return cAlternatives; } + + //{True} 'true' + public Group getGroup_0() { return cGroup_0; } + + //{True} + public Action getTrueAction_0_0() { return cTrueAction_0_0; } + + //'true' + public Keyword getTrueKeyword_0_1() { return cTrueKeyword_0_1; } + + //{False} 'false' + public Group getGroup_1() { return cGroup_1; } + + //{False} + public Action getFalseAction_1_0() { return cFalseAction_1_0; } + + //'false' + public Keyword getFalseKeyword_1_1() { return cFalseKeyword_1_1; } + + //{Unknown} 'unknown' + public Group getGroup_2() { return cGroup_2; } + + //{Unknown} + public Action getUnknownAction_2_0() { return cUnknownAction_2_0; } + + //'unknown' + public Keyword getUnknownKeyword_2_1() { return cUnknownKeyword_2_1; } + + //{Error} 'error' + public Group getGroup_3() { return cGroup_3; } + + //{Error} + public Action getErrorAction_3_0() { return cErrorAction_3_0; } + + //'error' + public Keyword getErrorKeyword_3_1() { return cErrorKeyword_3_1; } + } + public class InterpretationElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Interpretation"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cBasicInterpretationParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cDefaultInterpretationParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + private final RuleCall cCDInterpretationParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); + + ///////////////////// + //// Core grammar + // /////////////////// + //Interpretation: + // BasicInterpretation | DefaultInterpretation | CDInterpretation; + @Override public ParserRule getRule() { return rule; } + + //BasicInterpretation | DefaultInterpretation | CDInterpretation + public Alternatives getAlternatives() { return cAlternatives; } + + //BasicInterpretation + public RuleCall getBasicInterpretationParserRuleCall_0() { return cBasicInterpretationParserRuleCall_0; } + + //DefaultInterpretation + public RuleCall getDefaultInterpretationParserRuleCall_1() { return cDefaultInterpretationParserRuleCall_1; } + + //CDInterpretation + public RuleCall getCDInterpretationParserRuleCall_2() { return cCDInterpretationParserRuleCall_2; } + } + public class BasicInterpretationElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BasicInterpretation"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cSymbolAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final RuleCall cSymbolSymbolParserRuleCall_0_0 = (RuleCall)cSymbolAssignment_0.eContents().get(0); + private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1); + private final Assignment cObjectsAssignment_2 = (Assignment)cGroup.eContents().get(2); + private final RuleCall cObjectsComplexObjectParserRuleCall_2_0 = (RuleCall)cObjectsAssignment_2.eContents().get(0); + private final Keyword cRightParenthesisKeyword_3 = (Keyword)cGroup.eContents().get(3); + private final Keyword cColonKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Assignment cValueAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final RuleCall cValueTruthValueParserRuleCall_5_0 = (RuleCall)cValueAssignment_5.eContents().get(0); + + //BasicInterpretation: + // symbol=Symbol '(' objects+=ComplexObject* ')' ':' value=TruthValue; + @Override public ParserRule getRule() { return rule; } + + //symbol=Symbol '(' objects+=ComplexObject* ')' ':' value=TruthValue + public Group getGroup() { return cGroup; } + + //symbol=Symbol + public Assignment getSymbolAssignment_0() { return cSymbolAssignment_0; } + + //Symbol + public RuleCall getSymbolSymbolParserRuleCall_0_0() { return cSymbolSymbolParserRuleCall_0_0; } + + //'(' + public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; } + + //objects+=ComplexObject* + public Assignment getObjectsAssignment_2() { return cObjectsAssignment_2; } + + //ComplexObject + public RuleCall getObjectsComplexObjectParserRuleCall_2_0() { return cObjectsComplexObjectParserRuleCall_2_0; } + + //')' + public Keyword getRightParenthesisKeyword_3() { return cRightParenthesisKeyword_3; } + + //':' + public Keyword getColonKeyword_4() { return cColonKeyword_4; } + + //value=TruthValue + public Assignment getValueAssignment_5() { return cValueAssignment_5; } + + //TruthValue + public RuleCall getValueTruthValueParserRuleCall_5_0() { return cValueTruthValueParserRuleCall_5_0; } + } + public class SymbolElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Symbol"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cModelSymbolParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cPartialitySymbolParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + private final RuleCall cDataSymbolParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); + + //Symbol: + // ModelSymbol | PartialitySymbol | DataSymbol; + @Override public ParserRule getRule() { return rule; } + + //ModelSymbol | PartialitySymbol | DataSymbol + public Alternatives getAlternatives() { return cAlternatives; } + + //ModelSymbol + public RuleCall getModelSymbolParserRuleCall_0() { return cModelSymbolParserRuleCall_0; } + + //PartialitySymbol + public RuleCall getPartialitySymbolParserRuleCall_1() { return cPartialitySymbolParserRuleCall_1; } + + //DataSymbol + public RuleCall getDataSymbolParserRuleCall_2() { return cDataSymbolParserRuleCall_2; } + } + public class ModelSymbolElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ModelSymbol"); + private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1); + private final RuleCall cNameIDTerminalRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0); + + //ModelSymbol: + // name=ID; + @Override public ParserRule getRule() { return rule; } + + //name=ID + public Assignment getNameAssignment() { return cNameAssignment; } + + //ID + public RuleCall getNameIDTerminalRuleCall_0() { return cNameIDTerminalRuleCall_0; } + } + public class PartialitySymbolElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.PartialitySymbol"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cExistSymbolParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cEqualsSymbolParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + + //PartialitySymbol: + // ExistSymbol | EqualsSymbol; + @Override public ParserRule getRule() { return rule; } + + //ExistSymbol | EqualsSymbol + public Alternatives getAlternatives() { return cAlternatives; } + + //ExistSymbol + public RuleCall getExistSymbolParserRuleCall_0() { return cExistSymbolParserRuleCall_0; } + + //EqualsSymbol + public RuleCall getEqualsSymbolParserRuleCall_1() { return cEqualsSymbolParserRuleCall_1; } + } + public class ExistSymbolElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ExistSymbol"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cExistsKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Action cExistSymbolAction_1 = (Action)cGroup.eContents().get(1); + + //ExistSymbol: + // 'exists' {ExistSymbol}; + @Override public ParserRule getRule() { return rule; } + + //'exists' {ExistSymbol} + public Group getGroup() { return cGroup; } + + //'exists' + public Keyword getExistsKeyword_0() { return cExistsKeyword_0; } + + //{ExistSymbol} + public Action getExistSymbolAction_1() { return cExistSymbolAction_1; } + } + public class EqualsSymbolElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.EqualsSymbol"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cEqualsKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Action cEqualsSymbolAction_1 = (Action)cGroup.eContents().get(1); + + //EqualsSymbol: + // 'equals' {EqualsSymbol}; + @Override public ParserRule getRule() { return rule; } + + //'equals' {EqualsSymbol} + public Group getGroup() { return cGroup; } + + //'equals' + public Keyword getEqualsKeyword_0() { return cEqualsKeyword_0; } + + //{EqualsSymbol} + public Action getEqualsSymbolAction_1() { return cEqualsSymbolAction_1; } + } + public class DataSymbolElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DataSymbol"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cBooleanSymbolParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cIntegerSymbolParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + private final RuleCall cRealSymbolParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); + private final RuleCall cStringSymbolParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); + + //DataSymbol: + // BooleanSymbol | IntegerSymbol | RealSymbol | StringSymbol; + @Override public ParserRule getRule() { return rule; } + + //BooleanSymbol | IntegerSymbol | RealSymbol | StringSymbol + public Alternatives getAlternatives() { return cAlternatives; } + + //BooleanSymbol + public RuleCall getBooleanSymbolParserRuleCall_0() { return cBooleanSymbolParserRuleCall_0; } + + //IntegerSymbol + public RuleCall getIntegerSymbolParserRuleCall_1() { return cIntegerSymbolParserRuleCall_1; } + + //RealSymbol + public RuleCall getRealSymbolParserRuleCall_2() { return cRealSymbolParserRuleCall_2; } + + //StringSymbol + public RuleCall getStringSymbolParserRuleCall_3() { return cStringSymbolParserRuleCall_3; } + } + public class BooleanSymbolElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BooleanSymbol"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cBoolKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Action cBooleanSymbolAction_1 = (Action)cGroup.eContents().get(1); + + //BooleanSymbol: + // 'bool' {BooleanSymbol}; + @Override public ParserRule getRule() { return rule; } + + //'bool' {BooleanSymbol} + public Group getGroup() { return cGroup; } + + //'bool' + public Keyword getBoolKeyword_0() { return cBoolKeyword_0; } + + //{BooleanSymbol} + public Action getBooleanSymbolAction_1() { return cBooleanSymbolAction_1; } + } + public class IntegerSymbolElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.IntegerSymbol"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cIntKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Action cIntegerSymbolAction_1 = (Action)cGroup.eContents().get(1); + + //IntegerSymbol: + // 'int' {IntegerSymbol}; + @Override public ParserRule getRule() { return rule; } + + //'int' {IntegerSymbol} + public Group getGroup() { return cGroup; } + + //'int' + public Keyword getIntKeyword_0() { return cIntKeyword_0; } + + //{IntegerSymbol} + public Action getIntegerSymbolAction_1() { return cIntegerSymbolAction_1; } + } + public class RealSymbolElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.RealSymbol"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cRealKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Action cRealSymbolAction_1 = (Action)cGroup.eContents().get(1); + + //RealSymbol: + // 'real' {RealSymbol}; + @Override public ParserRule getRule() { return rule; } + + //'real' {RealSymbol} + public Group getGroup() { return cGroup; } + + //'real' + public Keyword getRealKeyword_0() { return cRealKeyword_0; } + + //{RealSymbol} + public Action getRealSymbolAction_1() { return cRealSymbolAction_1; } + } + public class StringSymbolElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.StringSymbol"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cStringKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Action cStringSymbolAction_1 = (Action)cGroup.eContents().get(1); + + //StringSymbol: + // 'string' {StringSymbol}; + @Override public ParserRule getRule() { return rule; } + + //'string' {StringSymbol} + public Group getGroup() { return cGroup; } + + //'string' + public Keyword getStringKeyword_0() { return cStringKeyword_0; } + + //{StringSymbol} + public Action getStringSymbolAction_1() { return cStringSymbolAction_1; } + } + public class ComplexObjectElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ComplexObject"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cObjectParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cAllInstancesParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + private final RuleCall cAllObjectsParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); + + //ComplexObject: + // Object | AllInstances | AllObjects; + @Override public ParserRule getRule() { return rule; } + + //Object | AllInstances | AllObjects + public Alternatives getAlternatives() { return cAlternatives; } + + //Object + public RuleCall getObjectParserRuleCall_0() { return cObjectParserRuleCall_0; } + + //AllInstances + public RuleCall getAllInstancesParserRuleCall_1() { return cAllInstancesParserRuleCall_1; } + + //AllObjects + public RuleCall getAllObjectsParserRuleCall_2() { return cAllObjectsParserRuleCall_2; } + } + public class ObjectElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Object"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cNamedObjectParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cUnnamedObjectParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + private final RuleCall cDataObjectParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); + + //Object: + // NamedObject | UnnamedObject | DataObject; + @Override public ParserRule getRule() { return rule; } + + //NamedObject | UnnamedObject | DataObject + public Alternatives getAlternatives() { return cAlternatives; } + + //NamedObject + public RuleCall getNamedObjectParserRuleCall_0() { return cNamedObjectParserRuleCall_0; } + + //UnnamedObject + public RuleCall getUnnamedObjectParserRuleCall_1() { return cUnnamedObjectParserRuleCall_1; } + + //DataObject + public RuleCall getDataObjectParserRuleCall_2() { return cDataObjectParserRuleCall_2; } + } + public class NamedObjectElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.NamedObject"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cApostropheKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cNameIDTerminalRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); + private final Keyword cApostropheKeyword_2 = (Keyword)cGroup.eContents().get(2); + + //NamedObject: + // "'" name=ID "'"; + @Override public ParserRule getRule() { return rule; } + + //"'" name=ID "'" + public Group getGroup() { return cGroup; } + + //"'" + public Keyword getApostropheKeyword_0() { return cApostropheKeyword_0; } + + //name=ID + public Assignment getNameAssignment_1() { return cNameAssignment_1; } + + //ID + public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; } + + //"'" + public Keyword getApostropheKeyword_2() { return cApostropheKeyword_2; } + } + public class UnnamedObjectElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.UnnamedObject"); + private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1); + private final RuleCall cNameIDTerminalRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0); + + //UnnamedObject: + // name=ID; + @Override public ParserRule getRule() { return rule; } + + //name=ID + public Assignment getNameAssignment() { return cNameAssignment; } + + //ID + public RuleCall getNameIDTerminalRuleCall_0() { return cNameIDTerminalRuleCall_0; } + } + public class DataObjectElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DataObject"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cBooleanObjectParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cIntObjectParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + private final RuleCall cRealObjectParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); + private final RuleCall cStringObjectParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); + + //DataObject: + // BooleanObject | IntObject | RealObject | StringObject; + @Override public ParserRule getRule() { return rule; } + + //BooleanObject | IntObject | RealObject | StringObject + public Alternatives getAlternatives() { return cAlternatives; } + + //BooleanObject + public RuleCall getBooleanObjectParserRuleCall_0() { return cBooleanObjectParserRuleCall_0; } + + //IntObject + public RuleCall getIntObjectParserRuleCall_1() { return cIntObjectParserRuleCall_1; } + + //RealObject + public RuleCall getRealObjectParserRuleCall_2() { return cRealObjectParserRuleCall_2; } + + //StringObject + public RuleCall getStringObjectParserRuleCall_3() { return cStringObjectParserRuleCall_3; } + } + public class BooleanObjectElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.BooleanObject"); + private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); + private final RuleCall cValueBooleanValueParserRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); + + //BooleanObject: + // value=BooleanValue; + @Override public ParserRule getRule() { return rule; } + + //value=BooleanValue + public Assignment getValueAssignment() { return cValueAssignment; } + + //BooleanValue + public RuleCall getValueBooleanValueParserRuleCall_0() { return cValueBooleanValueParserRuleCall_0; } + } + public class IntObjectElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.IntObject"); + private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); + private final RuleCall cValueINTLiteralParserRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); + + //IntObject: + // value=INTLiteral; + @Override public ParserRule getRule() { return rule; } + + //value=INTLiteral + public Assignment getValueAssignment() { return cValueAssignment; } + + //INTLiteral + public RuleCall getValueINTLiteralParserRuleCall_0() { return cValueINTLiteralParserRuleCall_0; } + } + public class RealObjectElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.RealObject"); + private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); + private final RuleCall cValueREALLiteralParserRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); + + //RealObject: + // value=REALLiteral; + @Override public ParserRule getRule() { return rule; } + + //value=REALLiteral + public Assignment getValueAssignment() { return cValueAssignment; } + + //REALLiteral + public RuleCall getValueREALLiteralParserRuleCall_0() { return cValueREALLiteralParserRuleCall_0; } + } + public class StringObjectElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.StringObject"); + private final Assignment cValueAssignment = (Assignment)rule.eContents().get(1); + private final RuleCall cValueSTRINGTerminalRuleCall_0 = (RuleCall)cValueAssignment.eContents().get(0); + + //StringObject: + // value=STRING; + @Override public ParserRule getRule() { return rule; } + + //value=STRING + public Assignment getValueAssignment() { return cValueAssignment; } + + //STRING + public RuleCall getValueSTRINGTerminalRuleCall_0() { return cValueSTRINGTerminalRuleCall_0; } + } + public class PredicateElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Predicate"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cPredicateSymbolParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cErrorPredicateParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + + ///////////////////// + //// Predicte grammar + ///////////////////// + //Predicate: + // PredicateSymbol | ErrorPredicate; + @Override public ParserRule getRule() { return rule; } + + //PredicateSymbol | ErrorPredicate + public Alternatives getAlternatives() { return cAlternatives; } + + //PredicateSymbol + public RuleCall getPredicateSymbolParserRuleCall_0() { return cPredicateSymbolParserRuleCall_0; } + + //ErrorPredicate + public RuleCall getErrorPredicateParserRuleCall_1() { return cErrorPredicateParserRuleCall_1; } + } + public class PredicateSymbolElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.PredicateSymbol"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cPredicateKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cSymbolModelSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0); + private final Keyword cLeftParenthesisKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final Assignment cParametersAssignment_3 = (Assignment)cGroup.eContents().get(3); + private final RuleCall cParametersParameterParserRuleCall_3_0 = (RuleCall)cParametersAssignment_3.eContents().get(0); + private final Keyword cRightParenthesisKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Keyword cColonKeyword_5 = (Keyword)cGroup.eContents().get(5); + private final Alternatives cAlternatives_6 = (Alternatives)cGroup.eContents().get(6); + private final Keyword cFalseKeyword_6_0 = (Keyword)cAlternatives_6.eContents().get(0); + private final Group cGroup_6_1 = (Group)cAlternatives_6.eContents().get(1); + private final Assignment cBodiesAssignment_6_1_0 = (Assignment)cGroup_6_1.eContents().get(0); + private final RuleCall cBodiesPatternBodyParserRuleCall_6_1_0_0 = (RuleCall)cBodiesAssignment_6_1_0.eContents().get(0); + private final Group cGroup_6_1_1 = (Group)cGroup_6_1.eContents().get(1); + private final Keyword cVerticalLineKeyword_6_1_1_0 = (Keyword)cGroup_6_1_1.eContents().get(0); + private final Assignment cBodiesAssignment_6_1_1_1 = (Assignment)cGroup_6_1_1.eContents().get(1); + private final RuleCall cBodiesPatternBodyParserRuleCall_6_1_1_1_0 = (RuleCall)cBodiesAssignment_6_1_1_1.eContents().get(0); + private final Keyword cFullStopKeyword_7 = (Keyword)cGroup.eContents().get(7); + + //PredicateSymbol: + // 'predicate' symbol=ModelSymbol '(' parameters+=Parameter* ')' ':' ('false' | bodies+=PatternBody ('|' + // bodies+=PatternBody)*) '.'; + @Override public ParserRule getRule() { return rule; } + + //'predicate' symbol=ModelSymbol '(' parameters+=Parameter* ')' ':' ('false' | bodies+=PatternBody ('|' + //bodies+=PatternBody)*) '.' + public Group getGroup() { return cGroup; } + + //'predicate' + public Keyword getPredicateKeyword_0() { return cPredicateKeyword_0; } + + //symbol=ModelSymbol + public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; } + + //ModelSymbol + public RuleCall getSymbolModelSymbolParserRuleCall_1_0() { return cSymbolModelSymbolParserRuleCall_1_0; } + + //'(' + public Keyword getLeftParenthesisKeyword_2() { return cLeftParenthesisKeyword_2; } + + //parameters+=Parameter* + public Assignment getParametersAssignment_3() { return cParametersAssignment_3; } + + //Parameter + public RuleCall getParametersParameterParserRuleCall_3_0() { return cParametersParameterParserRuleCall_3_0; } + + //')' + public Keyword getRightParenthesisKeyword_4() { return cRightParenthesisKeyword_4; } + + //':' + public Keyword getColonKeyword_5() { return cColonKeyword_5; } + + //'false' | bodies+=PatternBody ('|' bodies+=PatternBody)* + public Alternatives getAlternatives_6() { return cAlternatives_6; } + + //'false' + public Keyword getFalseKeyword_6_0() { return cFalseKeyword_6_0; } + + //bodies+=PatternBody ('|' bodies+=PatternBody)* + public Group getGroup_6_1() { return cGroup_6_1; } + + //bodies+=PatternBody + public Assignment getBodiesAssignment_6_1_0() { return cBodiesAssignment_6_1_0; } + + //PatternBody + public RuleCall getBodiesPatternBodyParserRuleCall_6_1_0_0() { return cBodiesPatternBodyParserRuleCall_6_1_0_0; } + + //('|' bodies+=PatternBody)* + public Group getGroup_6_1_1() { return cGroup_6_1_1; } + + //'|' + public Keyword getVerticalLineKeyword_6_1_1_0() { return cVerticalLineKeyword_6_1_1_0; } + + //bodies+=PatternBody + public Assignment getBodiesAssignment_6_1_1_1() { return cBodiesAssignment_6_1_1_1; } + + //PatternBody + public RuleCall getBodiesPatternBodyParserRuleCall_6_1_1_1_0() { return cBodiesPatternBodyParserRuleCall_6_1_1_1_0; } + + //'.' + public Keyword getFullStopKeyword_7() { return cFullStopKeyword_7; } + } + public class ErrorPredicateElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ErrorPredicate"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cErrorPredicateAction_0 = (Action)cGroup.eContents().get(0); + private final Keyword cErrorKeyword_1 = (Keyword)cGroup.eContents().get(1); + private final Assignment cNameAssignment_2 = (Assignment)cGroup.eContents().get(2); + private final RuleCall cNameIDTerminalRuleCall_2_0 = (RuleCall)cNameAssignment_2.eContents().get(0); + private final Group cGroup_3 = (Group)cGroup.eContents().get(3); + private final Keyword cLeftParenthesisKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); + private final Assignment cParametersAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); + private final RuleCall cParametersParameterParserRuleCall_3_1_0 = (RuleCall)cParametersAssignment_3_1.eContents().get(0); + private final Keyword cRightParenthesisKeyword_3_2 = (Keyword)cGroup_3.eContents().get(2); + private final Keyword cColonKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Alternatives cAlternatives_5 = (Alternatives)cGroup.eContents().get(5); + private final Keyword cFalseKeyword_5_0 = (Keyword)cAlternatives_5.eContents().get(0); + private final Group cGroup_5_1 = (Group)cAlternatives_5.eContents().get(1); + private final Assignment cBodiesAssignment_5_1_0 = (Assignment)cGroup_5_1.eContents().get(0); + private final RuleCall cBodiesPatternBodyParserRuleCall_5_1_0_0 = (RuleCall)cBodiesAssignment_5_1_0.eContents().get(0); + private final Group cGroup_5_1_1 = (Group)cGroup_5_1.eContents().get(1); + private final Keyword cVerticalLineKeyword_5_1_1_0 = (Keyword)cGroup_5_1_1.eContents().get(0); + private final Assignment cBodiesAssignment_5_1_1_1 = (Assignment)cGroup_5_1_1.eContents().get(1); + private final RuleCall cBodiesPatternBodyParserRuleCall_5_1_1_1_0 = (RuleCall)cBodiesAssignment_5_1_1_1.eContents().get(0); + private final Keyword cFullStopKeyword_6 = (Keyword)cGroup.eContents().get(6); + + //ErrorPredicate: + // {ErrorPredicate} 'error' name=ID? ('(' parameters+=Parameter* ')') ':' ('false' | bodies+=PatternBody ('|' + // bodies+=PatternBody)*) '.'; + @Override public ParserRule getRule() { return rule; } + + //{ErrorPredicate} 'error' name=ID? ('(' parameters+=Parameter* ')') ':' ('false' | bodies+=PatternBody ('|' + //bodies+=PatternBody)*) '.' + public Group getGroup() { return cGroup; } + + //{ErrorPredicate} + public Action getErrorPredicateAction_0() { return cErrorPredicateAction_0; } + + //'error' + public Keyword getErrorKeyword_1() { return cErrorKeyword_1; } + + //name=ID? + public Assignment getNameAssignment_2() { return cNameAssignment_2; } + + //ID + public RuleCall getNameIDTerminalRuleCall_2_0() { return cNameIDTerminalRuleCall_2_0; } + + //'(' parameters+=Parameter* ')' + public Group getGroup_3() { return cGroup_3; } + + //'(' + public Keyword getLeftParenthesisKeyword_3_0() { return cLeftParenthesisKeyword_3_0; } + + //parameters+=Parameter* + public Assignment getParametersAssignment_3_1() { return cParametersAssignment_3_1; } + + //Parameter + public RuleCall getParametersParameterParserRuleCall_3_1_0() { return cParametersParameterParserRuleCall_3_1_0; } + + //')' + public Keyword getRightParenthesisKeyword_3_2() { return cRightParenthesisKeyword_3_2; } + + //':' + public Keyword getColonKeyword_4() { return cColonKeyword_4; } + + //'false' | bodies+=PatternBody ('|' bodies+=PatternBody)* + public Alternatives getAlternatives_5() { return cAlternatives_5; } + + //'false' + public Keyword getFalseKeyword_5_0() { return cFalseKeyword_5_0; } + + //bodies+=PatternBody ('|' bodies+=PatternBody)* + public Group getGroup_5_1() { return cGroup_5_1; } + + //bodies+=PatternBody + public Assignment getBodiesAssignment_5_1_0() { return cBodiesAssignment_5_1_0; } + + //PatternBody + public RuleCall getBodiesPatternBodyParserRuleCall_5_1_0_0() { return cBodiesPatternBodyParserRuleCall_5_1_0_0; } + + //('|' bodies+=PatternBody)* + public Group getGroup_5_1_1() { return cGroup_5_1_1; } + + //'|' + public Keyword getVerticalLineKeyword_5_1_1_0() { return cVerticalLineKeyword_5_1_1_0; } + + //bodies+=PatternBody + public Assignment getBodiesAssignment_5_1_1_1() { return cBodiesAssignment_5_1_1_1; } + + //PatternBody + public RuleCall getBodiesPatternBodyParserRuleCall_5_1_1_1_0() { return cBodiesPatternBodyParserRuleCall_5_1_1_1_0; } + + //'.' + public Keyword getFullStopKeyword_6() { return cFullStopKeyword_6; } + } + public class ParameterElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Parameter"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cVariableAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final RuleCall cVariableVariableParserRuleCall_0_0 = (RuleCall)cVariableAssignment_0.eContents().get(0); + private final Group cGroup_1 = (Group)cGroup.eContents().get(1); + private final Keyword cColonKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); + private final Assignment cTypeAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1); + private final RuleCall cTypeSymbolParserRuleCall_1_1_0 = (RuleCall)cTypeAssignment_1_1.eContents().get(0); + + //Parameter: + // variable=Variable (':' type=Symbol)?; + @Override public ParserRule getRule() { return rule; } + + //variable=Variable (':' type=Symbol)? + public Group getGroup() { return cGroup; } + + //variable=Variable + public Assignment getVariableAssignment_0() { return cVariableAssignment_0; } + + //Variable + public RuleCall getVariableVariableParserRuleCall_0_0() { return cVariableVariableParserRuleCall_0_0; } + + //(':' type=Symbol)? + public Group getGroup_1() { return cGroup_1; } + + //':' + public Keyword getColonKeyword_1_0() { return cColonKeyword_1_0; } + + //type=Symbol + public Assignment getTypeAssignment_1_1() { return cTypeAssignment_1_1; } + + //Symbol + public RuleCall getTypeSymbolParserRuleCall_1_1_0() { return cTypeSymbolParserRuleCall_1_1_0; } + } + public class PatternBodyElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.PatternBody"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cPatternBodyAction_0 = (Action)cGroup.eContents().get(0); + private final Alternatives cAlternatives_1 = (Alternatives)cGroup.eContents().get(1); + private final Keyword cTrueKeyword_1_0 = (Keyword)cAlternatives_1.eContents().get(0); + private final Assignment cConstraintsAssignment_1_1 = (Assignment)cAlternatives_1.eContents().get(1); + private final RuleCall cConstraintsConstraintParserRuleCall_1_1_0 = (RuleCall)cConstraintsAssignment_1_1.eContents().get(0); + + //PatternBody: + // {PatternBody} ('true' | constraints+=Constraint*); + @Override public ParserRule getRule() { return rule; } + + //{PatternBody} ('true' | constraints+=Constraint*) + public Group getGroup() { return cGroup; } + + //{PatternBody} + public Action getPatternBodyAction_0() { return cPatternBodyAction_0; } + + //'true' | constraints+=Constraint* + public Alternatives getAlternatives_1() { return cAlternatives_1; } + + //'true' + public Keyword getTrueKeyword_1_0() { return cTrueKeyword_1_0; } + + //constraints+=Constraint* + public Assignment getConstraintsAssignment_1_1() { return cConstraintsAssignment_1_1; } + + //Constraint + public RuleCall getConstraintsConstraintParserRuleCall_1_1_0() { return cConstraintsConstraintParserRuleCall_1_1_0; } + } + public class PolarityElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Polarity"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0); + private final Action cPositiveAction_0_0 = (Action)cGroup_0.eContents().get(0); + private final Keyword cPlusSignKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1); + private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); + private final Action cNegativeAction_1_0 = (Action)cGroup_1.eContents().get(0); + private final Keyword cHyphenMinusKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1); + + //Polarity: + // {Positive} '+' | {Negative} '-'; + @Override public ParserRule getRule() { return rule; } + + //{Positive} '+' | {Negative} '-' + public Alternatives getAlternatives() { return cAlternatives; } + + //{Positive} '+' + public Group getGroup_0() { return cGroup_0; } + + //{Positive} + public Action getPositiveAction_0_0() { return cPositiveAction_0_0; } + + //'+' + public Keyword getPlusSignKeyword_0_1() { return cPlusSignKeyword_0_1; } + + //{Negative} '-' + public Group getGroup_1() { return cGroup_1; } + + //{Negative} + public Action getNegativeAction_1_0() { return cNegativeAction_1_0; } + + //'-' + public Keyword getHyphenMinusKeyword_1_1() { return cHyphenMinusKeyword_1_1; } + } + public class ConstraintElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Constraint"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cPolarityAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final RuleCall cPolarityPolarityParserRuleCall_0_0 = (RuleCall)cPolarityAssignment_0.eContents().get(0); + private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cSymbolModelSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0); + private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2); + private final Group cGroup_2_0 = (Group)cAlternatives_2.eContents().get(0); + private final Keyword cLeftParenthesisKeyword_2_0_0 = (Keyword)cGroup_2_0.eContents().get(0); + private final Assignment cParamsAssignment_2_0_1 = (Assignment)cGroup_2_0.eContents().get(1); + private final RuleCall cParamsLiteralParserRuleCall_2_0_1_0 = (RuleCall)cParamsAssignment_2_0_1.eContents().get(0); + private final Keyword cRightParenthesisKeyword_2_0_2 = (Keyword)cGroup_2_0.eContents().get(2); + private final Group cGroup_2_1 = (Group)cAlternatives_2.eContents().get(1); + private final Assignment cClosureTypeAssignment_2_1_0 = (Assignment)cGroup_2_1.eContents().get(0); + private final RuleCall cClosureTypeClosureTypeParserRuleCall_2_1_0_0 = (RuleCall)cClosureTypeAssignment_2_1_0.eContents().get(0); + private final Keyword cLeftParenthesisKeyword_2_1_1 = (Keyword)cGroup_2_1.eContents().get(1); + private final Assignment cParamsAssignment_2_1_2 = (Assignment)cGroup_2_1.eContents().get(2); + private final RuleCall cParamsLiteralParserRuleCall_2_1_2_0 = (RuleCall)cParamsAssignment_2_1_2.eContents().get(0); + private final Assignment cParamsAssignment_2_1_3 = (Assignment)cGroup_2_1.eContents().get(3); + private final RuleCall cParamsLiteralParserRuleCall_2_1_3_0 = (RuleCall)cParamsAssignment_2_1_3.eContents().get(0); + private final Keyword cRightParenthesisKeyword_2_1_4 = (Keyword)cGroup_2_1.eContents().get(4); + + //Constraint: + // polarity=Polarity? symbol=ModelSymbol ('(' params+=Literal* ')' | closureType=ClosureType '(' params+=Literal + // params+=Literal ')'); + @Override public ParserRule getRule() { return rule; } + + //polarity=Polarity? symbol=ModelSymbol ('(' params+=Literal* ')' | closureType=ClosureType '(' params+=Literal + //params+=Literal ')') + public Group getGroup() { return cGroup; } + + //polarity=Polarity? + public Assignment getPolarityAssignment_0() { return cPolarityAssignment_0; } + + //Polarity + public RuleCall getPolarityPolarityParserRuleCall_0_0() { return cPolarityPolarityParserRuleCall_0_0; } + + //symbol=ModelSymbol + public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; } + + //ModelSymbol + public RuleCall getSymbolModelSymbolParserRuleCall_1_0() { return cSymbolModelSymbolParserRuleCall_1_0; } + + //'(' params+=Literal* ')' | closureType=ClosureType '(' params+=Literal params+=Literal ')' + public Alternatives getAlternatives_2() { return cAlternatives_2; } + + //'(' params+=Literal* ')' + public Group getGroup_2_0() { return cGroup_2_0; } + + //'(' + public Keyword getLeftParenthesisKeyword_2_0_0() { return cLeftParenthesisKeyword_2_0_0; } + + //params+=Literal* + public Assignment getParamsAssignment_2_0_1() { return cParamsAssignment_2_0_1; } + + //Literal + public RuleCall getParamsLiteralParserRuleCall_2_0_1_0() { return cParamsLiteralParserRuleCall_2_0_1_0; } + + //')' + public Keyword getRightParenthesisKeyword_2_0_2() { return cRightParenthesisKeyword_2_0_2; } + + //closureType=ClosureType '(' params+=Literal params+=Literal ')' + public Group getGroup_2_1() { return cGroup_2_1; } + + //closureType=ClosureType + public Assignment getClosureTypeAssignment_2_1_0() { return cClosureTypeAssignment_2_1_0; } + + //ClosureType + public RuleCall getClosureTypeClosureTypeParserRuleCall_2_1_0_0() { return cClosureTypeClosureTypeParserRuleCall_2_1_0_0; } + + //'(' + public Keyword getLeftParenthesisKeyword_2_1_1() { return cLeftParenthesisKeyword_2_1_1; } + + //params+=Literal + public Assignment getParamsAssignment_2_1_2() { return cParamsAssignment_2_1_2; } + + //Literal + public RuleCall getParamsLiteralParserRuleCall_2_1_2_0() { return cParamsLiteralParserRuleCall_2_1_2_0; } + + //params+=Literal + public Assignment getParamsAssignment_2_1_3() { return cParamsAssignment_2_1_3; } + + //Literal + public RuleCall getParamsLiteralParserRuleCall_2_1_3_0() { return cParamsLiteralParserRuleCall_2_1_3_0; } + + //')' + public Keyword getRightParenthesisKeyword_2_1_4() { return cRightParenthesisKeyword_2_1_4; } + } + public class ClosureTypeElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ClosureType"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final Group cGroup_0 = (Group)cAlternatives.eContents().get(0); + private final Action cReflexiveClosureAction_0_0 = (Action)cGroup_0.eContents().get(0); + private final Keyword cAsteriskKeyword_0_1 = (Keyword)cGroup_0.eContents().get(1); + private final Group cGroup_1 = (Group)cAlternatives.eContents().get(1); + private final Action cIrreflexiveClosureAction_1_0 = (Action)cGroup_1.eContents().get(0); + private final Keyword cPlusSignKeyword_1_1 = (Keyword)cGroup_1.eContents().get(1); + + //ClosureType: + // {ReflexiveClosure} '*' | {IrreflexiveClosure} '+'; + @Override public ParserRule getRule() { return rule; } + + //{ReflexiveClosure} '*' | {IrreflexiveClosure} '+' + public Alternatives getAlternatives() { return cAlternatives; } + + //{ReflexiveClosure} '*' + public Group getGroup_0() { return cGroup_0; } + + //{ReflexiveClosure} + public Action getReflexiveClosureAction_0_0() { return cReflexiveClosureAction_0_0; } + + //'*' + public Keyword getAsteriskKeyword_0_1() { return cAsteriskKeyword_0_1; } + + //{IrreflexiveClosure} '+' + public Group getGroup_1() { return cGroup_1; } + + //{IrreflexiveClosure} + public Action getIrreflexiveClosureAction_1_0() { return cIrreflexiveClosureAction_1_0; } + + //'+' + public Keyword getPlusSignKeyword_1_1() { return cPlusSignKeyword_1_1; } + } + public class LiteralElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Literal"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cVariableParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cDataObjectParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + + //Literal: + // Variable | DataObject; + @Override public ParserRule getRule() { return rule; } + + //Variable | DataObject + public Alternatives getAlternatives() { return cAlternatives; } + + //Variable + public RuleCall getVariableParserRuleCall_0() { return cVariableParserRuleCall_0; } + + //DataObject + public RuleCall getDataObjectParserRuleCall_1() { return cDataObjectParserRuleCall_1; } + } + public class VariableElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.Variable"); + private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1); + private final RuleCall cNameIDTerminalRuleCall_0 = (RuleCall)cNameAssignment.eContents().get(0); + + //Variable: + // name=ID; + @Override public ParserRule getRule() { return rule; } + + //name=ID + public Assignment getNameAssignment() { return cNameAssignment; } + + //ID + public RuleCall getNameIDTerminalRuleCall_0() { return cNameIDTerminalRuleCall_0; } + } + public class AllInstancesElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AllInstances"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cColonKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cSymbolSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0); + + ///////////////////// + //// Complex Interpretation grammar + ///////////////////// + //AllInstances: + // ':' symbol=Symbol; + @Override public ParserRule getRule() { return rule; } + + //':' symbol=Symbol + public Group getGroup() { return cGroup; } + + //':' + public Keyword getColonKeyword_0() { return cColonKeyword_0; } + + //symbol=Symbol + public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; } + + //Symbol + public RuleCall getSymbolSymbolParserRuleCall_1_0() { return cSymbolSymbolParserRuleCall_1_0; } + } + public class AllObjectsElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.AllObjects"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Action cAllObjectsAction_0 = (Action)cGroup.eContents().get(0); + private final Keyword cAsteriskKeyword_1 = (Keyword)cGroup.eContents().get(1); + + //AllObjects: + // {AllObjects} '*'; + @Override public ParserRule getRule() { return rule; } + + //{AllObjects} '*' + public Group getGroup() { return cGroup; } + + //{AllObjects} + public Action getAllObjectsAction_0() { return cAllObjectsAction_0; } + + //'*' + public Keyword getAsteriskKeyword_1() { return cAsteriskKeyword_1; } + } + public class DefaultInterpretationElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.DefaultInterpretation"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cDefaultKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Assignment cInterpretationAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cInterpretationBasicInterpretationParserRuleCall_1_0 = (RuleCall)cInterpretationAssignment_1.eContents().get(0); + + ///////////////////// + //// Defaul Interpretation grammar + ///////////////////// + //DefaultInterpretation: + // 'default' interpretation=BasicInterpretation; + @Override public ParserRule getRule() { return rule; } + + //'default' interpretation=BasicInterpretation + public Group getGroup() { return cGroup; } + + //'default' + public Keyword getDefaultKeyword_0() { return cDefaultKeyword_0; } + + //interpretation=BasicInterpretation + public Assignment getInterpretationAssignment_1() { return cInterpretationAssignment_1; } + + //BasicInterpretation + public RuleCall getInterpretationBasicInterpretationParserRuleCall_1_0() { return cInterpretationBasicInterpretationParserRuleCall_1_0; } + } + public class CDInterpretationElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.CDInterpretation"); + private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); + private final RuleCall cClassInterpretationParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); + private final RuleCall cEnumInterpretationParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); + private final RuleCall cGlobalRelationInterpretationParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); + + ///////////////////// + //// Advanced Class-Diagram interpretations + ///////////////////// + //CDInterpretation: + // ClassInterpretation | EnumInterpretation | GlobalRelationInterpretation; + @Override public ParserRule getRule() { return rule; } + + //ClassInterpretation | EnumInterpretation | GlobalRelationInterpretation + public Alternatives getAlternatives() { return cAlternatives; } + + //ClassInterpretation + public RuleCall getClassInterpretationParserRuleCall_0() { return cClassInterpretationParserRuleCall_0; } + + //EnumInterpretation + public RuleCall getEnumInterpretationParserRuleCall_1() { return cEnumInterpretationParserRuleCall_1; } + + //GlobalRelationInterpretation + public RuleCall getGlobalRelationInterpretationParserRuleCall_2() { return cGlobalRelationInterpretationParserRuleCall_2; } + } + public class ClassInterpretationElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.ClassInterpretation"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cAbstractAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final Keyword cAbstractAbstractKeyword_0_0 = (Keyword)cAbstractAssignment_0.eContents().get(0); + private final Keyword cClassKeyword_1 = (Keyword)cGroup.eContents().get(1); + private final Assignment cSymbolAssignment_2 = (Assignment)cGroup.eContents().get(2); + private final RuleCall cSymbolModelSymbolParserRuleCall_2_0 = (RuleCall)cSymbolAssignment_2.eContents().get(0); + private final Group cGroup_3 = (Group)cGroup.eContents().get(3); + private final Keyword cExtendsKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); + private final Assignment cSupertypesAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); + private final RuleCall cSupertypesModelSymbolParserRuleCall_3_1_0 = (RuleCall)cSupertypesAssignment_3_1.eContents().get(0); + private final Keyword cLeftCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); + private final Assignment cFieltAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final RuleCall cFieltFieldRelationInterpretationParserRuleCall_5_0 = (RuleCall)cFieltAssignment_5.eContents().get(0); + private final Keyword cRightCurlyBracketKeyword_6 = (Keyword)cGroup.eContents().get(6); + + //ClassInterpretation: + // abstract?='abstract' 'class' symbol=ModelSymbol ('extends' supertypes+=ModelSymbol+)? '{' + // fielt+=FieldRelationInterpretation* + // '}'; + @Override public ParserRule getRule() { return rule; } + + //abstract?='abstract' 'class' symbol=ModelSymbol ('extends' supertypes+=ModelSymbol+)? '{' + //fielt+=FieldRelationInterpretation* '}' + public Group getGroup() { return cGroup; } + + //abstract?='abstract' + public Assignment getAbstractAssignment_0() { return cAbstractAssignment_0; } + + //'abstract' + public Keyword getAbstractAbstractKeyword_0_0() { return cAbstractAbstractKeyword_0_0; } + + //'class' + public Keyword getClassKeyword_1() { return cClassKeyword_1; } + + //symbol=ModelSymbol + public Assignment getSymbolAssignment_2() { return cSymbolAssignment_2; } + + //ModelSymbol + public RuleCall getSymbolModelSymbolParserRuleCall_2_0() { return cSymbolModelSymbolParserRuleCall_2_0; } + + //('extends' supertypes+=ModelSymbol+)? + public Group getGroup_3() { return cGroup_3; } + + //'extends' + public Keyword getExtendsKeyword_3_0() { return cExtendsKeyword_3_0; } + + //supertypes+=ModelSymbol+ + public Assignment getSupertypesAssignment_3_1() { return cSupertypesAssignment_3_1; } + + //ModelSymbol + public RuleCall getSupertypesModelSymbolParserRuleCall_3_1_0() { return cSupertypesModelSymbolParserRuleCall_3_1_0; } + + //'{' + public Keyword getLeftCurlyBracketKeyword_4() { return cLeftCurlyBracketKeyword_4; } + + //fielt+=FieldRelationInterpretation* + public Assignment getFieltAssignment_5() { return cFieltAssignment_5; } + + //FieldRelationInterpretation + public RuleCall getFieltFieldRelationInterpretationParserRuleCall_5_0() { return cFieltFieldRelationInterpretationParserRuleCall_5_0; } + + //'}' + public Keyword getRightCurlyBracketKeyword_6() { return cRightCurlyBracketKeyword_6; } + } + public class EnumInterpretationElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.EnumInterpretation"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Keyword cEnumKeyword_0 = (Keyword)cGroup.eContents().get(0); + private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cSymbolModelSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0); + private final Keyword cLeftCurlyBracketKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final Assignment cObjectsAssignment_3 = (Assignment)cGroup.eContents().get(3); + private final RuleCall cObjectsNamedObjectParserRuleCall_3_0 = (RuleCall)cObjectsAssignment_3.eContents().get(0); + private final Keyword cRightCurlyBracketKeyword_4 = (Keyword)cGroup.eContents().get(4); + + //EnumInterpretation: + // 'enum' Symbol=ModelSymbol '{' objects+=NamedObject+ '}'; + @Override public ParserRule getRule() { return rule; } + + //'enum' Symbol=ModelSymbol '{' objects+=NamedObject+ '}' + public Group getGroup() { return cGroup; } + + //'enum' + public Keyword getEnumKeyword_0() { return cEnumKeyword_0; } + + //Symbol=ModelSymbol + public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; } + + //ModelSymbol + public RuleCall getSymbolModelSymbolParserRuleCall_1_0() { return cSymbolModelSymbolParserRuleCall_1_0; } + + //'{' + public Keyword getLeftCurlyBracketKeyword_2() { return cLeftCurlyBracketKeyword_2; } + + //objects+=NamedObject+ + public Assignment getObjectsAssignment_3() { return cObjectsAssignment_3; } + + //NamedObject + public RuleCall getObjectsNamedObjectParserRuleCall_3_0() { return cObjectsNamedObjectParserRuleCall_3_0; } + + //'}' + public Keyword getRightCurlyBracketKeyword_4() { return cRightCurlyBracketKeyword_4; } + } + public class FieldRelationInterpretationElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.FieldRelationInterpretation"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cContainmentAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final Keyword cContainmentContainmentKeyword_0_0 = (Keyword)cContainmentAssignment_0.eContents().get(0); + private final Assignment cSymbolAssignment_1 = (Assignment)cGroup.eContents().get(1); + private final RuleCall cSymbolModelSymbolParserRuleCall_1_0 = (RuleCall)cSymbolAssignment_1.eContents().get(0); + private final Keyword cColonKeyword_2 = (Keyword)cGroup.eContents().get(2); + private final Assignment cMultiplicityAssignment_3 = (Assignment)cGroup.eContents().get(3); + private final RuleCall cMultiplicityMultiplicityDefinitionParserRuleCall_3_0 = (RuleCall)cMultiplicityAssignment_3.eContents().get(0); + private final Assignment cTargetAssignment_4 = (Assignment)cGroup.eContents().get(4); + private final RuleCall cTargetSymbolParserRuleCall_4_0 = (RuleCall)cTargetAssignment_4.eContents().get(0); + + //FieldRelationInterpretation: + // containment?='containment' symbol=ModelSymbol ':' multiplicity=MultiplicityDefinition? target=Symbol; + @Override public ParserRule getRule() { return rule; } + + //containment?='containment' symbol=ModelSymbol ':' multiplicity=MultiplicityDefinition? target=Symbol + public Group getGroup() { return cGroup; } + + //containment?='containment' + public Assignment getContainmentAssignment_0() { return cContainmentAssignment_0; } + + //'containment' + public Keyword getContainmentContainmentKeyword_0_0() { return cContainmentContainmentKeyword_0_0; } + + //symbol=ModelSymbol + public Assignment getSymbolAssignment_1() { return cSymbolAssignment_1; } + + //ModelSymbol + public RuleCall getSymbolModelSymbolParserRuleCall_1_0() { return cSymbolModelSymbolParserRuleCall_1_0; } + + //':' + public Keyword getColonKeyword_2() { return cColonKeyword_2; } + + //multiplicity=MultiplicityDefinition? + public Assignment getMultiplicityAssignment_3() { return cMultiplicityAssignment_3; } + + //MultiplicityDefinition + public RuleCall getMultiplicityMultiplicityDefinitionParserRuleCall_3_0() { return cMultiplicityMultiplicityDefinitionParserRuleCall_3_0; } + + //target=Symbol + public Assignment getTargetAssignment_4() { return cTargetAssignment_4; } + + //Symbol + public RuleCall getTargetSymbolParserRuleCall_4_0() { return cTargetSymbolParserRuleCall_4_0; } + } + public class GlobalRelationInterpretationElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.GlobalRelationInterpretation"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cContainmentAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final Keyword cContainmentContainmentKeyword_0_0 = (Keyword)cContainmentAssignment_0.eContents().get(0); + private final Keyword cRelationKeyword_1 = (Keyword)cGroup.eContents().get(1); + private final Assignment cSymbolAssignment_2 = (Assignment)cGroup.eContents().get(2); + private final RuleCall cSymbolModelSymbolParserRuleCall_2_0 = (RuleCall)cSymbolAssignment_2.eContents().get(0); + private final Keyword cColonKeyword_3 = (Keyword)cGroup.eContents().get(3); + private final Assignment cSourceMultiplicityAssignment_4 = (Assignment)cGroup.eContents().get(4); + private final RuleCall cSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0 = (RuleCall)cSourceMultiplicityAssignment_4.eContents().get(0); + private final Assignment cSourceAssignment_5 = (Assignment)cGroup.eContents().get(5); + private final RuleCall cSourceSymbolParserRuleCall_5_0 = (RuleCall)cSourceAssignment_5.eContents().get(0); + private final Assignment cTargetMultiplicityAssignment_6 = (Assignment)cGroup.eContents().get(6); + private final RuleCall cTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0 = (RuleCall)cTargetMultiplicityAssignment_6.eContents().get(0); + private final Assignment cTargetAssignment_7 = (Assignment)cGroup.eContents().get(7); + private final RuleCall cTargetSymbolParserRuleCall_7_0 = (RuleCall)cTargetAssignment_7.eContents().get(0); + + //GlobalRelationInterpretation: + // containment?='containment' 'relation' symbol=ModelSymbol ':' sourceMultiplicity=MultiplicityDefinition? source=Symbol + // targetMultiplicity=MultiplicityDefinition? target=Symbol; + @Override public ParserRule getRule() { return rule; } + + //containment?='containment' 'relation' symbol=ModelSymbol ':' sourceMultiplicity=MultiplicityDefinition? source=Symbol + //targetMultiplicity=MultiplicityDefinition? target=Symbol + public Group getGroup() { return cGroup; } + + //containment?='containment' + public Assignment getContainmentAssignment_0() { return cContainmentAssignment_0; } + + //'containment' + public Keyword getContainmentContainmentKeyword_0_0() { return cContainmentContainmentKeyword_0_0; } + + //'relation' + public Keyword getRelationKeyword_1() { return cRelationKeyword_1; } + + //symbol=ModelSymbol + public Assignment getSymbolAssignment_2() { return cSymbolAssignment_2; } + + //ModelSymbol + public RuleCall getSymbolModelSymbolParserRuleCall_2_0() { return cSymbolModelSymbolParserRuleCall_2_0; } + + //':' + public Keyword getColonKeyword_3() { return cColonKeyword_3; } + + //sourceMultiplicity=MultiplicityDefinition? + public Assignment getSourceMultiplicityAssignment_4() { return cSourceMultiplicityAssignment_4; } + + //MultiplicityDefinition + public RuleCall getSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0() { return cSourceMultiplicityMultiplicityDefinitionParserRuleCall_4_0; } + + //source=Symbol + public Assignment getSourceAssignment_5() { return cSourceAssignment_5; } + + //Symbol + public RuleCall getSourceSymbolParserRuleCall_5_0() { return cSourceSymbolParserRuleCall_5_0; } + + //targetMultiplicity=MultiplicityDefinition? + public Assignment getTargetMultiplicityAssignment_6() { return cTargetMultiplicityAssignment_6; } + + //MultiplicityDefinition + public RuleCall getTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0() { return cTargetMultiplicityMultiplicityDefinitionParserRuleCall_6_0; } + + //target=Symbol + public Assignment getTargetAssignment_7() { return cTargetAssignment_7; } + + //Symbol + public RuleCall getTargetSymbolParserRuleCall_7_0() { return cTargetSymbolParserRuleCall_7_0; } + } + public class MultiplicityDefinitionElements extends AbstractParserRuleElementFinder { + private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.MultiplicityDefinition"); + private final Group cGroup = (Group)rule.eContents().get(1); + private final Assignment cLowerAssignment_0 = (Assignment)cGroup.eContents().get(0); + private final RuleCall cLowerINTTerminalRuleCall_0_0 = (RuleCall)cLowerAssignment_0.eContents().get(0); + private final Keyword cFullStopFullStopKeyword_1 = (Keyword)cGroup.eContents().get(1); + private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2); + private final Assignment cUpperAssignment_2_0 = (Assignment)cAlternatives_2.eContents().get(0); + private final RuleCall cUpperINTTerminalRuleCall_2_0_0 = (RuleCall)cUpperAssignment_2_0.eContents().get(0); + private final Assignment cUnlimitedUpperAssignment_2_1 = (Assignment)cAlternatives_2.eContents().get(1); + private final Keyword cUnlimitedUpperAsteriskKeyword_2_1_0 = (Keyword)cUnlimitedUpperAssignment_2_1.eContents().get(0); + + //MultiplicityDefinition: + // lower=INT '..' (upper=INT | unlimitedUpper?='*'); + @Override public ParserRule getRule() { return rule; } + + //lower=INT '..' (upper=INT | unlimitedUpper?='*') + public Group getGroup() { return cGroup; } + + //lower=INT + public Assignment getLowerAssignment_0() { return cLowerAssignment_0; } + + //INT + public RuleCall getLowerINTTerminalRuleCall_0_0() { return cLowerINTTerminalRuleCall_0_0; } + + //'..' + public Keyword getFullStopFullStopKeyword_1() { return cFullStopFullStopKeyword_1; } + + //upper=INT | unlimitedUpper?='*' + public Alternatives getAlternatives_2() { return cAlternatives_2; } + + //upper=INT + public Assignment getUpperAssignment_2_0() { return cUpperAssignment_2_0; } + + //INT + public RuleCall getUpperINTTerminalRuleCall_2_0_0() { return cUpperINTTerminalRuleCall_2_0_0; } + + //unlimitedUpper?='*' + public Assignment getUnlimitedUpperAssignment_2_1() { return cUnlimitedUpperAssignment_2_1; } + + //'*' + public Keyword getUnlimitedUpperAsteriskKeyword_2_1_0() { return cUnlimitedUpperAsteriskKeyword_2_1_0; } + } + + + private final ProblemElements pProblem; + private final StatementElements pStatement; + private final TerminalRule tSTRING; + private final REALLiteralElements pREALLiteral; + private final INTLiteralElements pINTLiteral; + private final BooleanValueElements pBooleanValue; + private final TruthValueElements pTruthValue; + private final InterpretationElements pInterpretation; + private final BasicInterpretationElements pBasicInterpretation; + private final SymbolElements pSymbol; + private final ModelSymbolElements pModelSymbol; + private final PartialitySymbolElements pPartialitySymbol; + private final ExistSymbolElements pExistSymbol; + private final EqualsSymbolElements pEqualsSymbol; + private final DataSymbolElements pDataSymbol; + private final BooleanSymbolElements pBooleanSymbol; + private final IntegerSymbolElements pIntegerSymbol; + private final RealSymbolElements pRealSymbol; + private final StringSymbolElements pStringSymbol; + private final ComplexObjectElements pComplexObject; + private final ObjectElements pObject; + private final NamedObjectElements pNamedObject; + private final UnnamedObjectElements pUnnamedObject; + private final DataObjectElements pDataObject; + private final BooleanObjectElements pBooleanObject; + private final IntObjectElements pIntObject; + private final RealObjectElements pRealObject; + private final StringObjectElements pStringObject; + private final PredicateElements pPredicate; + private final PredicateSymbolElements pPredicateSymbol; + private final ErrorPredicateElements pErrorPredicate; + private final ParameterElements pParameter; + private final PatternBodyElements pPatternBody; + private final PolarityElements pPolarity; + private final ConstraintElements pConstraint; + private final ClosureTypeElements pClosureType; + private final LiteralElements pLiteral; + private final VariableElements pVariable; + private final AllInstancesElements pAllInstances; + private final AllObjectsElements pAllObjects; + private final DefaultInterpretationElements pDefaultInterpretation; + private final CDInterpretationElements pCDInterpretation; + private final ClassInterpretationElements pClassInterpretation; + private final EnumInterpretationElements pEnumInterpretation; + private final FieldRelationInterpretationElements pFieldRelationInterpretation; + private final GlobalRelationInterpretationElements pGlobalRelationInterpretation; + private final MultiplicityDefinitionElements pMultiplicityDefinition; + + private final Grammar grammar; + + private final TerminalsGrammarAccess gaTerminals; + + @Inject + public SolverLanguageGrammarAccess(GrammarProvider grammarProvider, + TerminalsGrammarAccess gaTerminals) { + this.grammar = internalFindGrammar(grammarProvider); + this.gaTerminals = gaTerminals; + this.pProblem = new ProblemElements(); + this.pStatement = new StatementElements(); + this.tSTRING = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.viatra.solver.language.SolverLanguage.STRING"); + this.pREALLiteral = new REALLiteralElements(); + this.pINTLiteral = new INTLiteralElements(); + this.pBooleanValue = new BooleanValueElements(); + this.pTruthValue = new TruthValueElements(); + this.pInterpretation = new InterpretationElements(); + this.pBasicInterpretation = new BasicInterpretationElements(); + this.pSymbol = new SymbolElements(); + this.pModelSymbol = new ModelSymbolElements(); + this.pPartialitySymbol = new PartialitySymbolElements(); + this.pExistSymbol = new ExistSymbolElements(); + this.pEqualsSymbol = new EqualsSymbolElements(); + this.pDataSymbol = new DataSymbolElements(); + this.pBooleanSymbol = new BooleanSymbolElements(); + this.pIntegerSymbol = new IntegerSymbolElements(); + this.pRealSymbol = new RealSymbolElements(); + this.pStringSymbol = new StringSymbolElements(); + this.pComplexObject = new ComplexObjectElements(); + this.pObject = new ObjectElements(); + this.pNamedObject = new NamedObjectElements(); + this.pUnnamedObject = new UnnamedObjectElements(); + this.pDataObject = new DataObjectElements(); + this.pBooleanObject = new BooleanObjectElements(); + this.pIntObject = new IntObjectElements(); + this.pRealObject = new RealObjectElements(); + this.pStringObject = new StringObjectElements(); + this.pPredicate = new PredicateElements(); + this.pPredicateSymbol = new PredicateSymbolElements(); + this.pErrorPredicate = new ErrorPredicateElements(); + this.pParameter = new ParameterElements(); + this.pPatternBody = new PatternBodyElements(); + this.pPolarity = new PolarityElements(); + this.pConstraint = new ConstraintElements(); + this.pClosureType = new ClosureTypeElements(); + this.pLiteral = new LiteralElements(); + this.pVariable = new VariableElements(); + this.pAllInstances = new AllInstancesElements(); + this.pAllObjects = new AllObjectsElements(); + this.pDefaultInterpretation = new DefaultInterpretationElements(); + this.pCDInterpretation = new CDInterpretationElements(); + this.pClassInterpretation = new ClassInterpretationElements(); + this.pEnumInterpretation = new EnumInterpretationElements(); + this.pFieldRelationInterpretation = new FieldRelationInterpretationElements(); + this.pGlobalRelationInterpretation = new GlobalRelationInterpretationElements(); + this.pMultiplicityDefinition = new MultiplicityDefinitionElements(); + } + + protected Grammar internalFindGrammar(GrammarProvider grammarProvider) { + Grammar grammar = grammarProvider.getGrammar(this); + while (grammar != null) { + if ("org.eclipse.viatra.solver.language.SolverLanguage".equals(grammar.getName())) { + return grammar; + } + List grammars = grammar.getUsedGrammars(); + if (!grammars.isEmpty()) { + grammar = grammars.iterator().next(); + } else { + return null; + } + } + return grammar; + } + + @Override + public Grammar getGrammar() { + return grammar; + } + + + public TerminalsGrammarAccess getTerminalsGrammarAccess() { + return gaTerminals; + } + + + //Problem: + // statements+=Statement*; + public ProblemElements getProblemAccess() { + return pProblem; + } + + public ParserRule getProblemRule() { + return getProblemAccess().getRule(); + } + + //Statement: + // Interpretation | Predicate; + public StatementElements getStatementAccess() { + return pStatement; + } + + public ParserRule getStatementRule() { + return getStatementAccess().getRule(); + } + + //@Override + //terminal STRING: + // '"' ('\\' . | !('\\' | '"'))* '"'; + public TerminalRule getSTRINGRule() { + return tSTRING; + } + + //REALLiteral ecore::EBigDecimal: + // '-'? INT '.' INT; + public REALLiteralElements getREALLiteralAccess() { + return pREALLiteral; + } + + public ParserRule getREALLiteralRule() { + return getREALLiteralAccess().getRule(); + } + + //INTLiteral ecore::EInt: + // '-'? INT; + public INTLiteralElements getINTLiteralAccess() { + return pINTLiteral; + } + + public ParserRule getINTLiteralRule() { + return getINTLiteralAccess().getRule(); + } + + //BooleanValue: + // {BooleanTrue} 'true' | 'false' {BooleanFalse}; + public BooleanValueElements getBooleanValueAccess() { + return pBooleanValue; + } + + public ParserRule getBooleanValueRule() { + return getBooleanValueAccess().getRule(); + } + + //TruthValue: + // {True} 'true' | {False} 'false' | {Unknown} 'unknown' | {Error} 'error'; + public TruthValueElements getTruthValueAccess() { + return pTruthValue; + } + + public ParserRule getTruthValueRule() { + return getTruthValueAccess().getRule(); + } + + ///////////////////// + //// Core grammar + // /////////////////// + //Interpretation: + // BasicInterpretation | DefaultInterpretation | CDInterpretation; + public InterpretationElements getInterpretationAccess() { + return pInterpretation; + } + + public ParserRule getInterpretationRule() { + return getInterpretationAccess().getRule(); + } + + //BasicInterpretation: + // symbol=Symbol '(' objects+=ComplexObject* ')' ':' value=TruthValue; + public BasicInterpretationElements getBasicInterpretationAccess() { + return pBasicInterpretation; + } + + public ParserRule getBasicInterpretationRule() { + return getBasicInterpretationAccess().getRule(); + } + + //Symbol: + // ModelSymbol | PartialitySymbol | DataSymbol; + public SymbolElements getSymbolAccess() { + return pSymbol; + } + + public ParserRule getSymbolRule() { + return getSymbolAccess().getRule(); + } + + //ModelSymbol: + // name=ID; + public ModelSymbolElements getModelSymbolAccess() { + return pModelSymbol; + } + + public ParserRule getModelSymbolRule() { + return getModelSymbolAccess().getRule(); + } + + //PartialitySymbol: + // ExistSymbol | EqualsSymbol; + public PartialitySymbolElements getPartialitySymbolAccess() { + return pPartialitySymbol; + } + + public ParserRule getPartialitySymbolRule() { + return getPartialitySymbolAccess().getRule(); + } + + //ExistSymbol: + // 'exists' {ExistSymbol}; + public ExistSymbolElements getExistSymbolAccess() { + return pExistSymbol; + } + + public ParserRule getExistSymbolRule() { + return getExistSymbolAccess().getRule(); + } + + //EqualsSymbol: + // 'equals' {EqualsSymbol}; + public EqualsSymbolElements getEqualsSymbolAccess() { + return pEqualsSymbol; + } + + public ParserRule getEqualsSymbolRule() { + return getEqualsSymbolAccess().getRule(); + } + + //DataSymbol: + // BooleanSymbol | IntegerSymbol | RealSymbol | StringSymbol; + public DataSymbolElements getDataSymbolAccess() { + return pDataSymbol; + } + + public ParserRule getDataSymbolRule() { + return getDataSymbolAccess().getRule(); + } + + //BooleanSymbol: + // 'bool' {BooleanSymbol}; + public BooleanSymbolElements getBooleanSymbolAccess() { + return pBooleanSymbol; + } + + public ParserRule getBooleanSymbolRule() { + return getBooleanSymbolAccess().getRule(); + } + + //IntegerSymbol: + // 'int' {IntegerSymbol}; + public IntegerSymbolElements getIntegerSymbolAccess() { + return pIntegerSymbol; + } + + public ParserRule getIntegerSymbolRule() { + return getIntegerSymbolAccess().getRule(); + } + + //RealSymbol: + // 'real' {RealSymbol}; + public RealSymbolElements getRealSymbolAccess() { + return pRealSymbol; + } + + public ParserRule getRealSymbolRule() { + return getRealSymbolAccess().getRule(); + } + + //StringSymbol: + // 'string' {StringSymbol}; + public StringSymbolElements getStringSymbolAccess() { + return pStringSymbol; + } + + public ParserRule getStringSymbolRule() { + return getStringSymbolAccess().getRule(); + } + + //ComplexObject: + // Object | AllInstances | AllObjects; + public ComplexObjectElements getComplexObjectAccess() { + return pComplexObject; + } + + public ParserRule getComplexObjectRule() { + return getComplexObjectAccess().getRule(); + } + + //Object: + // NamedObject | UnnamedObject | DataObject; + public ObjectElements getObjectAccess() { + return pObject; + } + + public ParserRule getObjectRule() { + return getObjectAccess().getRule(); + } + + //NamedObject: + // "'" name=ID "'"; + public NamedObjectElements getNamedObjectAccess() { + return pNamedObject; + } + + public ParserRule getNamedObjectRule() { + return getNamedObjectAccess().getRule(); + } + + //UnnamedObject: + // name=ID; + public UnnamedObjectElements getUnnamedObjectAccess() { + return pUnnamedObject; + } + + public ParserRule getUnnamedObjectRule() { + return getUnnamedObjectAccess().getRule(); + } + + //DataObject: + // BooleanObject | IntObject | RealObject | StringObject; + public DataObjectElements getDataObjectAccess() { + return pDataObject; + } + + public ParserRule getDataObjectRule() { + return getDataObjectAccess().getRule(); + } + + //BooleanObject: + // value=BooleanValue; + public BooleanObjectElements getBooleanObjectAccess() { + return pBooleanObject; + } + + public ParserRule getBooleanObjectRule() { + return getBooleanObjectAccess().getRule(); + } + + //IntObject: + // value=INTLiteral; + public IntObjectElements getIntObjectAccess() { + return pIntObject; + } + + public ParserRule getIntObjectRule() { + return getIntObjectAccess().getRule(); + } + + //RealObject: + // value=REALLiteral; + public RealObjectElements getRealObjectAccess() { + return pRealObject; + } + + public ParserRule getRealObjectRule() { + return getRealObjectAccess().getRule(); + } + + //StringObject: + // value=STRING; + public StringObjectElements getStringObjectAccess() { + return pStringObject; + } + + public ParserRule getStringObjectRule() { + return getStringObjectAccess().getRule(); + } + + ///////////////////// + //// Predicte grammar + ///////////////////// + //Predicate: + // PredicateSymbol | ErrorPredicate; + public PredicateElements getPredicateAccess() { + return pPredicate; + } + + public ParserRule getPredicateRule() { + return getPredicateAccess().getRule(); + } + + //PredicateSymbol: + // 'predicate' symbol=ModelSymbol '(' parameters+=Parameter* ')' ':' ('false' | bodies+=PatternBody ('|' + // bodies+=PatternBody)*) '.'; + public PredicateSymbolElements getPredicateSymbolAccess() { + return pPredicateSymbol; + } + + public ParserRule getPredicateSymbolRule() { + return getPredicateSymbolAccess().getRule(); + } + + //ErrorPredicate: + // {ErrorPredicate} 'error' name=ID? ('(' parameters+=Parameter* ')') ':' ('false' | bodies+=PatternBody ('|' + // bodies+=PatternBody)*) '.'; + public ErrorPredicateElements getErrorPredicateAccess() { + return pErrorPredicate; + } + + public ParserRule getErrorPredicateRule() { + return getErrorPredicateAccess().getRule(); + } + + //Parameter: + // variable=Variable (':' type=Symbol)?; + public ParameterElements getParameterAccess() { + return pParameter; + } + + public ParserRule getParameterRule() { + return getParameterAccess().getRule(); + } + + //PatternBody: + // {PatternBody} ('true' | constraints+=Constraint*); + public PatternBodyElements getPatternBodyAccess() { + return pPatternBody; + } + + public ParserRule getPatternBodyRule() { + return getPatternBodyAccess().getRule(); + } + + //Polarity: + // {Positive} '+' | {Negative} '-'; + public PolarityElements getPolarityAccess() { + return pPolarity; + } + + public ParserRule getPolarityRule() { + return getPolarityAccess().getRule(); + } + + //Constraint: + // polarity=Polarity? symbol=ModelSymbol ('(' params+=Literal* ')' | closureType=ClosureType '(' params+=Literal + // params+=Literal ')'); + public ConstraintElements getConstraintAccess() { + return pConstraint; + } + + public ParserRule getConstraintRule() { + return getConstraintAccess().getRule(); + } + + //ClosureType: + // {ReflexiveClosure} '*' | {IrreflexiveClosure} '+'; + public ClosureTypeElements getClosureTypeAccess() { + return pClosureType; + } + + public ParserRule getClosureTypeRule() { + return getClosureTypeAccess().getRule(); + } + + //Literal: + // Variable | DataObject; + public LiteralElements getLiteralAccess() { + return pLiteral; + } + + public ParserRule getLiteralRule() { + return getLiteralAccess().getRule(); + } + + //Variable: + // name=ID; + public VariableElements getVariableAccess() { + return pVariable; + } + + public ParserRule getVariableRule() { + return getVariableAccess().getRule(); + } + + ///////////////////// + //// Complex Interpretation grammar + ///////////////////// + //AllInstances: + // ':' symbol=Symbol; + public AllInstancesElements getAllInstancesAccess() { + return pAllInstances; + } + + public ParserRule getAllInstancesRule() { + return getAllInstancesAccess().getRule(); + } + + //AllObjects: + // {AllObjects} '*'; + public AllObjectsElements getAllObjectsAccess() { + return pAllObjects; + } + + public ParserRule getAllObjectsRule() { + return getAllObjectsAccess().getRule(); + } + + ///////////////////// + //// Defaul Interpretation grammar + ///////////////////// + //DefaultInterpretation: + // 'default' interpretation=BasicInterpretation; + public DefaultInterpretationElements getDefaultInterpretationAccess() { + return pDefaultInterpretation; + } + + public ParserRule getDefaultInterpretationRule() { + return getDefaultInterpretationAccess().getRule(); + } + + ///////////////////// + //// Advanced Class-Diagram interpretations + ///////////////////// + //CDInterpretation: + // ClassInterpretation | EnumInterpretation | GlobalRelationInterpretation; + public CDInterpretationElements getCDInterpretationAccess() { + return pCDInterpretation; + } + + public ParserRule getCDInterpretationRule() { + return getCDInterpretationAccess().getRule(); + } + + //ClassInterpretation: + // abstract?='abstract' 'class' symbol=ModelSymbol ('extends' supertypes+=ModelSymbol+)? '{' + // fielt+=FieldRelationInterpretation* + // '}'; + public ClassInterpretationElements getClassInterpretationAccess() { + return pClassInterpretation; + } + + public ParserRule getClassInterpretationRule() { + return getClassInterpretationAccess().getRule(); + } + + //EnumInterpretation: + // 'enum' Symbol=ModelSymbol '{' objects+=NamedObject+ '}'; + public EnumInterpretationElements getEnumInterpretationAccess() { + return pEnumInterpretation; + } + + public ParserRule getEnumInterpretationRule() { + return getEnumInterpretationAccess().getRule(); + } + + //FieldRelationInterpretation: + // containment?='containment' symbol=ModelSymbol ':' multiplicity=MultiplicityDefinition? target=Symbol; + public FieldRelationInterpretationElements getFieldRelationInterpretationAccess() { + return pFieldRelationInterpretation; + } + + public ParserRule getFieldRelationInterpretationRule() { + return getFieldRelationInterpretationAccess().getRule(); + } + + //GlobalRelationInterpretation: + // containment?='containment' 'relation' symbol=ModelSymbol ':' sourceMultiplicity=MultiplicityDefinition? source=Symbol + // targetMultiplicity=MultiplicityDefinition? target=Symbol; + public GlobalRelationInterpretationElements getGlobalRelationInterpretationAccess() { + return pGlobalRelationInterpretation; + } + + public ParserRule getGlobalRelationInterpretationRule() { + return getGlobalRelationInterpretationAccess().getRule(); + } + + //MultiplicityDefinition: + // lower=INT '..' (upper=INT | unlimitedUpper?='*'); + public MultiplicityDefinitionElements getMultiplicityDefinitionAccess() { + return pMultiplicityDefinition; + } + + public ParserRule getMultiplicityDefinitionRule() { + return getMultiplicityDefinitionAccess().getRule(); + } + + //terminal ID: + // '^'? ('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '_' | '0'..'9')*; + public TerminalRule getIDRule() { + return gaTerminals.getIDRule(); + } + + //terminal INT returns ecore::EInt: + // '0'..'9'+; + public TerminalRule getINTRule() { + return gaTerminals.getINTRule(); + } + + //terminal ML_COMMENT: + // '/*'->'*/'; + public TerminalRule getML_COMMENTRule() { + return gaTerminals.getML_COMMENTRule(); + } + + //terminal SL_COMMENT: + // '//' !('\n' | '\r')* ('\r'? '\n')?; + public TerminalRule getSL_COMMENTRule() { + return gaTerminals.getSL_COMMENTRule(); + } + + //terminal WS: + // ' ' | '\t' | '\r' | '\n'+; + public TerminalRule getWSRule() { + return gaTerminals.getWSRule(); + } + + //terminal ANY_OTHER: + // .; + public TerminalRule getANY_OTHERRule() { + return gaTerminals.getANY_OTHERRule(); + } +} diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllInstances.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllInstances.java new file mode 100644 index 00000000..17cb45fb --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllInstances.java @@ -0,0 +1,47 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'All Instances'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances#getSymbol Symbol}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAllInstances() + * @model + * @generated + */ +public interface AllInstances extends ComplexObject +{ + /** + * Returns the value of the 'Symbol' containment reference. + * + * + * @return the value of the 'Symbol' containment reference. + * @see #setSymbol(Symbol) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAllInstances_Symbol() + * @model containment="true" + * @generated + */ + Symbol getSymbol(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances#getSymbol Symbol}' containment reference. + * + * + * @param value the new value of the 'Symbol' containment reference. + * @see #getSymbol() + * @generated + */ + void setSymbol(Symbol value); + +} // AllInstances diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllObjects.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllObjects.java new file mode 100644 index 00000000..fbb18046 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/AllObjects.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'All Objects'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getAllObjects() + * @model + * @generated + */ +public interface AllObjects extends ComplexObject +{ +} // AllObjects diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BasicInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BasicInterpretation.java new file mode 100644 index 00000000..b4226d4a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BasicInterpretation.java @@ -0,0 +1,84 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.common.util.EList; + +/** + * + * A representation of the model object 'Basic Interpretation'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getSymbol Symbol}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getObjects Objects}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getValue Value}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBasicInterpretation() + * @model + * @generated + */ +public interface BasicInterpretation extends Interpretation +{ + /** + * Returns the value of the 'Symbol' containment reference. + * + * + * @return the value of the 'Symbol' containment reference. + * @see #setSymbol(Symbol) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBasicInterpretation_Symbol() + * @model containment="true" + * @generated + */ + Symbol getSymbol(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getSymbol Symbol}' containment reference. + * + * + * @param value the new value of the 'Symbol' containment reference. + * @see #getSymbol() + * @generated + */ + void setSymbol(Symbol value); + + /** + * Returns the value of the 'Objects' containment reference list. + * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.ComplexObject}. + * + * + * @return the value of the 'Objects' containment reference list. + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBasicInterpretation_Objects() + * @model containment="true" + * @generated + */ + EList getObjects(); + + /** + * Returns the value of the 'Value' containment reference. + * + * + * @return the value of the 'Value' containment reference. + * @see #setValue(TruthValue) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBasicInterpretation_Value() + * @model containment="true" + * @generated + */ + TruthValue getValue(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getValue Value}' containment reference. + * + * + * @param value the new value of the 'Value' containment reference. + * @see #getValue() + * @generated + */ + void setValue(TruthValue value); + +} // BasicInterpretation diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanFalse.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanFalse.java new file mode 100644 index 00000000..678e8fee --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanFalse.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Boolean False'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanFalse() + * @model + * @generated + */ +public interface BooleanFalse extends BooleanValue +{ +} // BooleanFalse diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanObject.java new file mode 100644 index 00000000..c2c652ab --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanObject.java @@ -0,0 +1,47 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Boolean Object'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject#getValue Value}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanObject() + * @model + * @generated + */ +public interface BooleanObject extends DataObject +{ + /** + * Returns the value of the 'Value' containment reference. + * + * + * @return the value of the 'Value' containment reference. + * @see #setValue(BooleanValue) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanObject_Value() + * @model containment="true" + * @generated + */ + BooleanValue getValue(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject#getValue Value}' containment reference. + * + * + * @param value the new value of the 'Value' containment reference. + * @see #getValue() + * @generated + */ + void setValue(BooleanValue value); + +} // BooleanObject diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanSymbol.java new file mode 100644 index 00000000..4760c96c --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanSymbol.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Boolean Symbol'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanSymbol() + * @model + * @generated + */ +public interface BooleanSymbol extends DataSymbol +{ +} // BooleanSymbol diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanTrue.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanTrue.java new file mode 100644 index 00000000..7c72ec36 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanTrue.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Boolean True'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanTrue() + * @model + * @generated + */ +public interface BooleanTrue extends BooleanValue +{ +} // BooleanTrue diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanValue.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanValue.java new file mode 100644 index 00000000..8fe67a48 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/BooleanValue.java @@ -0,0 +1,20 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Boolean Value'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getBooleanValue() + * @model + * @generated + */ +public interface BooleanValue extends EObject +{ +} // BooleanValue diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/CDInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/CDInterpretation.java new file mode 100644 index 00000000..9a69fc8a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/CDInterpretation.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'CD Interpretation'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getCDInterpretation() + * @model + * @generated + */ +public interface CDInterpretation extends Interpretation +{ +} // CDInterpretation diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClassInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClassInterpretation.java new file mode 100644 index 00000000..777e0c50 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClassInterpretation.java @@ -0,0 +1,97 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.common.util.EList; + +/** + * + * A representation of the model object 'Class Interpretation'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#isAbstract Abstract}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSymbol Symbol}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSupertypes Supertypes}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getFielt Fielt}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation() + * @model + * @generated + */ +public interface ClassInterpretation extends CDInterpretation +{ + /** + * Returns the value of the 'Abstract' attribute. + * + * + * @return the value of the 'Abstract' attribute. + * @see #setAbstract(boolean) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation_Abstract() + * @model + * @generated + */ + boolean isAbstract(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#isAbstract Abstract}' attribute. + * + * + * @param value the new value of the 'Abstract' attribute. + * @see #isAbstract() + * @generated + */ + void setAbstract(boolean value); + + /** + * Returns the value of the 'Symbol' containment reference. + * + * + * @return the value of the 'Symbol' containment reference. + * @see #setSymbol(ModelSymbol) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation_Symbol() + * @model containment="true" + * @generated + */ + ModelSymbol getSymbol(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSymbol Symbol}' containment reference. + * + * + * @param value the new value of the 'Symbol' containment reference. + * @see #getSymbol() + * @generated + */ + void setSymbol(ModelSymbol value); + + /** + * Returns the value of the 'Supertypes' containment reference list. + * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol}. + * + * + * @return the value of the 'Supertypes' containment reference list. + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation_Supertypes() + * @model containment="true" + * @generated + */ + EList getSupertypes(); + + /** + * Returns the value of the 'Fielt' containment reference list. + * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation}. + * + * + * @return the value of the 'Fielt' containment reference list. + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClassInterpretation_Fielt() + * @model containment="true" + * @generated + */ + EList getFielt(); + +} // ClassInterpretation diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClosureType.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClosureType.java new file mode 100644 index 00000000..f9d8dc28 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ClosureType.java @@ -0,0 +1,20 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Closure Type'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getClosureType() + * @model + * @generated + */ +public interface ClosureType extends EObject +{ +} // ClosureType diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ComplexObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ComplexObject.java new file mode 100644 index 00000000..e266f231 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ComplexObject.java @@ -0,0 +1,20 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Complex Object'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getComplexObject() + * @model + * @generated + */ +public interface ComplexObject extends EObject +{ +} // ComplexObject diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Constraint.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Constraint.java new file mode 100644 index 00000000..9c957def --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Constraint.java @@ -0,0 +1,109 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Constraint'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getPolarity Polarity}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getSymbol Symbol}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getParams Params}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getClosureType Closure Type}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint() + * @model + * @generated + */ +public interface Constraint extends EObject +{ + /** + * Returns the value of the 'Polarity' containment reference. + * + * + * @return the value of the 'Polarity' containment reference. + * @see #setPolarity(Polarity) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint_Polarity() + * @model containment="true" + * @generated + */ + Polarity getPolarity(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getPolarity Polarity}' containment reference. + * + * + * @param value the new value of the 'Polarity' containment reference. + * @see #getPolarity() + * @generated + */ + void setPolarity(Polarity value); + + /** + * Returns the value of the 'Symbol' containment reference. + * + * + * @return the value of the 'Symbol' containment reference. + * @see #setSymbol(ModelSymbol) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint_Symbol() + * @model containment="true" + * @generated + */ + ModelSymbol getSymbol(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getSymbol Symbol}' containment reference. + * + * + * @param value the new value of the 'Symbol' containment reference. + * @see #getSymbol() + * @generated + */ + void setSymbol(ModelSymbol value); + + /** + * Returns the value of the 'Params' containment reference list. + * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Literal}. + * + * + * @return the value of the 'Params' containment reference list. + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint_Params() + * @model containment="true" + * @generated + */ + EList getParams(); + + /** + * Returns the value of the 'Closure Type' containment reference. + * + * + * @return the value of the 'Closure Type' containment reference. + * @see #setClosureType(ClosureType) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getConstraint_ClosureType() + * @model containment="true" + * @generated + */ + ClosureType getClosureType(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getClosureType Closure Type}' containment reference. + * + * + * @param value the new value of the 'Closure Type' containment reference. + * @see #getClosureType() + * @generated + */ + void setClosureType(ClosureType value); + +} // Constraint diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataObject.java new file mode 100644 index 00000000..79a0af43 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataObject.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Data Object'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDataObject() + * @model + * @generated + */ +public interface DataObject extends org.eclipse.viatra.solver.language.solverLanguage.Object, Literal +{ +} // DataObject diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataSymbol.java new file mode 100644 index 00000000..eae8175a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DataSymbol.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Data Symbol'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDataSymbol() + * @model + * @generated + */ +public interface DataSymbol extends Symbol +{ +} // DataSymbol diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultInterpretation.java new file mode 100644 index 00000000..2e9209f6 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/DefaultInterpretation.java @@ -0,0 +1,47 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Default Interpretation'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation#getInterpretation Interpretation}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDefaultInterpretation() + * @model + * @generated + */ +public interface DefaultInterpretation extends Interpretation +{ + /** + * Returns the value of the 'Interpretation' containment reference. + * + * + * @return the value of the 'Interpretation' containment reference. + * @see #setInterpretation(BasicInterpretation) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getDefaultInterpretation_Interpretation() + * @model containment="true" + * @generated + */ + BasicInterpretation getInterpretation(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation#getInterpretation Interpretation}' containment reference. + * + * + * @param value the new value of the 'Interpretation' containment reference. + * @see #getInterpretation() + * @generated + */ + void setInterpretation(BasicInterpretation value); + +} // DefaultInterpretation diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EnumInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EnumInterpretation.java new file mode 100644 index 00000000..8d48c0df --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EnumInterpretation.java @@ -0,0 +1,61 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.common.util.EList; + +/** + * + * A representation of the model object 'Enum Interpretation'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getSymbol Symbol}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getObjects Objects}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEnumInterpretation() + * @model + * @generated + */ +public interface EnumInterpretation extends CDInterpretation +{ + /** + * Returns the value of the 'Symbol' containment reference. + * + * + * @return the value of the 'Symbol' containment reference. + * @see #setSymbol(ModelSymbol) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEnumInterpretation_Symbol() + * @model containment="true" + * @generated + */ + ModelSymbol getSymbol(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getSymbol Symbol}' containment reference. + * + * + * @param value the new value of the 'Symbol' containment reference. + * @see #getSymbol() + * @generated + */ + void setSymbol(ModelSymbol value); + + /** + * Returns the value of the 'Objects' containment reference list. + * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject}. + * + * + * @return the value of the 'Objects' containment reference list. + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEnumInterpretation_Objects() + * @model containment="true" + * @generated + */ + EList getObjects(); + +} // EnumInterpretation diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EqualsSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EqualsSymbol.java new file mode 100644 index 00000000..1edb994f --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/EqualsSymbol.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Equals Symbol'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getEqualsSymbol() + * @model + * @generated + */ +public interface EqualsSymbol extends PartialitySymbol +{ +} // EqualsSymbol diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Error.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Error.java new file mode 100644 index 00000000..bf99bc42 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Error.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Error'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getError() + * @model + * @generated + */ +public interface Error extends TruthValue +{ +} // Error diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ErrorPredicate.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ErrorPredicate.java new file mode 100644 index 00000000..c8e49d48 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ErrorPredicate.java @@ -0,0 +1,47 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Error Predicate'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate#getName Name}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getErrorPredicate() + * @model + * @generated + */ +public interface ErrorPredicate extends Predicate +{ + /** + * Returns the value of the 'Name' attribute. + * + * + * @return the value of the 'Name' attribute. + * @see #setName(String) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getErrorPredicate_Name() + * @model + * @generated + */ + String getName(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate#getName Name}' attribute. + * + * + * @param value the new value of the 'Name' attribute. + * @see #getName() + * @generated + */ + void setName(String value); + +} // ErrorPredicate diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExistSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExistSymbol.java new file mode 100644 index 00000000..4dad3295 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ExistSymbol.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Exist Symbol'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getExistSymbol() + * @model + * @generated + */ +public interface ExistSymbol extends PartialitySymbol +{ +} // ExistSymbol diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/False.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/False.java new file mode 100644 index 00000000..71947237 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/False.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'False'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFalse() + * @model + * @generated + */ +public interface False extends TruthValue +{ +} // False diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/FieldRelationInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/FieldRelationInterpretation.java new file mode 100644 index 00000000..eccf49e0 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/FieldRelationInterpretation.java @@ -0,0 +1,117 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Field Relation Interpretation'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#isContainment Containment}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getSymbol Symbol}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getMultiplicity Multiplicity}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getTarget Target}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation() + * @model + * @generated + */ +public interface FieldRelationInterpretation extends EObject +{ + /** + * Returns the value of the 'Containment' attribute. + * + * + * @return the value of the 'Containment' attribute. + * @see #setContainment(boolean) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation_Containment() + * @model + * @generated + */ + boolean isContainment(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#isContainment Containment}' attribute. + * + * + * @param value the new value of the 'Containment' attribute. + * @see #isContainment() + * @generated + */ + void setContainment(boolean value); + + /** + * Returns the value of the 'Symbol' containment reference. + * + * + * @return the value of the 'Symbol' containment reference. + * @see #setSymbol(ModelSymbol) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation_Symbol() + * @model containment="true" + * @generated + */ + ModelSymbol getSymbol(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getSymbol Symbol}' containment reference. + * + * + * @param value the new value of the 'Symbol' containment reference. + * @see #getSymbol() + * @generated + */ + void setSymbol(ModelSymbol value); + + /** + * Returns the value of the 'Multiplicity' containment reference. + * + * + * @return the value of the 'Multiplicity' containment reference. + * @see #setMultiplicity(MultiplicityDefinition) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation_Multiplicity() + * @model containment="true" + * @generated + */ + MultiplicityDefinition getMultiplicity(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getMultiplicity Multiplicity}' containment reference. + * + * + * @param value the new value of the 'Multiplicity' containment reference. + * @see #getMultiplicity() + * @generated + */ + void setMultiplicity(MultiplicityDefinition value); + + /** + * Returns the value of the 'Target' containment reference. + * + * + * @return the value of the 'Target' containment reference. + * @see #setTarget(Symbol) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getFieldRelationInterpretation_Target() + * @model containment="true" + * @generated + */ + Symbol getTarget(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getTarget Target}' containment reference. + * + * + * @param value the new value of the 'Target' containment reference. + * @see #getTarget() + * @generated + */ + void setTarget(Symbol value); + +} // FieldRelationInterpretation diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/GlobalRelationInterpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/GlobalRelationInterpretation.java new file mode 100644 index 00000000..59ab4278 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/GlobalRelationInterpretation.java @@ -0,0 +1,162 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Global Relation Interpretation'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#isContainment Containment}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSymbol Symbol}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSourceMultiplicity Source Multiplicity}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSource Source}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTargetMultiplicity Target Multiplicity}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTarget Target}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation() + * @model + * @generated + */ +public interface GlobalRelationInterpretation extends CDInterpretation +{ + /** + * Returns the value of the 'Containment' attribute. + * + * + * @return the value of the 'Containment' attribute. + * @see #setContainment(boolean) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_Containment() + * @model + * @generated + */ + boolean isContainment(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#isContainment Containment}' attribute. + * + * + * @param value the new value of the 'Containment' attribute. + * @see #isContainment() + * @generated + */ + void setContainment(boolean value); + + /** + * Returns the value of the 'Symbol' containment reference. + * + * + * @return the value of the 'Symbol' containment reference. + * @see #setSymbol(ModelSymbol) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_Symbol() + * @model containment="true" + * @generated + */ + ModelSymbol getSymbol(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSymbol Symbol}' containment reference. + * + * + * @param value the new value of the 'Symbol' containment reference. + * @see #getSymbol() + * @generated + */ + void setSymbol(ModelSymbol value); + + /** + * Returns the value of the 'Source Multiplicity' containment reference. + * + * + * @return the value of the 'Source Multiplicity' containment reference. + * @see #setSourceMultiplicity(MultiplicityDefinition) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_SourceMultiplicity() + * @model containment="true" + * @generated + */ + MultiplicityDefinition getSourceMultiplicity(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSourceMultiplicity Source Multiplicity}' containment reference. + * + * + * @param value the new value of the 'Source Multiplicity' containment reference. + * @see #getSourceMultiplicity() + * @generated + */ + void setSourceMultiplicity(MultiplicityDefinition value); + + /** + * Returns the value of the 'Source' containment reference. + * + * + * @return the value of the 'Source' containment reference. + * @see #setSource(Symbol) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_Source() + * @model containment="true" + * @generated + */ + Symbol getSource(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSource Source}' containment reference. + * + * + * @param value the new value of the 'Source' containment reference. + * @see #getSource() + * @generated + */ + void setSource(Symbol value); + + /** + * Returns the value of the 'Target Multiplicity' containment reference. + * + * + * @return the value of the 'Target Multiplicity' containment reference. + * @see #setTargetMultiplicity(MultiplicityDefinition) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_TargetMultiplicity() + * @model containment="true" + * @generated + */ + MultiplicityDefinition getTargetMultiplicity(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTargetMultiplicity Target Multiplicity}' containment reference. + * + * + * @param value the new value of the 'Target Multiplicity' containment reference. + * @see #getTargetMultiplicity() + * @generated + */ + void setTargetMultiplicity(MultiplicityDefinition value); + + /** + * Returns the value of the 'Target' containment reference. + * + * + * @return the value of the 'Target' containment reference. + * @see #setTarget(Symbol) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getGlobalRelationInterpretation_Target() + * @model containment="true" + * @generated + */ + Symbol getTarget(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTarget Target}' containment reference. + * + * + * @param value the new value of the 'Target' containment reference. + * @see #getTarget() + * @generated + */ + void setTarget(Symbol value); + +} // GlobalRelationInterpretation diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntObject.java new file mode 100644 index 00000000..1a42b0c3 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntObject.java @@ -0,0 +1,47 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Int Object'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.IntObject#getValue Value}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIntObject() + * @model + * @generated + */ +public interface IntObject extends DataObject +{ + /** + * Returns the value of the 'Value' attribute. + * + * + * @return the value of the 'Value' attribute. + * @see #setValue(int) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIntObject_Value() + * @model + * @generated + */ + int getValue(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject#getValue Value}' attribute. + * + * + * @param value the new value of the 'Value' attribute. + * @see #getValue() + * @generated + */ + void setValue(int value); + +} // IntObject diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntegerSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntegerSymbol.java new file mode 100644 index 00000000..d1472499 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IntegerSymbol.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Integer Symbol'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIntegerSymbol() + * @model + * @generated + */ +public interface IntegerSymbol extends DataSymbol +{ +} // IntegerSymbol diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interpretation.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interpretation.java new file mode 100644 index 00000000..56541016 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Interpretation.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Interpretation'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getInterpretation() + * @model + * @generated + */ +public interface Interpretation extends Statement +{ +} // Interpretation diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IrreflexiveClosure.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IrreflexiveClosure.java new file mode 100644 index 00000000..eca04f1e --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/IrreflexiveClosure.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Irreflexive Closure'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getIrreflexiveClosure() + * @model + * @generated + */ +public interface IrreflexiveClosure extends ClosureType +{ +} // IrreflexiveClosure diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Literal.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Literal.java new file mode 100644 index 00000000..259abe8c --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Literal.java @@ -0,0 +1,20 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Literal'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getLiteral() + * @model + * @generated + */ +public interface Literal extends EObject +{ +} // Literal diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ModelSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ModelSymbol.java new file mode 100644 index 00000000..0d91b791 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ModelSymbol.java @@ -0,0 +1,47 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Model Symbol'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol#getName Name}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getModelSymbol() + * @model + * @generated + */ +public interface ModelSymbol extends Symbol +{ + /** + * Returns the value of the 'Name' attribute. + * + * + * @return the value of the 'Name' attribute. + * @see #setName(String) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getModelSymbol_Name() + * @model + * @generated + */ + String getName(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol#getName Name}' attribute. + * + * + * @param value the new value of the 'Name' attribute. + * @see #getName() + * @generated + */ + void setName(String value); + +} // ModelSymbol diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MultiplicityDefinition.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MultiplicityDefinition.java new file mode 100644 index 00000000..9b4def59 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/MultiplicityDefinition.java @@ -0,0 +1,94 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Multiplicity Definition'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getLower Lower}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getUpper Upper}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#isUnlimitedUpper Unlimited Upper}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicityDefinition() + * @model + * @generated + */ +public interface MultiplicityDefinition extends EObject +{ + /** + * Returns the value of the 'Lower' attribute. + * + * + * @return the value of the 'Lower' attribute. + * @see #setLower(int) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicityDefinition_Lower() + * @model + * @generated + */ + int getLower(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getLower Lower}' attribute. + * + * + * @param value the new value of the 'Lower' attribute. + * @see #getLower() + * @generated + */ + void setLower(int value); + + /** + * Returns the value of the 'Upper' attribute. + * + * + * @return the value of the 'Upper' attribute. + * @see #setUpper(int) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicityDefinition_Upper() + * @model + * @generated + */ + int getUpper(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getUpper Upper}' attribute. + * + * + * @param value the new value of the 'Upper' attribute. + * @see #getUpper() + * @generated + */ + void setUpper(int value); + + /** + * Returns the value of the 'Unlimited Upper' attribute. + * + * + * @return the value of the 'Unlimited Upper' attribute. + * @see #setUnlimitedUpper(boolean) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getMultiplicityDefinition_UnlimitedUpper() + * @model + * @generated + */ + boolean isUnlimitedUpper(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#isUnlimitedUpper Unlimited Upper}' attribute. + * + * + * @param value the new value of the 'Unlimited Upper' attribute. + * @see #isUnlimitedUpper() + * @generated + */ + void setUnlimitedUpper(boolean value); + +} // MultiplicityDefinition diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NamedObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NamedObject.java new file mode 100644 index 00000000..a6deaea8 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/NamedObject.java @@ -0,0 +1,47 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Named Object'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject#getName Name}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNamedObject() + * @model + * @generated + */ +public interface NamedObject extends org.eclipse.viatra.solver.language.solverLanguage.Object +{ + /** + * Returns the value of the 'Name' attribute. + * + * + * @return the value of the 'Name' attribute. + * @see #setName(String) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNamedObject_Name() + * @model + * @generated + */ + String getName(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject#getName Name}' attribute. + * + * + * @param value the new value of the 'Name' attribute. + * @see #getName() + * @generated + */ + void setName(String value); + +} // NamedObject diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Negative.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Negative.java new file mode 100644 index 00000000..5d735fec --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Negative.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Negative'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getNegative() + * @model + * @generated + */ +public interface Negative extends Polarity +{ +} // Negative diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Object.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Object.java new file mode 100644 index 00000000..908ae5a6 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Object.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Object'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getObject() + * @model + * @generated + */ +public interface Object extends ComplexObject +{ +} // Object diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Parameter.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Parameter.java new file mode 100644 index 00000000..e4ef1c28 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Parameter.java @@ -0,0 +1,71 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Parameter'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getVariable Variable}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getType Type}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getParameter() + * @model + * @generated + */ +public interface Parameter extends EObject +{ + /** + * Returns the value of the 'Variable' containment reference. + * + * + * @return the value of the 'Variable' containment reference. + * @see #setVariable(Variable) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getParameter_Variable() + * @model containment="true" + * @generated + */ + Variable getVariable(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getVariable Variable}' containment reference. + * + * + * @param value the new value of the 'Variable' containment reference. + * @see #getVariable() + * @generated + */ + void setVariable(Variable value); + + /** + * Returns the value of the 'Type' containment reference. + * + * + * @return the value of the 'Type' containment reference. + * @see #setType(Symbol) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getParameter_Type() + * @model containment="true" + * @generated + */ + Symbol getType(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getType Type}' containment reference. + * + * + * @param value the new value of the 'Type' containment reference. + * @see #getType() + * @generated + */ + void setType(Symbol value); + +} // Parameter diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PartialitySymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PartialitySymbol.java new file mode 100644 index 00000000..a4331248 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PartialitySymbol.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Partiality Symbol'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPartialitySymbol() + * @model + * @generated + */ +public interface PartialitySymbol extends Symbol +{ +} // PartialitySymbol diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PatternBody.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PatternBody.java new file mode 100644 index 00000000..62be12a1 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PatternBody.java @@ -0,0 +1,40 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Pattern Body'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody#getConstraints Constraints}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPatternBody() + * @model + * @generated + */ +public interface PatternBody extends EObject +{ + /** + * Returns the value of the 'Constraints' containment reference list. + * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Constraint}. + * + * + * @return the value of the 'Constraints' containment reference list. + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPatternBody_Constraints() + * @model containment="true" + * @generated + */ + EList getConstraints(); + +} // PatternBody diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Polarity.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Polarity.java new file mode 100644 index 00000000..ba30c6ad --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Polarity.java @@ -0,0 +1,20 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Polarity'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPolarity() + * @model + * @generated + */ +public interface Polarity extends EObject +{ +} // Polarity diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Positive.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Positive.java new file mode 100644 index 00000000..075a865f --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Positive.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Positive'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPositive() + * @model + * @generated + */ +public interface Positive extends Polarity +{ +} // Positive diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Predicate.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Predicate.java new file mode 100644 index 00000000..fc61ea86 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Predicate.java @@ -0,0 +1,51 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.common.util.EList; + +/** + * + * A representation of the model object 'Predicate'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getParameters Parameters}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getBodies Bodies}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicate() + * @model + * @generated + */ +public interface Predicate extends Statement +{ + /** + * Returns the value of the 'Parameters' containment reference list. + * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Parameter}. + * + * + * @return the value of the 'Parameters' containment reference list. + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicate_Parameters() + * @model containment="true" + * @generated + */ + EList getParameters(); + + /** + * Returns the value of the 'Bodies' containment reference list. + * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody}. + * + * + * @return the value of the 'Bodies' containment reference list. + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicate_Bodies() + * @model containment="true" + * @generated + */ + EList getBodies(); + +} // Predicate diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PredicateSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PredicateSymbol.java new file mode 100644 index 00000000..0f1d0c47 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/PredicateSymbol.java @@ -0,0 +1,47 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Predicate Symbol'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol#getSymbol Symbol}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicateSymbol() + * @model + * @generated + */ +public interface PredicateSymbol extends Predicate +{ + /** + * Returns the value of the 'Symbol' containment reference. + * + * + * @return the value of the 'Symbol' containment reference. + * @see #setSymbol(ModelSymbol) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getPredicateSymbol_Symbol() + * @model containment="true" + * @generated + */ + ModelSymbol getSymbol(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol#getSymbol Symbol}' containment reference. + * + * + * @param value the new value of the 'Symbol' containment reference. + * @see #getSymbol() + * @generated + */ + void setSymbol(ModelSymbol value); + +} // PredicateSymbol diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Problem.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Problem.java new file mode 100644 index 00000000..91967617 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Problem.java @@ -0,0 +1,40 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Problem'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.Problem#getStatements Statements}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getProblem() + * @model + * @generated + */ +public interface Problem extends EObject +{ + /** + * Returns the value of the 'Statements' containment reference list. + * The list contents are of type {@link org.eclipse.viatra.solver.language.solverLanguage.Statement}. + * + * + * @return the value of the 'Statements' containment reference list. + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getProblem_Statements() + * @model containment="true" + * @generated + */ + EList getStatements(); + +} // Problem diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealObject.java new file mode 100644 index 00000000..12e8be3e --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealObject.java @@ -0,0 +1,48 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import java.math.BigDecimal; + +/** + * + * A representation of the model object 'Real Object'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.RealObject#getValue Value}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getRealObject() + * @model + * @generated + */ +public interface RealObject extends DataObject +{ + /** + * Returns the value of the 'Value' attribute. + * + * + * @return the value of the 'Value' attribute. + * @see #setValue(BigDecimal) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getRealObject_Value() + * @model + * @generated + */ + BigDecimal getValue(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject#getValue Value}' attribute. + * + * + * @param value the new value of the 'Value' attribute. + * @see #getValue() + * @generated + */ + void setValue(BigDecimal value); + +} // RealObject diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealSymbol.java new file mode 100644 index 00000000..06dd35fc --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/RealSymbol.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Real Symbol'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getRealSymbol() + * @model + * @generated + */ +public interface RealSymbol extends DataSymbol +{ +} // RealSymbol diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ReflexiveClosure.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ReflexiveClosure.java new file mode 100644 index 00000000..3eb30271 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/ReflexiveClosure.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Reflexive Closure'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getReflexiveClosure() + * @model + * @generated + */ +public interface ReflexiveClosure extends ClosureType +{ +} // ReflexiveClosure diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguageFactory.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguageFactory.java new file mode 100644 index 00000000..ebe2abdb --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguageFactory.java @@ -0,0 +1,521 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EFactory; + +/** + * + * The Factory for the model. + * It provides a create method for each non-abstract class of the model. + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage + * @generated + */ +public interface SolverLanguageFactory extends EFactory +{ + /** + * The singleton instance of the factory. + * + * + * @generated + */ + SolverLanguageFactory eINSTANCE = org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguageFactoryImpl.init(); + + /** + * Returns a new object of class 'Problem'. + * + * + * @return a new object of class 'Problem'. + * @generated + */ + Problem createProblem(); + + /** + * Returns a new object of class 'Statement'. + * + * + * @return a new object of class 'Statement'. + * @generated + */ + Statement createStatement(); + + /** + * Returns a new object of class 'Boolean Value'. + * + * + * @return a new object of class 'Boolean Value'. + * @generated + */ + BooleanValue createBooleanValue(); + + /** + * Returns a new object of class 'Truth Value'. + * + * + * @return a new object of class 'Truth Value'. + * @generated + */ + TruthValue createTruthValue(); + + /** + * Returns a new object of class 'Interpretation'. + * + * + * @return a new object of class 'Interpretation'. + * @generated + */ + Interpretation createInterpretation(); + + /** + * Returns a new object of class 'Basic Interpretation'. + * + * + * @return a new object of class 'Basic Interpretation'. + * @generated + */ + BasicInterpretation createBasicInterpretation(); + + /** + * Returns a new object of class 'Symbol'. + * + * + * @return a new object of class 'Symbol'. + * @generated + */ + Symbol createSymbol(); + + /** + * Returns a new object of class 'Model Symbol'. + * + * + * @return a new object of class 'Model Symbol'. + * @generated + */ + ModelSymbol createModelSymbol(); + + /** + * Returns a new object of class 'Partiality Symbol'. + * + * + * @return a new object of class 'Partiality Symbol'. + * @generated + */ + PartialitySymbol createPartialitySymbol(); + + /** + * Returns a new object of class 'Exist Symbol'. + * + * + * @return a new object of class 'Exist Symbol'. + * @generated + */ + ExistSymbol createExistSymbol(); + + /** + * Returns a new object of class 'Equals Symbol'. + * + * + * @return a new object of class 'Equals Symbol'. + * @generated + */ + EqualsSymbol createEqualsSymbol(); + + /** + * Returns a new object of class 'Data Symbol'. + * + * + * @return a new object of class 'Data Symbol'. + * @generated + */ + DataSymbol createDataSymbol(); + + /** + * Returns a new object of class 'Boolean Symbol'. + * + * + * @return a new object of class 'Boolean Symbol'. + * @generated + */ + BooleanSymbol createBooleanSymbol(); + + /** + * Returns a new object of class 'Integer Symbol'. + * + * + * @return a new object of class 'Integer Symbol'. + * @generated + */ + IntegerSymbol createIntegerSymbol(); + + /** + * Returns a new object of class 'Real Symbol'. + * + * + * @return a new object of class 'Real Symbol'. + * @generated + */ + RealSymbol createRealSymbol(); + + /** + * Returns a new object of class 'String Symbol'. + * + * + * @return a new object of class 'String Symbol'. + * @generated + */ + StringSymbol createStringSymbol(); + + /** + * Returns a new object of class 'Complex Object'. + * + * + * @return a new object of class 'Complex Object'. + * @generated + */ + ComplexObject createComplexObject(); + + /** + * Returns a new object of class 'Object'. + * + * + * @return a new object of class 'Object'. + * @generated + */ + Object createObject(); + + /** + * Returns a new object of class 'Named Object'. + * + * + * @return a new object of class 'Named Object'. + * @generated + */ + NamedObject createNamedObject(); + + /** + * Returns a new object of class 'Unnamed Object'. + * + * + * @return a new object of class 'Unnamed Object'. + * @generated + */ + UnnamedObject createUnnamedObject(); + + /** + * Returns a new object of class 'Data Object'. + * + * + * @return a new object of class 'Data Object'. + * @generated + */ + DataObject createDataObject(); + + /** + * Returns a new object of class 'Boolean Object'. + * + * + * @return a new object of class 'Boolean Object'. + * @generated + */ + BooleanObject createBooleanObject(); + + /** + * Returns a new object of class 'Int Object'. + * + * + * @return a new object of class 'Int Object'. + * @generated + */ + IntObject createIntObject(); + + /** + * Returns a new object of class 'Real Object'. + * + * + * @return a new object of class 'Real Object'. + * @generated + */ + RealObject createRealObject(); + + /** + * Returns a new object of class 'String Object'. + * + * + * @return a new object of class 'String Object'. + * @generated + */ + StringObject createStringObject(); + + /** + * Returns a new object of class 'Predicate'. + * + * + * @return a new object of class 'Predicate'. + * @generated + */ + Predicate createPredicate(); + + /** + * Returns a new object of class 'Predicate Symbol'. + * + * + * @return a new object of class 'Predicate Symbol'. + * @generated + */ + PredicateSymbol createPredicateSymbol(); + + /** + * Returns a new object of class 'Error Predicate'. + * + * + * @return a new object of class 'Error Predicate'. + * @generated + */ + ErrorPredicate createErrorPredicate(); + + /** + * Returns a new object of class 'Parameter'. + * + * + * @return a new object of class 'Parameter'. + * @generated + */ + Parameter createParameter(); + + /** + * Returns a new object of class 'Pattern Body'. + * + * + * @return a new object of class 'Pattern Body'. + * @generated + */ + PatternBody createPatternBody(); + + /** + * Returns a new object of class 'Polarity'. + * + * + * @return a new object of class 'Polarity'. + * @generated + */ + Polarity createPolarity(); + + /** + * Returns a new object of class 'Constraint'. + * + * + * @return a new object of class 'Constraint'. + * @generated + */ + Constraint createConstraint(); + + /** + * Returns a new object of class 'Closure Type'. + * + * + * @return a new object of class 'Closure Type'. + * @generated + */ + ClosureType createClosureType(); + + /** + * Returns a new object of class 'Literal'. + * + * + * @return a new object of class 'Literal'. + * @generated + */ + Literal createLiteral(); + + /** + * Returns a new object of class 'Variable'. + * + * + * @return a new object of class 'Variable'. + * @generated + */ + Variable createVariable(); + + /** + * Returns a new object of class 'All Instances'. + * + * + * @return a new object of class 'All Instances'. + * @generated + */ + AllInstances createAllInstances(); + + /** + * Returns a new object of class 'All Objects'. + * + * + * @return a new object of class 'All Objects'. + * @generated + */ + AllObjects createAllObjects(); + + /** + * Returns a new object of class 'Default Interpretation'. + * + * + * @return a new object of class 'Default Interpretation'. + * @generated + */ + DefaultInterpretation createDefaultInterpretation(); + + /** + * Returns a new object of class 'CD Interpretation'. + * + * + * @return a new object of class 'CD Interpretation'. + * @generated + */ + CDInterpretation createCDInterpretation(); + + /** + * Returns a new object of class 'Class Interpretation'. + * + * + * @return a new object of class 'Class Interpretation'. + * @generated + */ + ClassInterpretation createClassInterpretation(); + + /** + * Returns a new object of class 'Enum Interpretation'. + * + * + * @return a new object of class 'Enum Interpretation'. + * @generated + */ + EnumInterpretation createEnumInterpretation(); + + /** + * Returns a new object of class 'Field Relation Interpretation'. + * + * + * @return a new object of class 'Field Relation Interpretation'. + * @generated + */ + FieldRelationInterpretation createFieldRelationInterpretation(); + + /** + * Returns a new object of class 'Global Relation Interpretation'. + * + * + * @return a new object of class 'Global Relation Interpretation'. + * @generated + */ + GlobalRelationInterpretation createGlobalRelationInterpretation(); + + /** + * Returns a new object of class 'Multiplicity Definition'. + * + * + * @return a new object of class 'Multiplicity Definition'. + * @generated + */ + MultiplicityDefinition createMultiplicityDefinition(); + + /** + * Returns a new object of class 'Boolean True'. + * + * + * @return a new object of class 'Boolean True'. + * @generated + */ + BooleanTrue createBooleanTrue(); + + /** + * Returns a new object of class 'Boolean False'. + * + * + * @return a new object of class 'Boolean False'. + * @generated + */ + BooleanFalse createBooleanFalse(); + + /** + * Returns a new object of class 'True'. + * + * + * @return a new object of class 'True'. + * @generated + */ + True createTrue(); + + /** + * Returns a new object of class 'False'. + * + * + * @return a new object of class 'False'. + * @generated + */ + False createFalse(); + + /** + * Returns a new object of class 'Unknown'. + * + * + * @return a new object of class 'Unknown'. + * @generated + */ + Unknown createUnknown(); + + /** + * Returns a new object of class 'Error'. + * + * + * @return a new object of class 'Error'. + * @generated + */ + Error createError(); + + /** + * Returns a new object of class 'Positive'. + * + * + * @return a new object of class 'Positive'. + * @generated + */ + Positive createPositive(); + + /** + * Returns a new object of class 'Negative'. + * + * + * @return a new object of class 'Negative'. + * @generated + */ + Negative createNegative(); + + /** + * Returns a new object of class 'Reflexive Closure'. + * + * + * @return a new object of class 'Reflexive Closure'. + * @generated + */ + ReflexiveClosure createReflexiveClosure(); + + /** + * Returns a new object of class 'Irreflexive Closure'. + * + * + * @return a new object of class 'Irreflexive Closure'. + * @generated + */ + IrreflexiveClosure createIrreflexiveClosure(); + + /** + * Returns the package supported by this factory. + * + * + * @return the package supported by this factory. + * @generated + */ + SolverLanguagePackage getSolverLanguagePackage(); + +} //SolverLanguageFactory diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguagePackage.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguagePackage.java new file mode 100644 index 00000000..3bd01417 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/SolverLanguagePackage.java @@ -0,0 +1,3460 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EAttribute; +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.EReference; + +/** + * + * The Package for the model. + * It contains accessors for the meta objects to represent + *
    + *
  • each class,
    • + *
  • each feature of each class,
    • + *
  • each enum,
    • + *
  • and each data type
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguageFactory + * @model kind="package" + * @generated + */ +public interface SolverLanguagePackage extends EPackage +{ + /** + * The package name. + * + * + * @generated + */ + String eNAME = "solverLanguage"; + + /** + * The package namespace URI. + * + * + * @generated + */ + String eNS_URI = "http://www.eclipse.org/viatra/solver/language/SolverLanguage"; + + /** + * The package namespace name. + * + * + * @generated + */ + String eNS_PREFIX = "solverLanguage"; + + /** + * The singleton instance of the package. + * + * + * @generated + */ + SolverLanguagePackage eINSTANCE = org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl.init(); + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ProblemImpl Problem}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ProblemImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getProblem() + * @generated + */ + int PROBLEM = 0; + + /** + * The feature id for the 'Statements' containment reference list. + * + * + * @generated + * @ordered + */ + int PROBLEM__STATEMENTS = 0; + + /** + * The number of structural features of the 'Problem' class. + * + * + * @generated + * @ordered + */ + int PROBLEM_FEATURE_COUNT = 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StatementImpl Statement}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StatementImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStatement() + * @generated + */ + int STATEMENT = 1; + + /** + * The number of structural features of the 'Statement' class. + * + * + * @generated + * @ordered + */ + int STATEMENT_FEATURE_COUNT = 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanValueImpl Boolean Value}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanValueImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanValue() + * @generated + */ + int BOOLEAN_VALUE = 2; + + /** + * The number of structural features of the 'Boolean Value' class. + * + * + * @generated + * @ordered + */ + int BOOLEAN_VALUE_FEATURE_COUNT = 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TruthValueImpl Truth Value}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TruthValueImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTruthValue() + * @generated + */ + int TRUTH_VALUE = 3; + + /** + * The number of structural features of the 'Truth Value' class. + * + * + * @generated + * @ordered + */ + int TRUTH_VALUE_FEATURE_COUNT = 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.InterpretationImpl Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.InterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getInterpretation() + * @generated + */ + int INTERPRETATION = 4; + + /** + * The number of structural features of the 'Interpretation' class. + * + * + * @generated + * @ordered + */ + int INTERPRETATION_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl Basic Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBasicInterpretation() + * @generated + */ + int BASIC_INTERPRETATION = 5; + + /** + * The feature id for the 'Symbol' containment reference. + * + * + * @generated + * @ordered + */ + int BASIC_INTERPRETATION__SYMBOL = INTERPRETATION_FEATURE_COUNT + 0; + + /** + * The feature id for the 'Objects' containment reference list. + * + * + * @generated + * @ordered + */ + int BASIC_INTERPRETATION__OBJECTS = INTERPRETATION_FEATURE_COUNT + 1; + + /** + * The feature id for the 'Value' containment reference. + * + * + * @generated + * @ordered + */ + int BASIC_INTERPRETATION__VALUE = INTERPRETATION_FEATURE_COUNT + 2; + + /** + * The number of structural features of the 'Basic Interpretation' class. + * + * + * @generated + * @ordered + */ + int BASIC_INTERPRETATION_FEATURE_COUNT = INTERPRETATION_FEATURE_COUNT + 3; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.SymbolImpl Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getSymbol() + * @generated + */ + int SYMBOL = 6; + + /** + * The number of structural features of the 'Symbol' class. + * + * + * @generated + * @ordered + */ + int SYMBOL_FEATURE_COUNT = 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl Model Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getModelSymbol() + * @generated + */ + int MODEL_SYMBOL = 7; + + /** + * The feature id for the 'Name' attribute. + * + * + * @generated + * @ordered + */ + int MODEL_SYMBOL__NAME = SYMBOL_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'Model Symbol' class. + * + * + * @generated + * @ordered + */ + int MODEL_SYMBOL_FEATURE_COUNT = SYMBOL_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PartialitySymbolImpl Partiality Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PartialitySymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPartialitySymbol() + * @generated + */ + int PARTIALITY_SYMBOL = 8; + + /** + * The number of structural features of the 'Partiality Symbol' class. + * + * + * @generated + * @ordered + */ + int PARTIALITY_SYMBOL_FEATURE_COUNT = SYMBOL_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExistSymbolImpl Exist Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExistSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExistSymbol() + * @generated + */ + int EXIST_SYMBOL = 9; + + /** + * The number of structural features of the 'Exist Symbol' class. + * + * + * @generated + * @ordered + */ + int EXIST_SYMBOL_FEATURE_COUNT = PARTIALITY_SYMBOL_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EqualsSymbolImpl Equals Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EqualsSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEqualsSymbol() + * @generated + */ + int EQUALS_SYMBOL = 10; + + /** + * The number of structural features of the 'Equals Symbol' class. + * + * + * @generated + * @ordered + */ + int EQUALS_SYMBOL_FEATURE_COUNT = PARTIALITY_SYMBOL_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DataSymbolImpl Data Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DataSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDataSymbol() + * @generated + */ + int DATA_SYMBOL = 11; + + /** + * The number of structural features of the 'Data Symbol' class. + * + * + * @generated + * @ordered + */ + int DATA_SYMBOL_FEATURE_COUNT = SYMBOL_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanSymbolImpl Boolean Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanSymbol() + * @generated + */ + int BOOLEAN_SYMBOL = 12; + + /** + * The number of structural features of the 'Boolean Symbol' class. + * + * + * @generated + * @ordered + */ + int BOOLEAN_SYMBOL_FEATURE_COUNT = DATA_SYMBOL_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntegerSymbolImpl Integer Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntegerSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIntegerSymbol() + * @generated + */ + int INTEGER_SYMBOL = 13; + + /** + * The number of structural features of the 'Integer Symbol' class. + * + * + * @generated + * @ordered + */ + int INTEGER_SYMBOL_FEATURE_COUNT = DATA_SYMBOL_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealSymbolImpl Real Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.RealSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getRealSymbol() + * @generated + */ + int REAL_SYMBOL = 14; + + /** + * The number of structural features of the 'Real Symbol' class. + * + * + * @generated + * @ordered + */ + int REAL_SYMBOL_FEATURE_COUNT = DATA_SYMBOL_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringSymbolImpl String Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringSymbol() + * @generated + */ + int STRING_SYMBOL = 15; + + /** + * The number of structural features of the 'String Symbol' class. + * + * + * @generated + * @ordered + */ + int STRING_SYMBOL_FEATURE_COUNT = DATA_SYMBOL_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ComplexObjectImpl Complex Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ComplexObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getComplexObject() + * @generated + */ + int COMPLEX_OBJECT = 16; + + /** + * The number of structural features of the 'Complex Object' class. + * + * + * @generated + * @ordered + */ + int COMPLEX_OBJECT_FEATURE_COUNT = 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectImpl Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getObject() + * @generated + */ + int OBJECT = 17; + + /** + * The number of structural features of the 'Object' class. + * + * + * @generated + * @ordered + */ + int OBJECT_FEATURE_COUNT = COMPLEX_OBJECT_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl Named Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNamedObject() + * @generated + */ + int NAMED_OBJECT = 18; + + /** + * The feature id for the 'Name' attribute. + * + * + * @generated + * @ordered + */ + int NAMED_OBJECT__NAME = OBJECT_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'Named Object' class. + * + * + * @generated + * @ordered + */ + int NAMED_OBJECT_FEATURE_COUNT = OBJECT_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl Unnamed Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnnamedObject() + * @generated + */ + int UNNAMED_OBJECT = 19; + + /** + * The feature id for the 'Name' attribute. + * + * + * @generated + * @ordered + */ + int UNNAMED_OBJECT__NAME = OBJECT_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'Unnamed Object' class. + * + * + * @generated + * @ordered + */ + int UNNAMED_OBJECT_FEATURE_COUNT = OBJECT_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DataObjectImpl Data Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DataObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDataObject() + * @generated + */ + int DATA_OBJECT = 20; + + /** + * The number of structural features of the 'Data Object' class. + * + * + * @generated + * @ordered + */ + int DATA_OBJECT_FEATURE_COUNT = OBJECT_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl Boolean Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanObject() + * @generated + */ + int BOOLEAN_OBJECT = 21; + + /** + * The feature id for the 'Value' containment reference. + * + * + * @generated + * @ordered + */ + int BOOLEAN_OBJECT__VALUE = DATA_OBJECT_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'Boolean Object' class. + * + * + * @generated + * @ordered + */ + int BOOLEAN_OBJECT_FEATURE_COUNT = DATA_OBJECT_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl Int Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIntObject() + * @generated + */ + int INT_OBJECT = 22; + + /** + * The feature id for the 'Value' attribute. + * + * + * @generated + * @ordered + */ + int INT_OBJECT__VALUE = DATA_OBJECT_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'Int Object' class. + * + * + * @generated + * @ordered + */ + int INT_OBJECT_FEATURE_COUNT = DATA_OBJECT_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl Real Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getRealObject() + * @generated + */ + int REAL_OBJECT = 23; + + /** + * The feature id for the 'Value' attribute. + * + * + * @generated + * @ordered + */ + int REAL_OBJECT__VALUE = DATA_OBJECT_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'Real Object' class. + * + * + * @generated + * @ordered + */ + int REAL_OBJECT_FEATURE_COUNT = DATA_OBJECT_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl String Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringObject() + * @generated + */ + int STRING_OBJECT = 24; + + /** + * The feature id for the 'Value' attribute. + * + * + * @generated + * @ordered + */ + int STRING_OBJECT__VALUE = DATA_OBJECT_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'String Object' class. + * + * + * @generated + * @ordered + */ + int STRING_OBJECT_FEATURE_COUNT = DATA_OBJECT_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl Predicate}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPredicate() + * @generated + */ + int PREDICATE = 25; + + /** + * The feature id for the 'Parameters' containment reference list. + * + * + * @generated + * @ordered + */ + int PREDICATE__PARAMETERS = STATEMENT_FEATURE_COUNT + 0; + + /** + * The feature id for the 'Bodies' containment reference list. + * + * + * @generated + * @ordered + */ + int PREDICATE__BODIES = STATEMENT_FEATURE_COUNT + 1; + + /** + * The number of structural features of the 'Predicate' class. + * + * + * @generated + * @ordered + */ + int PREDICATE_FEATURE_COUNT = STATEMENT_FEATURE_COUNT + 2; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateSymbolImpl Predicate Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPredicateSymbol() + * @generated + */ + int PREDICATE_SYMBOL = 26; + + /** + * The feature id for the 'Parameters' containment reference list. + * + * + * @generated + * @ordered + */ + int PREDICATE_SYMBOL__PARAMETERS = PREDICATE__PARAMETERS; + + /** + * The feature id for the 'Bodies' containment reference list. + * + * + * @generated + * @ordered + */ + int PREDICATE_SYMBOL__BODIES = PREDICATE__BODIES; + + /** + * The feature id for the 'Symbol' containment reference. + * + * + * @generated + * @ordered + */ + int PREDICATE_SYMBOL__SYMBOL = PREDICATE_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'Predicate Symbol' class. + * + * + * @generated + * @ordered + */ + int PREDICATE_SYMBOL_FEATURE_COUNT = PREDICATE_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorPredicateImpl Error Predicate}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorPredicateImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getErrorPredicate() + * @generated + */ + int ERROR_PREDICATE = 27; + + /** + * The feature id for the 'Parameters' containment reference list. + * + * + * @generated + * @ordered + */ + int ERROR_PREDICATE__PARAMETERS = PREDICATE__PARAMETERS; + + /** + * The feature id for the 'Bodies' containment reference list. + * + * + * @generated + * @ordered + */ + int ERROR_PREDICATE__BODIES = PREDICATE__BODIES; + + /** + * The feature id for the 'Name' attribute. + * + * + * @generated + * @ordered + */ + int ERROR_PREDICATE__NAME = PREDICATE_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'Error Predicate' class. + * + * + * @generated + * @ordered + */ + int ERROR_PREDICATE_FEATURE_COUNT = PREDICATE_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl Parameter}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getParameter() + * @generated + */ + int PARAMETER = 28; + + /** + * The feature id for the 'Variable' containment reference. + * + * + * @generated + * @ordered + */ + int PARAMETER__VARIABLE = 0; + + /** + * The feature id for the 'Type' containment reference. + * + * + * @generated + * @ordered + */ + int PARAMETER__TYPE = 1; + + /** + * The number of structural features of the 'Parameter' class. + * + * + * @generated + * @ordered + */ + int PARAMETER_FEATURE_COUNT = 2; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl Pattern Body}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPatternBody() + * @generated + */ + int PATTERN_BODY = 29; + + /** + * The feature id for the 'Constraints' containment reference list. + * + * + * @generated + * @ordered + */ + int PATTERN_BODY__CONSTRAINTS = 0; + + /** + * The number of structural features of the 'Pattern Body' class. + * + * + * @generated + * @ordered + */ + int PATTERN_BODY_FEATURE_COUNT = 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PolarityImpl Polarity}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PolarityImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPolarity() + * @generated + */ + int POLARITY = 30; + + /** + * The number of structural features of the 'Polarity' class. + * + * + * @generated + * @ordered + */ + int POLARITY_FEATURE_COUNT = 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl Constraint}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getConstraint() + * @generated + */ + int CONSTRAINT = 31; + + /** + * The feature id for the 'Polarity' containment reference. + * + * + * @generated + * @ordered + */ + int CONSTRAINT__POLARITY = 0; + + /** + * The feature id for the 'Symbol' containment reference. + * + * + * @generated + * @ordered + */ + int CONSTRAINT__SYMBOL = 1; + + /** + * The feature id for the 'Params' containment reference list. + * + * + * @generated + * @ordered + */ + int CONSTRAINT__PARAMS = 2; + + /** + * The feature id for the 'Closure Type' containment reference. + * + * + * @generated + * @ordered + */ + int CONSTRAINT__CLOSURE_TYPE = 3; + + /** + * The number of structural features of the 'Constraint' class. + * + * + * @generated + * @ordered + */ + int CONSTRAINT_FEATURE_COUNT = 4; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClosureTypeImpl Closure Type}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClosureTypeImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClosureType() + * @generated + */ + int CLOSURE_TYPE = 32; + + /** + * The number of structural features of the 'Closure Type' class. + * + * + * @generated + * @ordered + */ + int CLOSURE_TYPE_FEATURE_COUNT = 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl Literal}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getLiteral() + * @generated + */ + int LITERAL = 33; + + /** + * The number of structural features of the 'Literal' class. + * + * + * @generated + * @ordered + */ + int LITERAL_FEATURE_COUNT = 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl Variable}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getVariable() + * @generated + */ + int VARIABLE = 34; + + /** + * The feature id for the 'Name' attribute. + * + * + * @generated + * @ordered + */ + int VARIABLE__NAME = LITERAL_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'Variable' class. + * + * + * @generated + * @ordered + */ + int VARIABLE_FEATURE_COUNT = LITERAL_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl All Instances}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAllInstances() + * @generated + */ + int ALL_INSTANCES = 35; + + /** + * The feature id for the 'Symbol' containment reference. + * + * + * @generated + * @ordered + */ + int ALL_INSTANCES__SYMBOL = COMPLEX_OBJECT_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'All Instances' class. + * + * + * @generated + * @ordered + */ + int ALL_INSTANCES_FEATURE_COUNT = COMPLEX_OBJECT_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllObjectsImpl All Objects}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AllObjectsImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAllObjects() + * @generated + */ + int ALL_OBJECTS = 36; + + /** + * The number of structural features of the 'All Objects' class. + * + * + * @generated + * @ordered + */ + int ALL_OBJECTS_FEATURE_COUNT = COMPLEX_OBJECT_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl Default Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDefaultInterpretation() + * @generated + */ + int DEFAULT_INTERPRETATION = 37; + + /** + * The feature id for the 'Interpretation' containment reference. + * + * + * @generated + * @ordered + */ + int DEFAULT_INTERPRETATION__INTERPRETATION = INTERPRETATION_FEATURE_COUNT + 0; + + /** + * The number of structural features of the 'Default Interpretation' class. + * + * + * @generated + * @ordered + */ + int DEFAULT_INTERPRETATION_FEATURE_COUNT = INTERPRETATION_FEATURE_COUNT + 1; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CDInterpretationImpl CD Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.CDInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getCDInterpretation() + * @generated + */ + int CD_INTERPRETATION = 38; + + /** + * The number of structural features of the 'CD Interpretation' class. + * + * + * @generated + * @ordered + */ + int CD_INTERPRETATION_FEATURE_COUNT = INTERPRETATION_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl Class Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClassInterpretation() + * @generated + */ + int CLASS_INTERPRETATION = 39; + + /** + * The feature id for the 'Abstract' attribute. + * + * + * @generated + * @ordered + */ + int CLASS_INTERPRETATION__ABSTRACT = CD_INTERPRETATION_FEATURE_COUNT + 0; + + /** + * The feature id for the 'Symbol' containment reference. + * + * + * @generated + * @ordered + */ + int CLASS_INTERPRETATION__SYMBOL = CD_INTERPRETATION_FEATURE_COUNT + 1; + + /** + * The feature id for the 'Supertypes' containment reference list. + * + * + * @generated + * @ordered + */ + int CLASS_INTERPRETATION__SUPERTYPES = CD_INTERPRETATION_FEATURE_COUNT + 2; + + /** + * The feature id for the 'Fielt' containment reference list. + * + * + * @generated + * @ordered + */ + int CLASS_INTERPRETATION__FIELT = CD_INTERPRETATION_FEATURE_COUNT + 3; + + /** + * The number of structural features of the 'Class Interpretation' class. + * + * + * @generated + * @ordered + */ + int CLASS_INTERPRETATION_FEATURE_COUNT = CD_INTERPRETATION_FEATURE_COUNT + 4; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl Enum Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEnumInterpretation() + * @generated + */ + int ENUM_INTERPRETATION = 40; + + /** + * The feature id for the 'Symbol' containment reference. + * + * + * @generated + * @ordered + */ + int ENUM_INTERPRETATION__SYMBOL = CD_INTERPRETATION_FEATURE_COUNT + 0; + + /** + * The feature id for the 'Objects' containment reference list. + * + * + * @generated + * @ordered + */ + int ENUM_INTERPRETATION__OBJECTS = CD_INTERPRETATION_FEATURE_COUNT + 1; + + /** + * The number of structural features of the 'Enum Interpretation' class. + * + * + * @generated + * @ordered + */ + int ENUM_INTERPRETATION_FEATURE_COUNT = CD_INTERPRETATION_FEATURE_COUNT + 2; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl Field Relation Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getFieldRelationInterpretation() + * @generated + */ + int FIELD_RELATION_INTERPRETATION = 41; + + /** + * The feature id for the 'Containment' attribute. + * + * + * @generated + * @ordered + */ + int FIELD_RELATION_INTERPRETATION__CONTAINMENT = 0; + + /** + * The feature id for the 'Symbol' containment reference. + * + * + * @generated + * @ordered + */ + int FIELD_RELATION_INTERPRETATION__SYMBOL = 1; + + /** + * The feature id for the 'Multiplicity' containment reference. + * + * + * @generated + * @ordered + */ + int FIELD_RELATION_INTERPRETATION__MULTIPLICITY = 2; + + /** + * The feature id for the 'Target' containment reference. + * + * + * @generated + * @ordered + */ + int FIELD_RELATION_INTERPRETATION__TARGET = 3; + + /** + * The number of structural features of the 'Field Relation Interpretation' class. + * + * + * @generated + * @ordered + */ + int FIELD_RELATION_INTERPRETATION_FEATURE_COUNT = 4; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl Global Relation Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getGlobalRelationInterpretation() + * @generated + */ + int GLOBAL_RELATION_INTERPRETATION = 42; + + /** + * The feature id for the 'Containment' attribute. + * + * + * @generated + * @ordered + */ + int GLOBAL_RELATION_INTERPRETATION__CONTAINMENT = CD_INTERPRETATION_FEATURE_COUNT + 0; + + /** + * The feature id for the 'Symbol' containment reference. + * + * + * @generated + * @ordered + */ + int GLOBAL_RELATION_INTERPRETATION__SYMBOL = CD_INTERPRETATION_FEATURE_COUNT + 1; + + /** + * The feature id for the 'Source Multiplicity' containment reference. + * + * + * @generated + * @ordered + */ + int GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY = CD_INTERPRETATION_FEATURE_COUNT + 2; + + /** + * The feature id for the 'Source' containment reference. + * + * + * @generated + * @ordered + */ + int GLOBAL_RELATION_INTERPRETATION__SOURCE = CD_INTERPRETATION_FEATURE_COUNT + 3; + + /** + * The feature id for the 'Target Multiplicity' containment reference. + * + * + * @generated + * @ordered + */ + int GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY = CD_INTERPRETATION_FEATURE_COUNT + 4; + + /** + * The feature id for the 'Target' containment reference. + * + * + * @generated + * @ordered + */ + int GLOBAL_RELATION_INTERPRETATION__TARGET = CD_INTERPRETATION_FEATURE_COUNT + 5; + + /** + * The number of structural features of the 'Global Relation Interpretation' class. + * + * + * @generated + * @ordered + */ + int GLOBAL_RELATION_INTERPRETATION_FEATURE_COUNT = CD_INTERPRETATION_FEATURE_COUNT + 6; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl Multiplicity Definition}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMultiplicityDefinition() + * @generated + */ + int MULTIPLICITY_DEFINITION = 43; + + /** + * The feature id for the 'Lower' attribute. + * + * + * @generated + * @ordered + */ + int MULTIPLICITY_DEFINITION__LOWER = 0; + + /** + * The feature id for the 'Upper' attribute. + * + * + * @generated + * @ordered + */ + int MULTIPLICITY_DEFINITION__UPPER = 1; + + /** + * The feature id for the 'Unlimited Upper' attribute. + * + * + * @generated + * @ordered + */ + int MULTIPLICITY_DEFINITION__UNLIMITED_UPPER = 2; + + /** + * The number of structural features of the 'Multiplicity Definition' class. + * + * + * @generated + * @ordered + */ + int MULTIPLICITY_DEFINITION_FEATURE_COUNT = 3; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanTrueImpl Boolean True}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanTrueImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanTrue() + * @generated + */ + int BOOLEAN_TRUE = 44; + + /** + * The number of structural features of the 'Boolean True' class. + * + * + * @generated + * @ordered + */ + int BOOLEAN_TRUE_FEATURE_COUNT = BOOLEAN_VALUE_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanFalseImpl Boolean False}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanFalseImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanFalse() + * @generated + */ + int BOOLEAN_FALSE = 45; + + /** + * The number of structural features of the 'Boolean False' class. + * + * + * @generated + * @ordered + */ + int BOOLEAN_FALSE_FEATURE_COUNT = BOOLEAN_VALUE_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TrueImpl True}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TrueImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTrue() + * @generated + */ + int TRUE = 46; + + /** + * The number of structural features of the 'True' class. + * + * + * @generated + * @ordered + */ + int TRUE_FEATURE_COUNT = TRUTH_VALUE_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FalseImpl False}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.FalseImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getFalse() + * @generated + */ + int FALSE = 47; + + /** + * The number of structural features of the 'False' class. + * + * + * @generated + * @ordered + */ + int FALSE_FEATURE_COUNT = TRUTH_VALUE_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnknownImpl Unknown}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnknownImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnknown() + * @generated + */ + int UNKNOWN = 48; + + /** + * The number of structural features of the 'Unknown' class. + * + * + * @generated + * @ordered + */ + int UNKNOWN_FEATURE_COUNT = TRUTH_VALUE_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorImpl Error}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getError() + * @generated + */ + int ERROR = 49; + + /** + * The number of structural features of the 'Error' class. + * + * + * @generated + * @ordered + */ + int ERROR_FEATURE_COUNT = TRUTH_VALUE_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PositiveImpl Positive}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PositiveImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPositive() + * @generated + */ + int POSITIVE = 50; + + /** + * The number of structural features of the 'Positive' class. + * + * + * @generated + * @ordered + */ + int POSITIVE_FEATURE_COUNT = POLARITY_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NegativeImpl Negative}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NegativeImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNegative() + * @generated + */ + int NEGATIVE = 51; + + /** + * The number of structural features of the 'Negative' class. + * + * + * @generated + * @ordered + */ + int NEGATIVE_FEATURE_COUNT = POLARITY_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ReflexiveClosureImpl Reflexive Closure}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ReflexiveClosureImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getReflexiveClosure() + * @generated + */ + int REFLEXIVE_CLOSURE = 52; + + /** + * The number of structural features of the 'Reflexive Closure' class. + * + * + * @generated + * @ordered + */ + int REFLEXIVE_CLOSURE_FEATURE_COUNT = CLOSURE_TYPE_FEATURE_COUNT + 0; + + /** + * The meta object id for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IrreflexiveClosureImpl Irreflexive Closure}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IrreflexiveClosureImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIrreflexiveClosure() + * @generated + */ + int IRREFLEXIVE_CLOSURE = 53; + + /** + * The number of structural features of the 'Irreflexive Closure' class. + * + * + * @generated + * @ordered + */ + int IRREFLEXIVE_CLOSURE_FEATURE_COUNT = CLOSURE_TYPE_FEATURE_COUNT + 0; + + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Problem Problem}'. + * + * + * @return the meta object for class 'Problem'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Problem + * @generated + */ + EClass getProblem(); + + /** + * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Problem#getStatements Statements}'. + * + * + * @return the meta object for the containment reference list 'Statements'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Problem#getStatements() + * @see #getProblem() + * @generated + */ + EReference getProblem_Statements(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Statement Statement}'. + * + * + * @return the meta object for class 'Statement'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Statement + * @generated + */ + EClass getStatement(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanValue Boolean Value}'. + * + * + * @return the meta object for class 'Boolean Value'. + * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanValue + * @generated + */ + EClass getBooleanValue(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.TruthValue Truth Value}'. + * + * + * @return the meta object for class 'Truth Value'. + * @see org.eclipse.viatra.solver.language.solverLanguage.TruthValue + * @generated + */ + EClass getTruthValue(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Interpretation Interpretation}'. + * + * + * @return the meta object for class 'Interpretation'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Interpretation + * @generated + */ + EClass getInterpretation(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation Basic Interpretation}'. + * + * + * @return the meta object for class 'Basic Interpretation'. + * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation + * @generated + */ + EClass getBasicInterpretation(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getSymbol Symbol}'. + * + * + * @return the meta object for the containment reference 'Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getSymbol() + * @see #getBasicInterpretation() + * @generated + */ + EReference getBasicInterpretation_Symbol(); + + /** + * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getObjects Objects}'. + * + * + * @return the meta object for the containment reference list 'Objects'. + * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getObjects() + * @see #getBasicInterpretation() + * @generated + */ + EReference getBasicInterpretation_Objects(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getValue Value}'. + * + * + * @return the meta object for the containment reference 'Value'. + * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation#getValue() + * @see #getBasicInterpretation() + * @generated + */ + EReference getBasicInterpretation_Value(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Symbol Symbol}'. + * + * + * @return the meta object for class 'Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Symbol + * @generated + */ + EClass getSymbol(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol Model Symbol}'. + * + * + * @return the meta object for class 'Model Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol + * @generated + */ + EClass getModelSymbol(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol#getName Name}'. + * + * + * @return the meta object for the attribute 'Name'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol#getName() + * @see #getModelSymbol() + * @generated + */ + EAttribute getModelSymbol_Name(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol Partiality Symbol}'. + * + * + * @return the meta object for class 'Partiality Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol + * @generated + */ + EClass getPartialitySymbol(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol Exist Symbol}'. + * + * + * @return the meta object for class 'Exist Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol + * @generated + */ + EClass getExistSymbol(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol Equals Symbol}'. + * + * + * @return the meta object for class 'Equals Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol + * @generated + */ + EClass getEqualsSymbol(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.DataSymbol Data Symbol}'. + * + * + * @return the meta object for class 'Data Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.DataSymbol + * @generated + */ + EClass getDataSymbol(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol Boolean Symbol}'. + * + * + * @return the meta object for class 'Boolean Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol + * @generated + */ + EClass getBooleanSymbol(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol Integer Symbol}'. + * + * + * @return the meta object for class 'Integer Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol + * @generated + */ + EClass getIntegerSymbol(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealSymbol Real Symbol}'. + * + * + * @return the meta object for class 'Real Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.RealSymbol + * @generated + */ + EClass getRealSymbol(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringSymbol String Symbol}'. + * + * + * @return the meta object for class 'String Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.StringSymbol + * @generated + */ + EClass getStringSymbol(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ComplexObject Complex Object}'. + * + * + * @return the meta object for class 'Complex Object'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ComplexObject + * @generated + */ + EClass getComplexObject(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Object Object}'. + * + * + * @return the meta object for class 'Object'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Object + * @generated + */ + EClass getObject(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject Named Object}'. + * + * + * @return the meta object for class 'Named Object'. + * @see org.eclipse.viatra.solver.language.solverLanguage.NamedObject + * @generated + */ + EClass getNamedObject(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject#getName Name}'. + * + * + * @return the meta object for the attribute 'Name'. + * @see org.eclipse.viatra.solver.language.solverLanguage.NamedObject#getName() + * @see #getNamedObject() + * @generated + */ + EAttribute getNamedObject_Name(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject Unnamed Object}'. + * + * + * @return the meta object for class 'Unnamed Object'. + * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject + * @generated + */ + EClass getUnnamedObject(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject#getName Name}'. + * + * + * @return the meta object for the attribute 'Name'. + * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject#getName() + * @see #getUnnamedObject() + * @generated + */ + EAttribute getUnnamedObject_Name(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.DataObject Data Object}'. + * + * + * @return the meta object for class 'Data Object'. + * @see org.eclipse.viatra.solver.language.solverLanguage.DataObject + * @generated + */ + EClass getDataObject(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject Boolean Object}'. + * + * + * @return the meta object for class 'Boolean Object'. + * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanObject + * @generated + */ + EClass getBooleanObject(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject#getValue Value}'. + * + * + * @return the meta object for the containment reference 'Value'. + * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanObject#getValue() + * @see #getBooleanObject() + * @generated + */ + EReference getBooleanObject_Value(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject Int Object}'. + * + * + * @return the meta object for class 'Int Object'. + * @see org.eclipse.viatra.solver.language.solverLanguage.IntObject + * @generated + */ + EClass getIntObject(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject#getValue Value}'. + * + * + * @return the meta object for the attribute 'Value'. + * @see org.eclipse.viatra.solver.language.solverLanguage.IntObject#getValue() + * @see #getIntObject() + * @generated + */ + EAttribute getIntObject_Value(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject Real Object}'. + * + * + * @return the meta object for class 'Real Object'. + * @see org.eclipse.viatra.solver.language.solverLanguage.RealObject + * @generated + */ + EClass getRealObject(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject#getValue Value}'. + * + * + * @return the meta object for the attribute 'Value'. + * @see org.eclipse.viatra.solver.language.solverLanguage.RealObject#getValue() + * @see #getRealObject() + * @generated + */ + EAttribute getRealObject_Value(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject String Object}'. + * + * + * @return the meta object for class 'String Object'. + * @see org.eclipse.viatra.solver.language.solverLanguage.StringObject + * @generated + */ + EClass getStringObject(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject#getValue Value}'. + * + * + * @return the meta object for the attribute 'Value'. + * @see org.eclipse.viatra.solver.language.solverLanguage.StringObject#getValue() + * @see #getStringObject() + * @generated + */ + EAttribute getStringObject_Value(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate Predicate}'. + * + * + * @return the meta object for class 'Predicate'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate + * @generated + */ + EClass getPredicate(); + + /** + * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getParameters Parameters}'. + * + * + * @return the meta object for the containment reference list 'Parameters'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate#getParameters() + * @see #getPredicate() + * @generated + */ + EReference getPredicate_Parameters(); + + /** + * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate#getBodies Bodies}'. + * + * + * @return the meta object for the containment reference list 'Bodies'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate#getBodies() + * @see #getPredicate() + * @generated + */ + EReference getPredicate_Bodies(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol Predicate Symbol}'. + * + * + * @return the meta object for class 'Predicate Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol + * @generated + */ + EClass getPredicateSymbol(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol#getSymbol Symbol}'. + * + * + * @return the meta object for the containment reference 'Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol#getSymbol() + * @see #getPredicateSymbol() + * @generated + */ + EReference getPredicateSymbol_Symbol(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate Error Predicate}'. + * + * + * @return the meta object for class 'Error Predicate'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate + * @generated + */ + EClass getErrorPredicate(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate#getName Name}'. + * + * + * @return the meta object for the attribute 'Name'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate#getName() + * @see #getErrorPredicate() + * @generated + */ + EAttribute getErrorPredicate_Name(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter Parameter}'. + * + * + * @return the meta object for class 'Parameter'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Parameter + * @generated + */ + EClass getParameter(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getVariable Variable}'. + * + * + * @return the meta object for the containment reference 'Variable'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Parameter#getVariable() + * @see #getParameter() + * @generated + */ + EReference getParameter_Variable(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter#getType Type}'. + * + * + * @return the meta object for the containment reference 'Type'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Parameter#getType() + * @see #getParameter() + * @generated + */ + EReference getParameter_Type(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody Pattern Body}'. + * + * + * @return the meta object for class 'Pattern Body'. + * @see org.eclipse.viatra.solver.language.solverLanguage.PatternBody + * @generated + */ + EClass getPatternBody(); + + /** + * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody#getConstraints Constraints}'. + * + * + * @return the meta object for the containment reference list 'Constraints'. + * @see org.eclipse.viatra.solver.language.solverLanguage.PatternBody#getConstraints() + * @see #getPatternBody() + * @generated + */ + EReference getPatternBody_Constraints(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Polarity Polarity}'. + * + * + * @return the meta object for class 'Polarity'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Polarity + * @generated + */ + EClass getPolarity(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint Constraint}'. + * + * + * @return the meta object for class 'Constraint'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint + * @generated + */ + EClass getConstraint(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getPolarity Polarity}'. + * + * + * @return the meta object for the containment reference 'Polarity'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint#getPolarity() + * @see #getConstraint() + * @generated + */ + EReference getConstraint_Polarity(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getSymbol Symbol}'. + * + * + * @return the meta object for the containment reference 'Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint#getSymbol() + * @see #getConstraint() + * @generated + */ + EReference getConstraint_Symbol(); + + /** + * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getParams Params}'. + * + * + * @return the meta object for the containment reference list 'Params'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint#getParams() + * @see #getConstraint() + * @generated + */ + EReference getConstraint_Params(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint#getClosureType Closure Type}'. + * + * + * @return the meta object for the containment reference 'Closure Type'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint#getClosureType() + * @see #getConstraint() + * @generated + */ + EReference getConstraint_ClosureType(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClosureType Closure Type}'. + * + * + * @return the meta object for class 'Closure Type'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ClosureType + * @generated + */ + EClass getClosureType(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Literal Literal}'. + * + * + * @return the meta object for class 'Literal'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Literal + * @generated + */ + EClass getLiteral(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable Variable}'. + * + * + * @return the meta object for class 'Variable'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Variable + * @generated + */ + EClass getVariable(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable#getName Name}'. + * + * + * @return the meta object for the attribute 'Name'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Variable#getName() + * @see #getVariable() + * @generated + */ + EAttribute getVariable_Name(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances All Instances}'. + * + * + * @return the meta object for class 'All Instances'. + * @see org.eclipse.viatra.solver.language.solverLanguage.AllInstances + * @generated + */ + EClass getAllInstances(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances#getSymbol Symbol}'. + * + * + * @return the meta object for the containment reference 'Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.AllInstances#getSymbol() + * @see #getAllInstances() + * @generated + */ + EReference getAllInstances_Symbol(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.AllObjects All Objects}'. + * + * + * @return the meta object for class 'All Objects'. + * @see org.eclipse.viatra.solver.language.solverLanguage.AllObjects + * @generated + */ + EClass getAllObjects(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation Default Interpretation}'. + * + * + * @return the meta object for class 'Default Interpretation'. + * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation + * @generated + */ + EClass getDefaultInterpretation(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation#getInterpretation Interpretation}'. + * + * + * @return the meta object for the containment reference 'Interpretation'. + * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation#getInterpretation() + * @see #getDefaultInterpretation() + * @generated + */ + EReference getDefaultInterpretation_Interpretation(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation CD Interpretation}'. + * + * + * @return the meta object for class 'CD Interpretation'. + * @see org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation + * @generated + */ + EClass getCDInterpretation(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation Class Interpretation}'. + * + * + * @return the meta object for class 'Class Interpretation'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation + * @generated + */ + EClass getClassInterpretation(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#isAbstract Abstract}'. + * + * + * @return the meta object for the attribute 'Abstract'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#isAbstract() + * @see #getClassInterpretation() + * @generated + */ + EAttribute getClassInterpretation_Abstract(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSymbol Symbol}'. + * + * + * @return the meta object for the containment reference 'Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSymbol() + * @see #getClassInterpretation() + * @generated + */ + EReference getClassInterpretation_Symbol(); + + /** + * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSupertypes Supertypes}'. + * + * + * @return the meta object for the containment reference list 'Supertypes'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getSupertypes() + * @see #getClassInterpretation() + * @generated + */ + EReference getClassInterpretation_Supertypes(); + + /** + * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getFielt Fielt}'. + * + * + * @return the meta object for the containment reference list 'Fielt'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation#getFielt() + * @see #getClassInterpretation() + * @generated + */ + EReference getClassInterpretation_Fielt(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation Enum Interpretation}'. + * + * + * @return the meta object for class 'Enum Interpretation'. + * @see org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation + * @generated + */ + EClass getEnumInterpretation(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getSymbol Symbol}'. + * + * + * @return the meta object for the containment reference 'Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getSymbol() + * @see #getEnumInterpretation() + * @generated + */ + EReference getEnumInterpretation_Symbol(); + + /** + * Returns the meta object for the containment reference list '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getObjects Objects}'. + * + * + * @return the meta object for the containment reference list 'Objects'. + * @see org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation#getObjects() + * @see #getEnumInterpretation() + * @generated + */ + EReference getEnumInterpretation_Objects(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation Field Relation Interpretation}'. + * + * + * @return the meta object for class 'Field Relation Interpretation'. + * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation + * @generated + */ + EClass getFieldRelationInterpretation(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#isContainment Containment}'. + * + * + * @return the meta object for the attribute 'Containment'. + * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#isContainment() + * @see #getFieldRelationInterpretation() + * @generated + */ + EAttribute getFieldRelationInterpretation_Containment(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getSymbol Symbol}'. + * + * + * @return the meta object for the containment reference 'Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getSymbol() + * @see #getFieldRelationInterpretation() + * @generated + */ + EReference getFieldRelationInterpretation_Symbol(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getMultiplicity Multiplicity}'. + * + * + * @return the meta object for the containment reference 'Multiplicity'. + * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getMultiplicity() + * @see #getFieldRelationInterpretation() + * @generated + */ + EReference getFieldRelationInterpretation_Multiplicity(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getTarget Target}'. + * + * + * @return the meta object for the containment reference 'Target'. + * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation#getTarget() + * @see #getFieldRelationInterpretation() + * @generated + */ + EReference getFieldRelationInterpretation_Target(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation Global Relation Interpretation}'. + * + * + * @return the meta object for class 'Global Relation Interpretation'. + * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation + * @generated + */ + EClass getGlobalRelationInterpretation(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#isContainment Containment}'. + * + * + * @return the meta object for the attribute 'Containment'. + * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#isContainment() + * @see #getGlobalRelationInterpretation() + * @generated + */ + EAttribute getGlobalRelationInterpretation_Containment(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSymbol Symbol}'. + * + * + * @return the meta object for the containment reference 'Symbol'. + * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSymbol() + * @see #getGlobalRelationInterpretation() + * @generated + */ + EReference getGlobalRelationInterpretation_Symbol(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSourceMultiplicity Source Multiplicity}'. + * + * + * @return the meta object for the containment reference 'Source Multiplicity'. + * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSourceMultiplicity() + * @see #getGlobalRelationInterpretation() + * @generated + */ + EReference getGlobalRelationInterpretation_SourceMultiplicity(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSource Source}'. + * + * + * @return the meta object for the containment reference 'Source'. + * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getSource() + * @see #getGlobalRelationInterpretation() + * @generated + */ + EReference getGlobalRelationInterpretation_Source(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTargetMultiplicity Target Multiplicity}'. + * + * + * @return the meta object for the containment reference 'Target Multiplicity'. + * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTargetMultiplicity() + * @see #getGlobalRelationInterpretation() + * @generated + */ + EReference getGlobalRelationInterpretation_TargetMultiplicity(); + + /** + * Returns the meta object for the containment reference '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTarget Target}'. + * + * + * @return the meta object for the containment reference 'Target'. + * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation#getTarget() + * @see #getGlobalRelationInterpretation() + * @generated + */ + EReference getGlobalRelationInterpretation_Target(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition Multiplicity Definition}'. + * + * + * @return the meta object for class 'Multiplicity Definition'. + * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition + * @generated + */ + EClass getMultiplicityDefinition(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getLower Lower}'. + * + * + * @return the meta object for the attribute 'Lower'. + * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getLower() + * @see #getMultiplicityDefinition() + * @generated + */ + EAttribute getMultiplicityDefinition_Lower(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getUpper Upper}'. + * + * + * @return the meta object for the attribute 'Upper'. + * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#getUpper() + * @see #getMultiplicityDefinition() + * @generated + */ + EAttribute getMultiplicityDefinition_Upper(); + + /** + * Returns the meta object for the attribute '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#isUnlimitedUpper Unlimited Upper}'. + * + * + * @return the meta object for the attribute 'Unlimited Upper'. + * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition#isUnlimitedUpper() + * @see #getMultiplicityDefinition() + * @generated + */ + EAttribute getMultiplicityDefinition_UnlimitedUpper(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue Boolean True}'. + * + * + * @return the meta object for class 'Boolean True'. + * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue + * @generated + */ + EClass getBooleanTrue(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse Boolean False}'. + * + * + * @return the meta object for class 'Boolean False'. + * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse + * @generated + */ + EClass getBooleanFalse(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.True True}'. + * + * + * @return the meta object for class 'True'. + * @see org.eclipse.viatra.solver.language.solverLanguage.True + * @generated + */ + EClass getTrue(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.False False}'. + * + * + * @return the meta object for class 'False'. + * @see org.eclipse.viatra.solver.language.solverLanguage.False + * @generated + */ + EClass getFalse(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Unknown Unknown}'. + * + * + * @return the meta object for class 'Unknown'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Unknown + * @generated + */ + EClass getUnknown(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Error Error}'. + * + * + * @return the meta object for class 'Error'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Error + * @generated + */ + EClass getError(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Positive Positive}'. + * + * + * @return the meta object for class 'Positive'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Positive + * @generated + */ + EClass getPositive(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.Negative Negative}'. + * + * + * @return the meta object for class 'Negative'. + * @see org.eclipse.viatra.solver.language.solverLanguage.Negative + * @generated + */ + EClass getNegative(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure Reflexive Closure}'. + * + * + * @return the meta object for class 'Reflexive Closure'. + * @see org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure + * @generated + */ + EClass getReflexiveClosure(); + + /** + * Returns the meta object for class '{@link org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure Irreflexive Closure}'. + * + * + * @return the meta object for class 'Irreflexive Closure'. + * @see org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure + * @generated + */ + EClass getIrreflexiveClosure(); + + /** + * Returns the factory that creates the instances of the model. + * + * + * @return the factory that creates the instances of the model. + * @generated + */ + SolverLanguageFactory getSolverLanguageFactory(); + + /** + * + * Defines literals for the meta objects that represent + *
    + *
  • each class,
    • + *
  • each feature of each class,
    • + *
  • each enum,
    • + *
  • and each data type
    • + *
+ * + * @generated + */ + interface Literals + { + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ProblemImpl Problem}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ProblemImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getProblem() + * @generated + */ + EClass PROBLEM = eINSTANCE.getProblem(); + + /** + * The meta object literal for the 'Statements' containment reference list feature. + * + * + * @generated + */ + EReference PROBLEM__STATEMENTS = eINSTANCE.getProblem_Statements(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StatementImpl Statement}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StatementImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStatement() + * @generated + */ + EClass STATEMENT = eINSTANCE.getStatement(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanValueImpl Boolean Value}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanValueImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanValue() + * @generated + */ + EClass BOOLEAN_VALUE = eINSTANCE.getBooleanValue(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TruthValueImpl Truth Value}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TruthValueImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTruthValue() + * @generated + */ + EClass TRUTH_VALUE = eINSTANCE.getTruthValue(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.InterpretationImpl Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.InterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getInterpretation() + * @generated + */ + EClass INTERPRETATION = eINSTANCE.getInterpretation(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl Basic Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBasicInterpretation() + * @generated + */ + EClass BASIC_INTERPRETATION = eINSTANCE.getBasicInterpretation(); + + /** + * The meta object literal for the 'Symbol' containment reference feature. + * + * + * @generated + */ + EReference BASIC_INTERPRETATION__SYMBOL = eINSTANCE.getBasicInterpretation_Symbol(); + + /** + * The meta object literal for the 'Objects' containment reference list feature. + * + * + * @generated + */ + EReference BASIC_INTERPRETATION__OBJECTS = eINSTANCE.getBasicInterpretation_Objects(); + + /** + * The meta object literal for the 'Value' containment reference feature. + * + * + * @generated + */ + EReference BASIC_INTERPRETATION__VALUE = eINSTANCE.getBasicInterpretation_Value(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.SymbolImpl Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getSymbol() + * @generated + */ + EClass SYMBOL = eINSTANCE.getSymbol(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl Model Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getModelSymbol() + * @generated + */ + EClass MODEL_SYMBOL = eINSTANCE.getModelSymbol(); + + /** + * The meta object literal for the 'Name' attribute feature. + * + * + * @generated + */ + EAttribute MODEL_SYMBOL__NAME = eINSTANCE.getModelSymbol_Name(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PartialitySymbolImpl Partiality Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PartialitySymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPartialitySymbol() + * @generated + */ + EClass PARTIALITY_SYMBOL = eINSTANCE.getPartialitySymbol(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ExistSymbolImpl Exist Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ExistSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getExistSymbol() + * @generated + */ + EClass EXIST_SYMBOL = eINSTANCE.getExistSymbol(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EqualsSymbolImpl Equals Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EqualsSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEqualsSymbol() + * @generated + */ + EClass EQUALS_SYMBOL = eINSTANCE.getEqualsSymbol(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DataSymbolImpl Data Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DataSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDataSymbol() + * @generated + */ + EClass DATA_SYMBOL = eINSTANCE.getDataSymbol(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanSymbolImpl Boolean Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanSymbol() + * @generated + */ + EClass BOOLEAN_SYMBOL = eINSTANCE.getBooleanSymbol(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntegerSymbolImpl Integer Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntegerSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIntegerSymbol() + * @generated + */ + EClass INTEGER_SYMBOL = eINSTANCE.getIntegerSymbol(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealSymbolImpl Real Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.RealSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getRealSymbol() + * @generated + */ + EClass REAL_SYMBOL = eINSTANCE.getRealSymbol(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringSymbolImpl String Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringSymbol() + * @generated + */ + EClass STRING_SYMBOL = eINSTANCE.getStringSymbol(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ComplexObjectImpl Complex Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ComplexObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getComplexObject() + * @generated + */ + EClass COMPLEX_OBJECT = eINSTANCE.getComplexObject(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectImpl Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getObject() + * @generated + */ + EClass OBJECT = eINSTANCE.getObject(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl Named Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNamedObject() + * @generated + */ + EClass NAMED_OBJECT = eINSTANCE.getNamedObject(); + + /** + * The meta object literal for the 'Name' attribute feature. + * + * + * @generated + */ + EAttribute NAMED_OBJECT__NAME = eINSTANCE.getNamedObject_Name(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl Unnamed Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnnamedObject() + * @generated + */ + EClass UNNAMED_OBJECT = eINSTANCE.getUnnamedObject(); + + /** + * The meta object literal for the 'Name' attribute feature. + * + * + * @generated + */ + EAttribute UNNAMED_OBJECT__NAME = eINSTANCE.getUnnamedObject_Name(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DataObjectImpl Data Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DataObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDataObject() + * @generated + */ + EClass DATA_OBJECT = eINSTANCE.getDataObject(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl Boolean Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanObject() + * @generated + */ + EClass BOOLEAN_OBJECT = eINSTANCE.getBooleanObject(); + + /** + * The meta object literal for the 'Value' containment reference feature. + * + * + * @generated + */ + EReference BOOLEAN_OBJECT__VALUE = eINSTANCE.getBooleanObject_Value(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl Int Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIntObject() + * @generated + */ + EClass INT_OBJECT = eINSTANCE.getIntObject(); + + /** + * The meta object literal for the 'Value' attribute feature. + * + * + * @generated + */ + EAttribute INT_OBJECT__VALUE = eINSTANCE.getIntObject_Value(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl Real Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getRealObject() + * @generated + */ + EClass REAL_OBJECT = eINSTANCE.getRealObject(); + + /** + * The meta object literal for the 'Value' attribute feature. + * + * + * @generated + */ + EAttribute REAL_OBJECT__VALUE = eINSTANCE.getRealObject_Value(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl String Object}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getStringObject() + * @generated + */ + EClass STRING_OBJECT = eINSTANCE.getStringObject(); + + /** + * The meta object literal for the 'Value' attribute feature. + * + * + * @generated + */ + EAttribute STRING_OBJECT__VALUE = eINSTANCE.getStringObject_Value(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl Predicate}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPredicate() + * @generated + */ + EClass PREDICATE = eINSTANCE.getPredicate(); + + /** + * The meta object literal for the 'Parameters' containment reference list feature. + * + * + * @generated + */ + EReference PREDICATE__PARAMETERS = eINSTANCE.getPredicate_Parameters(); + + /** + * The meta object literal for the 'Bodies' containment reference list feature. + * + * + * @generated + */ + EReference PREDICATE__BODIES = eINSTANCE.getPredicate_Bodies(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateSymbolImpl Predicate Symbol}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateSymbolImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPredicateSymbol() + * @generated + */ + EClass PREDICATE_SYMBOL = eINSTANCE.getPredicateSymbol(); + + /** + * The meta object literal for the 'Symbol' containment reference feature. + * + * + * @generated + */ + EReference PREDICATE_SYMBOL__SYMBOL = eINSTANCE.getPredicateSymbol_Symbol(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorPredicateImpl Error Predicate}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorPredicateImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getErrorPredicate() + * @generated + */ + EClass ERROR_PREDICATE = eINSTANCE.getErrorPredicate(); + + /** + * The meta object literal for the 'Name' attribute feature. + * + * + * @generated + */ + EAttribute ERROR_PREDICATE__NAME = eINSTANCE.getErrorPredicate_Name(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl Parameter}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getParameter() + * @generated + */ + EClass PARAMETER = eINSTANCE.getParameter(); + + /** + * The meta object literal for the 'Variable' containment reference feature. + * + * + * @generated + */ + EReference PARAMETER__VARIABLE = eINSTANCE.getParameter_Variable(); + + /** + * The meta object literal for the 'Type' containment reference feature. + * + * + * @generated + */ + EReference PARAMETER__TYPE = eINSTANCE.getParameter_Type(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl Pattern Body}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPatternBody() + * @generated + */ + EClass PATTERN_BODY = eINSTANCE.getPatternBody(); + + /** + * The meta object literal for the 'Constraints' containment reference list feature. + * + * + * @generated + */ + EReference PATTERN_BODY__CONSTRAINTS = eINSTANCE.getPatternBody_Constraints(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PolarityImpl Polarity}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PolarityImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPolarity() + * @generated + */ + EClass POLARITY = eINSTANCE.getPolarity(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl Constraint}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getConstraint() + * @generated + */ + EClass CONSTRAINT = eINSTANCE.getConstraint(); + + /** + * The meta object literal for the 'Polarity' containment reference feature. + * + * + * @generated + */ + EReference CONSTRAINT__POLARITY = eINSTANCE.getConstraint_Polarity(); + + /** + * The meta object literal for the 'Symbol' containment reference feature. + * + * + * @generated + */ + EReference CONSTRAINT__SYMBOL = eINSTANCE.getConstraint_Symbol(); + + /** + * The meta object literal for the 'Params' containment reference list feature. + * + * + * @generated + */ + EReference CONSTRAINT__PARAMS = eINSTANCE.getConstraint_Params(); + + /** + * The meta object literal for the 'Closure Type' containment reference feature. + * + * + * @generated + */ + EReference CONSTRAINT__CLOSURE_TYPE = eINSTANCE.getConstraint_ClosureType(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClosureTypeImpl Closure Type}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClosureTypeImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClosureType() + * @generated + */ + EClass CLOSURE_TYPE = eINSTANCE.getClosureType(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl Literal}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.LiteralImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getLiteral() + * @generated + */ + EClass LITERAL = eINSTANCE.getLiteral(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl Variable}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getVariable() + * @generated + */ + EClass VARIABLE = eINSTANCE.getVariable(); + + /** + * The meta object literal for the 'Name' attribute feature. + * + * + * @generated + */ + EAttribute VARIABLE__NAME = eINSTANCE.getVariable_Name(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl All Instances}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAllInstances() + * @generated + */ + EClass ALL_INSTANCES = eINSTANCE.getAllInstances(); + + /** + * The meta object literal for the 'Symbol' containment reference feature. + * + * + * @generated + */ + EReference ALL_INSTANCES__SYMBOL = eINSTANCE.getAllInstances_Symbol(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllObjectsImpl All Objects}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.AllObjectsImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getAllObjects() + * @generated + */ + EClass ALL_OBJECTS = eINSTANCE.getAllObjects(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl Default Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getDefaultInterpretation() + * @generated + */ + EClass DEFAULT_INTERPRETATION = eINSTANCE.getDefaultInterpretation(); + + /** + * The meta object literal for the 'Interpretation' containment reference feature. + * + * + * @generated + */ + EReference DEFAULT_INTERPRETATION__INTERPRETATION = eINSTANCE.getDefaultInterpretation_Interpretation(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.CDInterpretationImpl CD Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.CDInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getCDInterpretation() + * @generated + */ + EClass CD_INTERPRETATION = eINSTANCE.getCDInterpretation(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl Class Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getClassInterpretation() + * @generated + */ + EClass CLASS_INTERPRETATION = eINSTANCE.getClassInterpretation(); + + /** + * The meta object literal for the 'Abstract' attribute feature. + * + * + * @generated + */ + EAttribute CLASS_INTERPRETATION__ABSTRACT = eINSTANCE.getClassInterpretation_Abstract(); + + /** + * The meta object literal for the 'Symbol' containment reference feature. + * + * + * @generated + */ + EReference CLASS_INTERPRETATION__SYMBOL = eINSTANCE.getClassInterpretation_Symbol(); + + /** + * The meta object literal for the 'Supertypes' containment reference list feature. + * + * + * @generated + */ + EReference CLASS_INTERPRETATION__SUPERTYPES = eINSTANCE.getClassInterpretation_Supertypes(); + + /** + * The meta object literal for the 'Fielt' containment reference list feature. + * + * + * @generated + */ + EReference CLASS_INTERPRETATION__FIELT = eINSTANCE.getClassInterpretation_Fielt(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl Enum Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getEnumInterpretation() + * @generated + */ + EClass ENUM_INTERPRETATION = eINSTANCE.getEnumInterpretation(); + + /** + * The meta object literal for the 'Symbol' containment reference feature. + * + * + * @generated + */ + EReference ENUM_INTERPRETATION__SYMBOL = eINSTANCE.getEnumInterpretation_Symbol(); + + /** + * The meta object literal for the 'Objects' containment reference list feature. + * + * + * @generated + */ + EReference ENUM_INTERPRETATION__OBJECTS = eINSTANCE.getEnumInterpretation_Objects(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl Field Relation Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getFieldRelationInterpretation() + * @generated + */ + EClass FIELD_RELATION_INTERPRETATION = eINSTANCE.getFieldRelationInterpretation(); + + /** + * The meta object literal for the 'Containment' attribute feature. + * + * + * @generated + */ + EAttribute FIELD_RELATION_INTERPRETATION__CONTAINMENT = eINSTANCE.getFieldRelationInterpretation_Containment(); + + /** + * The meta object literal for the 'Symbol' containment reference feature. + * + * + * @generated + */ + EReference FIELD_RELATION_INTERPRETATION__SYMBOL = eINSTANCE.getFieldRelationInterpretation_Symbol(); + + /** + * The meta object literal for the 'Multiplicity' containment reference feature. + * + * + * @generated + */ + EReference FIELD_RELATION_INTERPRETATION__MULTIPLICITY = eINSTANCE.getFieldRelationInterpretation_Multiplicity(); + + /** + * The meta object literal for the 'Target' containment reference feature. + * + * + * @generated + */ + EReference FIELD_RELATION_INTERPRETATION__TARGET = eINSTANCE.getFieldRelationInterpretation_Target(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl Global Relation Interpretation}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getGlobalRelationInterpretation() + * @generated + */ + EClass GLOBAL_RELATION_INTERPRETATION = eINSTANCE.getGlobalRelationInterpretation(); + + /** + * The meta object literal for the 'Containment' attribute feature. + * + * + * @generated + */ + EAttribute GLOBAL_RELATION_INTERPRETATION__CONTAINMENT = eINSTANCE.getGlobalRelationInterpretation_Containment(); + + /** + * The meta object literal for the 'Symbol' containment reference feature. + * + * + * @generated + */ + EReference GLOBAL_RELATION_INTERPRETATION__SYMBOL = eINSTANCE.getGlobalRelationInterpretation_Symbol(); + + /** + * The meta object literal for the 'Source Multiplicity' containment reference feature. + * + * + * @generated + */ + EReference GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY = eINSTANCE.getGlobalRelationInterpretation_SourceMultiplicity(); + + /** + * The meta object literal for the 'Source' containment reference feature. + * + * + * @generated + */ + EReference GLOBAL_RELATION_INTERPRETATION__SOURCE = eINSTANCE.getGlobalRelationInterpretation_Source(); + + /** + * The meta object literal for the 'Target Multiplicity' containment reference feature. + * + * + * @generated + */ + EReference GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY = eINSTANCE.getGlobalRelationInterpretation_TargetMultiplicity(); + + /** + * The meta object literal for the 'Target' containment reference feature. + * + * + * @generated + */ + EReference GLOBAL_RELATION_INTERPRETATION__TARGET = eINSTANCE.getGlobalRelationInterpretation_Target(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl Multiplicity Definition}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getMultiplicityDefinition() + * @generated + */ + EClass MULTIPLICITY_DEFINITION = eINSTANCE.getMultiplicityDefinition(); + + /** + * The meta object literal for the 'Lower' attribute feature. + * + * + * @generated + */ + EAttribute MULTIPLICITY_DEFINITION__LOWER = eINSTANCE.getMultiplicityDefinition_Lower(); + + /** + * The meta object literal for the 'Upper' attribute feature. + * + * + * @generated + */ + EAttribute MULTIPLICITY_DEFINITION__UPPER = eINSTANCE.getMultiplicityDefinition_Upper(); + + /** + * The meta object literal for the 'Unlimited Upper' attribute feature. + * + * + * @generated + */ + EAttribute MULTIPLICITY_DEFINITION__UNLIMITED_UPPER = eINSTANCE.getMultiplicityDefinition_UnlimitedUpper(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanTrueImpl Boolean True}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanTrueImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanTrue() + * @generated + */ + EClass BOOLEAN_TRUE = eINSTANCE.getBooleanTrue(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanFalseImpl Boolean False}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanFalseImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getBooleanFalse() + * @generated + */ + EClass BOOLEAN_FALSE = eINSTANCE.getBooleanFalse(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.TrueImpl True}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.TrueImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getTrue() + * @generated + */ + EClass TRUE = eINSTANCE.getTrue(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.FalseImpl False}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.FalseImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getFalse() + * @generated + */ + EClass FALSE = eINSTANCE.getFalse(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnknownImpl Unknown}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.UnknownImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getUnknown() + * @generated + */ + EClass UNKNOWN = eINSTANCE.getUnknown(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorImpl Error}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getError() + * @generated + */ + EClass ERROR = eINSTANCE.getError(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.PositiveImpl Positive}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.PositiveImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getPositive() + * @generated + */ + EClass POSITIVE = eINSTANCE.getPositive(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.NegativeImpl Negative}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.NegativeImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getNegative() + * @generated + */ + EClass NEGATIVE = eINSTANCE.getNegative(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.ReflexiveClosureImpl Reflexive Closure}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.ReflexiveClosureImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getReflexiveClosure() + * @generated + */ + EClass REFLEXIVE_CLOSURE = eINSTANCE.getReflexiveClosure(); + + /** + * The meta object literal for the '{@link org.eclipse.viatra.solver.language.solverLanguage.impl.IrreflexiveClosureImpl Irreflexive Closure}' class. + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.IrreflexiveClosureImpl + * @see org.eclipse.viatra.solver.language.solverLanguage.impl.SolverLanguagePackageImpl#getIrreflexiveClosure() + * @generated + */ + EClass IRREFLEXIVE_CLOSURE = eINSTANCE.getIrreflexiveClosure(); + + } + +} //SolverLanguagePackage diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Statement.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Statement.java new file mode 100644 index 00000000..f3da8f9c --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Statement.java @@ -0,0 +1,20 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Statement'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStatement() + * @model + * @generated + */ +public interface Statement extends EObject +{ +} // Statement diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringObject.java new file mode 100644 index 00000000..d1d3ee6d --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringObject.java @@ -0,0 +1,47 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'String Object'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.StringObject#getValue Value}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStringObject() + * @model + * @generated + */ +public interface StringObject extends DataObject +{ + /** + * Returns the value of the 'Value' attribute. + * + * + * @return the value of the 'Value' attribute. + * @see #setValue(String) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStringObject_Value() + * @model + * @generated + */ + String getValue(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject#getValue Value}' attribute. + * + * + * @param value the new value of the 'Value' attribute. + * @see #getValue() + * @generated + */ + void setValue(String value); + +} // StringObject diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringSymbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringSymbol.java new file mode 100644 index 00000000..f3d6d8ee --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/StringSymbol.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'String Symbol'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getStringSymbol() + * @model + * @generated + */ +public interface StringSymbol extends DataSymbol +{ +} // StringSymbol diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Symbol.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Symbol.java new file mode 100644 index 00000000..dcf2a01a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Symbol.java @@ -0,0 +1,20 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Symbol'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getSymbol() + * @model + * @generated + */ +public interface Symbol extends EObject +{ +} // Symbol diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/True.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/True.java new file mode 100644 index 00000000..d125d86a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/True.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'True'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getTrue() + * @model + * @generated + */ +public interface True extends TruthValue +{ +} // True diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TruthValue.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TruthValue.java new file mode 100644 index 00000000..48e2b8e8 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/TruthValue.java @@ -0,0 +1,20 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + +import org.eclipse.emf.ecore.EObject; + +/** + * + * A representation of the model object 'Truth Value'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getTruthValue() + * @model + * @generated + */ +public interface TruthValue extends EObject +{ +} // TruthValue diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Unknown.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Unknown.java new file mode 100644 index 00000000..496f433a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Unknown.java @@ -0,0 +1,19 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Unknown'. + * + * + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnknown() + * @model + * @generated + */ +public interface Unknown extends TruthValue +{ +} // Unknown diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedObject.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedObject.java new file mode 100644 index 00000000..152ee782 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/UnnamedObject.java @@ -0,0 +1,47 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Unnamed Object'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject#getName Name}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnnamedObject() + * @model + * @generated + */ +public interface UnnamedObject extends org.eclipse.viatra.solver.language.solverLanguage.Object +{ + /** + * Returns the value of the 'Name' attribute. + * + * + * @return the value of the 'Name' attribute. + * @see #setName(String) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getUnnamedObject_Name() + * @model + * @generated + */ + String getName(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject#getName Name}' attribute. + * + * + * @param value the new value of the 'Name' attribute. + * @see #getName() + * @generated + */ + void setName(String value); + +} // UnnamedObject diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Variable.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Variable.java new file mode 100644 index 00000000..2f915fa7 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/Variable.java @@ -0,0 +1,47 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage; + + +/** + * + * A representation of the model object 'Variable'. + * + * + *

+ * The following features are supported: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.Variable#getName Name}
    • + *
+ * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getVariable() + * @model + * @generated + */ +public interface Variable extends Literal +{ + /** + * Returns the value of the 'Name' attribute. + * + * + * @return the value of the 'Name' attribute. + * @see #setName(String) + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage#getVariable_Name() + * @model + * @generated + */ + String getName(); + + /** + * Sets the value of the '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable#getName Name}' attribute. + * + * + * @param value the new value of the 'Name' attribute. + * @see #getName() + * @generated + */ + void setName(String value); + +} // Variable diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllInstancesImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllInstancesImpl.java new file mode 100644 index 00000000..5da3bf30 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllInstancesImpl.java @@ -0,0 +1,196 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.AllInstances; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.Symbol; + +/** + * + * An implementation of the model object 'All Instances'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.AllInstancesImpl#getSymbol Symbol}
    • + *
+ * + * @generated + */ +public class AllInstancesImpl extends ComplexObjectImpl implements AllInstances +{ + /** + * The cached value of the '{@link #getSymbol() Symbol}' containment reference. + * + * + * @see #getSymbol() + * @generated + * @ordered + */ + protected Symbol symbol; + + /** + * + * + * @generated + */ + protected AllInstancesImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.ALL_INSTANCES; + } + + /** + * + * + * @generated + */ + @Override + public Symbol getSymbol() + { + return symbol; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetSymbol(Symbol newSymbol, NotificationChain msgs) + { + Symbol oldSymbol = symbol; + symbol = newSymbol; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ALL_INSTANCES__SYMBOL, oldSymbol, newSymbol); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setSymbol(Symbol newSymbol) + { + if (newSymbol != symbol) + { + NotificationChain msgs = null; + if (symbol != null) + msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ALL_INSTANCES__SYMBOL, null, msgs); + if (newSymbol != null) + msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ALL_INSTANCES__SYMBOL, null, msgs); + msgs = basicSetSymbol(newSymbol, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ALL_INSTANCES__SYMBOL, newSymbol, newSymbol)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.ALL_INSTANCES__SYMBOL: + return basicSetSymbol(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.ALL_INSTANCES__SYMBOL: + return getSymbol(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.ALL_INSTANCES__SYMBOL: + setSymbol((Symbol)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.ALL_INSTANCES__SYMBOL: + setSymbol((Symbol)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.ALL_INSTANCES__SYMBOL: + return symbol != null; + } + return super.eIsSet(featureID); + } + +} //AllInstancesImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllObjectsImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllObjectsImpl.java new file mode 100644 index 00000000..b1e9c3d0 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/AllObjectsImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.AllObjects; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'All Objects'. + * + * + * @generated + */ +public class AllObjectsImpl extends ComplexObjectImpl implements AllObjects +{ + /** + * + * + * @generated + */ + protected AllObjectsImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.ALL_OBJECTS; + } + +} //AllObjectsImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BasicInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BasicInterpretationImpl.java new file mode 100644 index 00000000..aef515f6 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BasicInterpretationImpl.java @@ -0,0 +1,318 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.emf.ecore.util.EObjectContainmentEList; +import org.eclipse.emf.ecore.util.InternalEList; + +import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.Symbol; +import org.eclipse.viatra.solver.language.solverLanguage.TruthValue; + +/** + * + * An implementation of the model object 'Basic Interpretation'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl#getSymbol Symbol}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl#getObjects Objects}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.BasicInterpretationImpl#getValue Value}
    • + *
+ * + * @generated + */ +public class BasicInterpretationImpl extends InterpretationImpl implements BasicInterpretation +{ + /** + * The cached value of the '{@link #getSymbol() Symbol}' containment reference. + * + * + * @see #getSymbol() + * @generated + * @ordered + */ + protected Symbol symbol; + + /** + * The cached value of the '{@link #getObjects() Objects}' containment reference list. + * + * + * @see #getObjects() + * @generated + * @ordered + */ + protected EList objects; + + /** + * The cached value of the '{@link #getValue() Value}' containment reference. + * + * + * @see #getValue() + * @generated + * @ordered + */ + protected TruthValue value; + + /** + * + * + * @generated + */ + protected BasicInterpretationImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.BASIC_INTERPRETATION; + } + + /** + * + * + * @generated + */ + @Override + public Symbol getSymbol() + { + return symbol; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetSymbol(Symbol newSymbol, NotificationChain msgs) + { + Symbol oldSymbol = symbol; + symbol = newSymbol; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL, oldSymbol, newSymbol); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setSymbol(Symbol newSymbol) + { + if (newSymbol != symbol) + { + NotificationChain msgs = null; + if (symbol != null) + msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL, null, msgs); + if (newSymbol != null) + msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL, null, msgs); + msgs = basicSetSymbol(newSymbol, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL, newSymbol, newSymbol)); + } + + /** + * + * + * @generated + */ + @Override + public EList getObjects() + { + if (objects == null) + { + objects = new EObjectContainmentEList(ComplexObject.class, this, SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS); + } + return objects; + } + + /** + * + * + * @generated + */ + @Override + public TruthValue getValue() + { + return value; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetValue(TruthValue newValue, NotificationChain msgs) + { + TruthValue oldValue = value; + value = newValue; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BASIC_INTERPRETATION__VALUE, oldValue, newValue); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setValue(TruthValue newValue) + { + if (newValue != value) + { + NotificationChain msgs = null; + if (value != null) + msgs = ((InternalEObject)value).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BASIC_INTERPRETATION__VALUE, null, msgs); + if (newValue != null) + msgs = ((InternalEObject)newValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BASIC_INTERPRETATION__VALUE, null, msgs); + msgs = basicSetValue(newValue, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BASIC_INTERPRETATION__VALUE, newValue, newValue)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL: + return basicSetSymbol(null, msgs); + case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS: + return ((InternalEList)getObjects()).basicRemove(otherEnd, msgs); + case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE: + return basicSetValue(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL: + return getSymbol(); + case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS: + return getObjects(); + case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE: + return getValue(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL: + setSymbol((Symbol)newValue); + return; + case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS: + getObjects().clear(); + getObjects().addAll((Collection)newValue); + return; + case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE: + setValue((TruthValue)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL: + setSymbol((Symbol)null); + return; + case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS: + getObjects().clear(); + return; + case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE: + setValue((TruthValue)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.BASIC_INTERPRETATION__SYMBOL: + return symbol != null; + case SolverLanguagePackage.BASIC_INTERPRETATION__OBJECTS: + return objects != null && !objects.isEmpty(); + case SolverLanguagePackage.BASIC_INTERPRETATION__VALUE: + return value != null; + } + return super.eIsSet(featureID); + } + +} //BasicInterpretationImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanFalseImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanFalseImpl.java new file mode 100644 index 00000000..ae78f540 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanFalseImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Boolean False'. + * + * + * @generated + */ +public class BooleanFalseImpl extends BooleanValueImpl implements BooleanFalse +{ + /** + * + * + * @generated + */ + protected BooleanFalseImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.BOOLEAN_FALSE; + } + +} //BooleanFalseImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanObjectImpl.java new file mode 100644 index 00000000..cb1a3ff4 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanObjectImpl.java @@ -0,0 +1,196 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject; +import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Boolean Object'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.BooleanObjectImpl#getValue Value}
    • + *
+ * + * @generated + */ +public class BooleanObjectImpl extends DataObjectImpl implements BooleanObject +{ + /** + * The cached value of the '{@link #getValue() Value}' containment reference. + * + * + * @see #getValue() + * @generated + * @ordered + */ + protected BooleanValue value; + + /** + * + * + * @generated + */ + protected BooleanObjectImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.BOOLEAN_OBJECT; + } + + /** + * + * + * @generated + */ + @Override + public BooleanValue getValue() + { + return value; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetValue(BooleanValue newValue, NotificationChain msgs) + { + BooleanValue oldValue = value; + value = newValue; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BOOLEAN_OBJECT__VALUE, oldValue, newValue); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setValue(BooleanValue newValue) + { + if (newValue != value) + { + NotificationChain msgs = null; + if (value != null) + msgs = ((InternalEObject)value).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BOOLEAN_OBJECT__VALUE, null, msgs); + if (newValue != null) + msgs = ((InternalEObject)newValue).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.BOOLEAN_OBJECT__VALUE, null, msgs); + msgs = basicSetValue(newValue, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.BOOLEAN_OBJECT__VALUE, newValue, newValue)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE: + return basicSetValue(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE: + return getValue(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE: + setValue((BooleanValue)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE: + setValue((BooleanValue)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.BOOLEAN_OBJECT__VALUE: + return value != null; + } + return super.eIsSet(featureID); + } + +} //BooleanObjectImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanSymbolImpl.java new file mode 100644 index 00000000..49258091 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanSymbolImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Boolean Symbol'. + * + * + * @generated + */ +public class BooleanSymbolImpl extends DataSymbolImpl implements BooleanSymbol +{ + /** + * + * + * @generated + */ + protected BooleanSymbolImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.BOOLEAN_SYMBOL; + } + +} //BooleanSymbolImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanTrueImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanTrueImpl.java new file mode 100644 index 00000000..4d110ee9 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanTrueImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Boolean True'. + * + * + * @generated + */ +public class BooleanTrueImpl extends BooleanValueImpl implements BooleanTrue +{ + /** + * + * + * @generated + */ + protected BooleanTrueImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.BOOLEAN_TRUE; + } + +} //BooleanTrueImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanValueImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanValueImpl.java new file mode 100644 index 00000000..b27ab959 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/BooleanValueImpl.java @@ -0,0 +1,43 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.BooleanValue; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Boolean Value'. + * + * + * @generated + */ +public class BooleanValueImpl extends MinimalEObjectImpl.Container implements BooleanValue +{ + /** + * + * + * @generated + */ + protected BooleanValueImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.BOOLEAN_VALUE; + } + +} //BooleanValueImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CDInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CDInterpretationImpl.java new file mode 100644 index 00000000..b23bbba5 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/CDInterpretationImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'CD Interpretation'. + * + * + * @generated + */ +public class CDInterpretationImpl extends InterpretationImpl implements CDInterpretation +{ + /** + * + * + * @generated + */ + protected CDInterpretationImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.CD_INTERPRETATION; + } + +} //CDInterpretationImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassInterpretationImpl.java new file mode 100644 index 00000000..effc5970 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClassInterpretationImpl.java @@ -0,0 +1,356 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.emf.ecore.util.EObjectContainmentEList; +import org.eclipse.emf.ecore.util.InternalEList; + +import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Class Interpretation'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl#isAbstract Abstract}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl#getSymbol Symbol}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl#getSupertypes Supertypes}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ClassInterpretationImpl#getFielt Fielt}
    • + *
+ * + * @generated + */ +public class ClassInterpretationImpl extends CDInterpretationImpl implements ClassInterpretation +{ + /** + * The default value of the '{@link #isAbstract() Abstract}' attribute. + * + * + * @see #isAbstract() + * @generated + * @ordered + */ + protected static final boolean ABSTRACT_EDEFAULT = false; + + /** + * The cached value of the '{@link #isAbstract() Abstract}' attribute. + * + * + * @see #isAbstract() + * @generated + * @ordered + */ + protected boolean abstract_ = ABSTRACT_EDEFAULT; + + /** + * The cached value of the '{@link #getSymbol() Symbol}' containment reference. + * + * + * @see #getSymbol() + * @generated + * @ordered + */ + protected ModelSymbol symbol; + + /** + * The cached value of the '{@link #getSupertypes() Supertypes}' containment reference list. + * + * + * @see #getSupertypes() + * @generated + * @ordered + */ + protected EList supertypes; + + /** + * The cached value of the '{@link #getFielt() Fielt}' containment reference list. + * + * + * @see #getFielt() + * @generated + * @ordered + */ + protected EList fielt; + + /** + * + * + * @generated + */ + protected ClassInterpretationImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.CLASS_INTERPRETATION; + } + + /** + * + * + * @generated + */ + @Override + public boolean isAbstract() + { + return abstract_; + } + + /** + * + * + * @generated + */ + @Override + public void setAbstract(boolean newAbstract) + { + boolean oldAbstract = abstract_; + abstract_ = newAbstract; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT, oldAbstract, abstract_)); + } + + /** + * + * + * @generated + */ + @Override + public ModelSymbol getSymbol() + { + return symbol; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs) + { + ModelSymbol oldSymbol = symbol; + symbol = newSymbol; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL, oldSymbol, newSymbol); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setSymbol(ModelSymbol newSymbol) + { + if (newSymbol != symbol) + { + NotificationChain msgs = null; + if (symbol != null) + msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL, null, msgs); + if (newSymbol != null) + msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL, null, msgs); + msgs = basicSetSymbol(newSymbol, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL, newSymbol, newSymbol)); + } + + /** + * + * + * @generated + */ + @Override + public EList getSupertypes() + { + if (supertypes == null) + { + supertypes = new EObjectContainmentEList(ModelSymbol.class, this, SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES); + } + return supertypes; + } + + /** + * + * + * @generated + */ + @Override + public EList getFielt() + { + if (fielt == null) + { + fielt = new EObjectContainmentEList(FieldRelationInterpretation.class, this, SolverLanguagePackage.CLASS_INTERPRETATION__FIELT); + } + return fielt; + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL: + return basicSetSymbol(null, msgs); + case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES: + return ((InternalEList)getSupertypes()).basicRemove(otherEnd, msgs); + case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT: + return ((InternalEList)getFielt()).basicRemove(otherEnd, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT: + return isAbstract(); + case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL: + return getSymbol(); + case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES: + return getSupertypes(); + case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT: + return getFielt(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT: + setAbstract((Boolean)newValue); + return; + case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL: + setSymbol((ModelSymbol)newValue); + return; + case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES: + getSupertypes().clear(); + getSupertypes().addAll((Collection)newValue); + return; + case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT: + getFielt().clear(); + getFielt().addAll((Collection)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT: + setAbstract(ABSTRACT_EDEFAULT); + return; + case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL: + setSymbol((ModelSymbol)null); + return; + case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES: + getSupertypes().clear(); + return; + case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT: + getFielt().clear(); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.CLASS_INTERPRETATION__ABSTRACT: + return abstract_ != ABSTRACT_EDEFAULT; + case SolverLanguagePackage.CLASS_INTERPRETATION__SYMBOL: + return symbol != null; + case SolverLanguagePackage.CLASS_INTERPRETATION__SUPERTYPES: + return supertypes != null && !supertypes.isEmpty(); + case SolverLanguagePackage.CLASS_INTERPRETATION__FIELT: + return fielt != null && !fielt.isEmpty(); + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (abstract: "); + result.append(abstract_); + result.append(')'); + return result.toString(); + } + +} //ClassInterpretationImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClosureTypeImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClosureTypeImpl.java new file mode 100644 index 00000000..98136f79 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ClosureTypeImpl.java @@ -0,0 +1,43 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.ClosureType; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Closure Type'. + * + * + * @generated + */ +public class ClosureTypeImpl extends MinimalEObjectImpl.Container implements ClosureType +{ + /** + * + * + * @generated + */ + protected ClosureTypeImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.CLOSURE_TYPE; + } + +} //ClosureTypeImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComplexObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComplexObjectImpl.java new file mode 100644 index 00000000..09ad8a6d --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ComplexObjectImpl.java @@ -0,0 +1,43 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.ComplexObject; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Complex Object'. + * + * + * @generated + */ +public class ComplexObjectImpl extends MinimalEObjectImpl.Container implements ComplexObject +{ + /** + * + * + * @generated + */ + protected ComplexObjectImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.COMPLEX_OBJECT; + } + +} //ComplexObjectImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConstraintImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConstraintImpl.java new file mode 100644 index 00000000..2f990fee --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ConstraintImpl.java @@ -0,0 +1,393 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.emf.ecore.util.EObjectContainmentEList; +import org.eclipse.emf.ecore.util.InternalEList; + +import org.eclipse.viatra.solver.language.solverLanguage.ClosureType; +import org.eclipse.viatra.solver.language.solverLanguage.Constraint; +import org.eclipse.viatra.solver.language.solverLanguage.Literal; +import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.Polarity; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Constraint'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl#getPolarity Polarity}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl#getSymbol Symbol}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl#getParams Params}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ConstraintImpl#getClosureType Closure Type}
    • + *
+ * + * @generated + */ +public class ConstraintImpl extends MinimalEObjectImpl.Container implements Constraint +{ + /** + * The cached value of the '{@link #getPolarity() Polarity}' containment reference. + * + * + * @see #getPolarity() + * @generated + * @ordered + */ + protected Polarity polarity; + + /** + * The cached value of the '{@link #getSymbol() Symbol}' containment reference. + * + * + * @see #getSymbol() + * @generated + * @ordered + */ + protected ModelSymbol symbol; + + /** + * The cached value of the '{@link #getParams() Params}' containment reference list. + * + * + * @see #getParams() + * @generated + * @ordered + */ + protected EList params; + + /** + * The cached value of the '{@link #getClosureType() Closure Type}' containment reference. + * + * + * @see #getClosureType() + * @generated + * @ordered + */ + protected ClosureType closureType; + + /** + * + * + * @generated + */ + protected ConstraintImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.CONSTRAINT; + } + + /** + * + * + * @generated + */ + @Override + public Polarity getPolarity() + { + return polarity; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetPolarity(Polarity newPolarity, NotificationChain msgs) + { + Polarity oldPolarity = polarity; + polarity = newPolarity; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__POLARITY, oldPolarity, newPolarity); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setPolarity(Polarity newPolarity) + { + if (newPolarity != polarity) + { + NotificationChain msgs = null; + if (polarity != null) + msgs = ((InternalEObject)polarity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__POLARITY, null, msgs); + if (newPolarity != null) + msgs = ((InternalEObject)newPolarity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__POLARITY, null, msgs); + msgs = basicSetPolarity(newPolarity, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__POLARITY, newPolarity, newPolarity)); + } + + /** + * + * + * @generated + */ + @Override + public ModelSymbol getSymbol() + { + return symbol; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs) + { + ModelSymbol oldSymbol = symbol; + symbol = newSymbol; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__SYMBOL, oldSymbol, newSymbol); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setSymbol(ModelSymbol newSymbol) + { + if (newSymbol != symbol) + { + NotificationChain msgs = null; + if (symbol != null) + msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__SYMBOL, null, msgs); + if (newSymbol != null) + msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__SYMBOL, null, msgs); + msgs = basicSetSymbol(newSymbol, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__SYMBOL, newSymbol, newSymbol)); + } + + /** + * + * + * @generated + */ + @Override + public EList getParams() + { + if (params == null) + { + params = new EObjectContainmentEList(Literal.class, this, SolverLanguagePackage.CONSTRAINT__PARAMS); + } + return params; + } + + /** + * + * + * @generated + */ + @Override + public ClosureType getClosureType() + { + return closureType; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetClosureType(ClosureType newClosureType, NotificationChain msgs) + { + ClosureType oldClosureType = closureType; + closureType = newClosureType; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE, oldClosureType, newClosureType); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setClosureType(ClosureType newClosureType) + { + if (newClosureType != closureType) + { + NotificationChain msgs = null; + if (closureType != null) + msgs = ((InternalEObject)closureType).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE, null, msgs); + if (newClosureType != null) + msgs = ((InternalEObject)newClosureType).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE, null, msgs); + msgs = basicSetClosureType(newClosureType, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE, newClosureType, newClosureType)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.CONSTRAINT__POLARITY: + return basicSetPolarity(null, msgs); + case SolverLanguagePackage.CONSTRAINT__SYMBOL: + return basicSetSymbol(null, msgs); + case SolverLanguagePackage.CONSTRAINT__PARAMS: + return ((InternalEList)getParams()).basicRemove(otherEnd, msgs); + case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE: + return basicSetClosureType(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.CONSTRAINT__POLARITY: + return getPolarity(); + case SolverLanguagePackage.CONSTRAINT__SYMBOL: + return getSymbol(); + case SolverLanguagePackage.CONSTRAINT__PARAMS: + return getParams(); + case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE: + return getClosureType(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.CONSTRAINT__POLARITY: + setPolarity((Polarity)newValue); + return; + case SolverLanguagePackage.CONSTRAINT__SYMBOL: + setSymbol((ModelSymbol)newValue); + return; + case SolverLanguagePackage.CONSTRAINT__PARAMS: + getParams().clear(); + getParams().addAll((Collection)newValue); + return; + case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE: + setClosureType((ClosureType)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.CONSTRAINT__POLARITY: + setPolarity((Polarity)null); + return; + case SolverLanguagePackage.CONSTRAINT__SYMBOL: + setSymbol((ModelSymbol)null); + return; + case SolverLanguagePackage.CONSTRAINT__PARAMS: + getParams().clear(); + return; + case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE: + setClosureType((ClosureType)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.CONSTRAINT__POLARITY: + return polarity != null; + case SolverLanguagePackage.CONSTRAINT__SYMBOL: + return symbol != null; + case SolverLanguagePackage.CONSTRAINT__PARAMS: + return params != null && !params.isEmpty(); + case SolverLanguagePackage.CONSTRAINT__CLOSURE_TYPE: + return closureType != null; + } + return super.eIsSet(featureID); + } + +} //ConstraintImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataObjectImpl.java new file mode 100644 index 00000000..33bee29f --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataObjectImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.DataObject; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Data Object'. + * + * + * @generated + */ +public class DataObjectImpl extends ObjectImpl implements DataObject +{ + /** + * + * + * @generated + */ + protected DataObjectImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.DATA_OBJECT; + } + +} //DataObjectImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataSymbolImpl.java new file mode 100644 index 00000000..221b4783 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DataSymbolImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.DataSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Data Symbol'. + * + * + * @generated + */ +public class DataSymbolImpl extends SymbolImpl implements DataSymbol +{ + /** + * + * + * @generated + */ + protected DataSymbolImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.DATA_SYMBOL; + } + +} //DataSymbolImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DefaultInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DefaultInterpretationImpl.java new file mode 100644 index 00000000..eb2835a0 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/DefaultInterpretationImpl.java @@ -0,0 +1,196 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Default Interpretation'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.DefaultInterpretationImpl#getInterpretation Interpretation}
    • + *
+ * + * @generated + */ +public class DefaultInterpretationImpl extends InterpretationImpl implements DefaultInterpretation +{ + /** + * The cached value of the '{@link #getInterpretation() Interpretation}' containment reference. + * + * + * @see #getInterpretation() + * @generated + * @ordered + */ + protected BasicInterpretation interpretation; + + /** + * + * + * @generated + */ + protected DefaultInterpretationImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION; + } + + /** + * + * + * @generated + */ + @Override + public BasicInterpretation getInterpretation() + { + return interpretation; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetInterpretation(BasicInterpretation newInterpretation, NotificationChain msgs) + { + BasicInterpretation oldInterpretation = interpretation; + interpretation = newInterpretation; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION, oldInterpretation, newInterpretation); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setInterpretation(BasicInterpretation newInterpretation) + { + if (newInterpretation != interpretation) + { + NotificationChain msgs = null; + if (interpretation != null) + msgs = ((InternalEObject)interpretation).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION, null, msgs); + if (newInterpretation != null) + msgs = ((InternalEObject)newInterpretation).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION, null, msgs); + msgs = basicSetInterpretation(newInterpretation, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION, newInterpretation, newInterpretation)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION: + return basicSetInterpretation(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION: + return getInterpretation(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION: + setInterpretation((BasicInterpretation)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION: + setInterpretation((BasicInterpretation)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.DEFAULT_INTERPRETATION__INTERPRETATION: + return interpretation != null; + } + return super.eIsSet(featureID); + } + +} //DefaultInterpretationImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EnumInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EnumInterpretationImpl.java new file mode 100644 index 00000000..efa12ea6 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EnumInterpretationImpl.java @@ -0,0 +1,244 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.emf.ecore.util.EObjectContainmentEList; +import org.eclipse.emf.ecore.util.InternalEList; + +import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.NamedObject; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Enum Interpretation'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl#getSymbol Symbol}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.EnumInterpretationImpl#getObjects Objects}
    • + *
+ * + * @generated + */ +public class EnumInterpretationImpl extends CDInterpretationImpl implements EnumInterpretation +{ + /** + * The cached value of the '{@link #getSymbol() Symbol}' containment reference. + * + * + * @see #getSymbol() + * @generated + * @ordered + */ + protected ModelSymbol symbol; + + /** + * The cached value of the '{@link #getObjects() Objects}' containment reference list. + * + * + * @see #getObjects() + * @generated + * @ordered + */ + protected EList objects; + + /** + * + * + * @generated + */ + protected EnumInterpretationImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.ENUM_INTERPRETATION; + } + + /** + * + * + * @generated + */ + @Override + public ModelSymbol getSymbol() + { + return symbol; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs) + { + ModelSymbol oldSymbol = symbol; + symbol = newSymbol; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL, oldSymbol, newSymbol); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setSymbol(ModelSymbol newSymbol) + { + if (newSymbol != symbol) + { + NotificationChain msgs = null; + if (symbol != null) + msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL, null, msgs); + if (newSymbol != null) + msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL, null, msgs); + msgs = basicSetSymbol(newSymbol, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL, newSymbol, newSymbol)); + } + + /** + * + * + * @generated + */ + @Override + public EList getObjects() + { + if (objects == null) + { + objects = new EObjectContainmentEList(NamedObject.class, this, SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS); + } + return objects; + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL: + return basicSetSymbol(null, msgs); + case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS: + return ((InternalEList)getObjects()).basicRemove(otherEnd, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL: + return getSymbol(); + case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS: + return getObjects(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL: + setSymbol((ModelSymbol)newValue); + return; + case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS: + getObjects().clear(); + getObjects().addAll((Collection)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL: + setSymbol((ModelSymbol)null); + return; + case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS: + getObjects().clear(); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.ENUM_INTERPRETATION__SYMBOL: + return symbol != null; + case SolverLanguagePackage.ENUM_INTERPRETATION__OBJECTS: + return objects != null && !objects.isEmpty(); + } + return super.eIsSet(featureID); + } + +} //EnumInterpretationImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EqualsSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EqualsSymbolImpl.java new file mode 100644 index 00000000..33929f42 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/EqualsSymbolImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Equals Symbol'. + * + * + * @generated + */ +public class EqualsSymbolImpl extends PartialitySymbolImpl implements EqualsSymbol +{ + /** + * + * + * @generated + */ + protected EqualsSymbolImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.EQUALS_SYMBOL; + } + +} //EqualsSymbolImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorImpl.java new file mode 100644 index 00000000..e58094a7 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorImpl.java @@ -0,0 +1,40 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Error'. + * + * + * @generated + */ +public class ErrorImpl extends TruthValueImpl implements org.eclipse.viatra.solver.language.solverLanguage.Error +{ + /** + * + * + * @generated + */ + protected ErrorImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.ERROR; + } + +} //ErrorImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorPredicateImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorPredicateImpl.java new file mode 100644 index 00000000..f9b0e8c8 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ErrorPredicateImpl.java @@ -0,0 +1,179 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Error Predicate'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ErrorPredicateImpl#getName Name}
    • + *
+ * + * @generated + */ +public class ErrorPredicateImpl extends PredicateImpl implements ErrorPredicate +{ + /** + * The default value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected static final String NAME_EDEFAULT = null; + + /** + * The cached value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected String name = NAME_EDEFAULT; + + /** + * + * + * @generated + */ + protected ErrorPredicateImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.ERROR_PREDICATE; + } + + /** + * + * + * @generated + */ + @Override + public String getName() + { + return name; + } + + /** + * + * + * @generated + */ + @Override + public void setName(String newName) + { + String oldName = name; + name = newName; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.ERROR_PREDICATE__NAME, oldName, name)); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.ERROR_PREDICATE__NAME: + return getName(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.ERROR_PREDICATE__NAME: + setName((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.ERROR_PREDICATE__NAME: + setName(NAME_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.ERROR_PREDICATE__NAME: + return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (name: "); + result.append(name); + result.append(')'); + return result.toString(); + } + +} //ErrorPredicateImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExistSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExistSymbolImpl.java new file mode 100644 index 00000000..2fd59e41 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ExistSymbolImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Exist Symbol'. + * + * + * @generated + */ +public class ExistSymbolImpl extends PartialitySymbolImpl implements ExistSymbol +{ + /** + * + * + * @generated + */ + protected ExistSymbolImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.EXIST_SYMBOL; + } + +} //ExistSymbolImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FalseImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FalseImpl.java new file mode 100644 index 00000000..332f9af3 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FalseImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.False; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'False'. + * + * + * @generated + */ +public class FalseImpl extends TruthValueImpl implements False +{ + /** + * + * + * @generated + */ + protected FalseImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.FALSE; + } + +} //FalseImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FieldRelationInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FieldRelationInterpretationImpl.java new file mode 100644 index 00000000..ea9b80b2 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/FieldRelationInterpretationImpl.java @@ -0,0 +1,418 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.Symbol; + +/** + * + * An implementation of the model object 'Field Relation Interpretation'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl#isContainment Containment}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl#getSymbol Symbol}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl#getMultiplicity Multiplicity}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.FieldRelationInterpretationImpl#getTarget Target}
    • + *
+ * + * @generated + */ +public class FieldRelationInterpretationImpl extends MinimalEObjectImpl.Container implements FieldRelationInterpretation +{ + /** + * The default value of the '{@link #isContainment() Containment}' attribute. + * + * + * @see #isContainment() + * @generated + * @ordered + */ + protected static final boolean CONTAINMENT_EDEFAULT = false; + + /** + * The cached value of the '{@link #isContainment() Containment}' attribute. + * + * + * @see #isContainment() + * @generated + * @ordered + */ + protected boolean containment = CONTAINMENT_EDEFAULT; + + /** + * The cached value of the '{@link #getSymbol() Symbol}' containment reference. + * + * + * @see #getSymbol() + * @generated + * @ordered + */ + protected ModelSymbol symbol; + + /** + * The cached value of the '{@link #getMultiplicity() Multiplicity}' containment reference. + * + * + * @see #getMultiplicity() + * @generated + * @ordered + */ + protected MultiplicityDefinition multiplicity; + + /** + * The cached value of the '{@link #getTarget() Target}' containment reference. + * + * + * @see #getTarget() + * @generated + * @ordered + */ + protected Symbol target; + + /** + * + * + * @generated + */ + protected FieldRelationInterpretationImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.FIELD_RELATION_INTERPRETATION; + } + + /** + * + * + * @generated + */ + @Override + public boolean isContainment() + { + return containment; + } + + /** + * + * + * @generated + */ + @Override + public void setContainment(boolean newContainment) + { + boolean oldContainment = containment; + containment = newContainment; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT, oldContainment, containment)); + } + + /** + * + * + * @generated + */ + @Override + public ModelSymbol getSymbol() + { + return symbol; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs) + { + ModelSymbol oldSymbol = symbol; + symbol = newSymbol; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL, oldSymbol, newSymbol); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setSymbol(ModelSymbol newSymbol) + { + if (newSymbol != symbol) + { + NotificationChain msgs = null; + if (symbol != null) + msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL, null, msgs); + if (newSymbol != null) + msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL, null, msgs); + msgs = basicSetSymbol(newSymbol, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL, newSymbol, newSymbol)); + } + + /** + * + * + * @generated + */ + @Override + public MultiplicityDefinition getMultiplicity() + { + return multiplicity; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetMultiplicity(MultiplicityDefinition newMultiplicity, NotificationChain msgs) + { + MultiplicityDefinition oldMultiplicity = multiplicity; + multiplicity = newMultiplicity; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY, oldMultiplicity, newMultiplicity); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setMultiplicity(MultiplicityDefinition newMultiplicity) + { + if (newMultiplicity != multiplicity) + { + NotificationChain msgs = null; + if (multiplicity != null) + msgs = ((InternalEObject)multiplicity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY, null, msgs); + if (newMultiplicity != null) + msgs = ((InternalEObject)newMultiplicity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY, null, msgs); + msgs = basicSetMultiplicity(newMultiplicity, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY, newMultiplicity, newMultiplicity)); + } + + /** + * + * + * @generated + */ + @Override + public Symbol getTarget() + { + return target; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetTarget(Symbol newTarget, NotificationChain msgs) + { + Symbol oldTarget = target; + target = newTarget; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET, oldTarget, newTarget); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setTarget(Symbol newTarget) + { + if (newTarget != target) + { + NotificationChain msgs = null; + if (target != null) + msgs = ((InternalEObject)target).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET, null, msgs); + if (newTarget != null) + msgs = ((InternalEObject)newTarget).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET, null, msgs); + msgs = basicSetTarget(newTarget, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET, newTarget, newTarget)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL: + return basicSetSymbol(null, msgs); + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY: + return basicSetMultiplicity(null, msgs); + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET: + return basicSetTarget(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT: + return isContainment(); + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL: + return getSymbol(); + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY: + return getMultiplicity(); + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET: + return getTarget(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT: + setContainment((Boolean)newValue); + return; + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL: + setSymbol((ModelSymbol)newValue); + return; + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY: + setMultiplicity((MultiplicityDefinition)newValue); + return; + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET: + setTarget((Symbol)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT: + setContainment(CONTAINMENT_EDEFAULT); + return; + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL: + setSymbol((ModelSymbol)null); + return; + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY: + setMultiplicity((MultiplicityDefinition)null); + return; + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET: + setTarget((Symbol)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__CONTAINMENT: + return containment != CONTAINMENT_EDEFAULT; + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__SYMBOL: + return symbol != null; + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__MULTIPLICITY: + return multiplicity != null; + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION__TARGET: + return target != null; + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (containment: "); + result.append(containment); + result.append(')'); + return result.toString(); + } + +} //FieldRelationInterpretationImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/GlobalRelationInterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/GlobalRelationInterpretationImpl.java new file mode 100644 index 00000000..52f7a67d --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/GlobalRelationInterpretationImpl.java @@ -0,0 +1,563 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation; +import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.Symbol; + +/** + * + * An implementation of the model object 'Global Relation Interpretation'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#isContainment Containment}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getSymbol Symbol}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getSourceMultiplicity Source Multiplicity}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getSource Source}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getTargetMultiplicity Target Multiplicity}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.GlobalRelationInterpretationImpl#getTarget Target}
    • + *
+ * + * @generated + */ +public class GlobalRelationInterpretationImpl extends CDInterpretationImpl implements GlobalRelationInterpretation +{ + /** + * The default value of the '{@link #isContainment() Containment}' attribute. + * + * + * @see #isContainment() + * @generated + * @ordered + */ + protected static final boolean CONTAINMENT_EDEFAULT = false; + + /** + * The cached value of the '{@link #isContainment() Containment}' attribute. + * + * + * @see #isContainment() + * @generated + * @ordered + */ + protected boolean containment = CONTAINMENT_EDEFAULT; + + /** + * The cached value of the '{@link #getSymbol() Symbol}' containment reference. + * + * + * @see #getSymbol() + * @generated + * @ordered + */ + protected ModelSymbol symbol; + + /** + * The cached value of the '{@link #getSourceMultiplicity() Source Multiplicity}' containment reference. + * + * + * @see #getSourceMultiplicity() + * @generated + * @ordered + */ + protected MultiplicityDefinition sourceMultiplicity; + + /** + * The cached value of the '{@link #getSource() Source}' containment reference. + * + * + * @see #getSource() + * @generated + * @ordered + */ + protected Symbol source; + + /** + * The cached value of the '{@link #getTargetMultiplicity() Target Multiplicity}' containment reference. + * + * + * @see #getTargetMultiplicity() + * @generated + * @ordered + */ + protected MultiplicityDefinition targetMultiplicity; + + /** + * The cached value of the '{@link #getTarget() Target}' containment reference. + * + * + * @see #getTarget() + * @generated + * @ordered + */ + protected Symbol target; + + /** + * + * + * @generated + */ + protected GlobalRelationInterpretationImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.GLOBAL_RELATION_INTERPRETATION; + } + + /** + * + * + * @generated + */ + @Override + public boolean isContainment() + { + return containment; + } + + /** + * + * + * @generated + */ + @Override + public void setContainment(boolean newContainment) + { + boolean oldContainment = containment; + containment = newContainment; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT, oldContainment, containment)); + } + + /** + * + * + * @generated + */ + @Override + public ModelSymbol getSymbol() + { + return symbol; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs) + { + ModelSymbol oldSymbol = symbol; + symbol = newSymbol; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL, oldSymbol, newSymbol); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setSymbol(ModelSymbol newSymbol) + { + if (newSymbol != symbol) + { + NotificationChain msgs = null; + if (symbol != null) + msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL, null, msgs); + if (newSymbol != null) + msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL, null, msgs); + msgs = basicSetSymbol(newSymbol, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL, newSymbol, newSymbol)); + } + + /** + * + * + * @generated + */ + @Override + public MultiplicityDefinition getSourceMultiplicity() + { + return sourceMultiplicity; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetSourceMultiplicity(MultiplicityDefinition newSourceMultiplicity, NotificationChain msgs) + { + MultiplicityDefinition oldSourceMultiplicity = sourceMultiplicity; + sourceMultiplicity = newSourceMultiplicity; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY, oldSourceMultiplicity, newSourceMultiplicity); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setSourceMultiplicity(MultiplicityDefinition newSourceMultiplicity) + { + if (newSourceMultiplicity != sourceMultiplicity) + { + NotificationChain msgs = null; + if (sourceMultiplicity != null) + msgs = ((InternalEObject)sourceMultiplicity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY, null, msgs); + if (newSourceMultiplicity != null) + msgs = ((InternalEObject)newSourceMultiplicity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY, null, msgs); + msgs = basicSetSourceMultiplicity(newSourceMultiplicity, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY, newSourceMultiplicity, newSourceMultiplicity)); + } + + /** + * + * + * @generated + */ + @Override + public Symbol getSource() + { + return source; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetSource(Symbol newSource, NotificationChain msgs) + { + Symbol oldSource = source; + source = newSource; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE, oldSource, newSource); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setSource(Symbol newSource) + { + if (newSource != source) + { + NotificationChain msgs = null; + if (source != null) + msgs = ((InternalEObject)source).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE, null, msgs); + if (newSource != null) + msgs = ((InternalEObject)newSource).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE, null, msgs); + msgs = basicSetSource(newSource, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE, newSource, newSource)); + } + + /** + * + * + * @generated + */ + @Override + public MultiplicityDefinition getTargetMultiplicity() + { + return targetMultiplicity; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetTargetMultiplicity(MultiplicityDefinition newTargetMultiplicity, NotificationChain msgs) + { + MultiplicityDefinition oldTargetMultiplicity = targetMultiplicity; + targetMultiplicity = newTargetMultiplicity; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY, oldTargetMultiplicity, newTargetMultiplicity); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setTargetMultiplicity(MultiplicityDefinition newTargetMultiplicity) + { + if (newTargetMultiplicity != targetMultiplicity) + { + NotificationChain msgs = null; + if (targetMultiplicity != null) + msgs = ((InternalEObject)targetMultiplicity).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY, null, msgs); + if (newTargetMultiplicity != null) + msgs = ((InternalEObject)newTargetMultiplicity).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY, null, msgs); + msgs = basicSetTargetMultiplicity(newTargetMultiplicity, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY, newTargetMultiplicity, newTargetMultiplicity)); + } + + /** + * + * + * @generated + */ + @Override + public Symbol getTarget() + { + return target; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetTarget(Symbol newTarget, NotificationChain msgs) + { + Symbol oldTarget = target; + target = newTarget; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET, oldTarget, newTarget); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setTarget(Symbol newTarget) + { + if (newTarget != target) + { + NotificationChain msgs = null; + if (target != null) + msgs = ((InternalEObject)target).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET, null, msgs); + if (newTarget != null) + msgs = ((InternalEObject)newTarget).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET, null, msgs); + msgs = basicSetTarget(newTarget, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET, newTarget, newTarget)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL: + return basicSetSymbol(null, msgs); + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY: + return basicSetSourceMultiplicity(null, msgs); + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE: + return basicSetSource(null, msgs); + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY: + return basicSetTargetMultiplicity(null, msgs); + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET: + return basicSetTarget(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT: + return isContainment(); + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL: + return getSymbol(); + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY: + return getSourceMultiplicity(); + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE: + return getSource(); + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY: + return getTargetMultiplicity(); + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET: + return getTarget(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT: + setContainment((Boolean)newValue); + return; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL: + setSymbol((ModelSymbol)newValue); + return; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY: + setSourceMultiplicity((MultiplicityDefinition)newValue); + return; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE: + setSource((Symbol)newValue); + return; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY: + setTargetMultiplicity((MultiplicityDefinition)newValue); + return; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET: + setTarget((Symbol)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT: + setContainment(CONTAINMENT_EDEFAULT); + return; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL: + setSymbol((ModelSymbol)null); + return; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY: + setSourceMultiplicity((MultiplicityDefinition)null); + return; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE: + setSource((Symbol)null); + return; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY: + setTargetMultiplicity((MultiplicityDefinition)null); + return; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET: + setTarget((Symbol)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__CONTAINMENT: + return containment != CONTAINMENT_EDEFAULT; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SYMBOL: + return symbol != null; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE_MULTIPLICITY: + return sourceMultiplicity != null; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__SOURCE: + return source != null; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET_MULTIPLICITY: + return targetMultiplicity != null; + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION__TARGET: + return target != null; + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (containment: "); + result.append(containment); + result.append(')'); + return result.toString(); + } + +} //GlobalRelationInterpretationImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntObjectImpl.java new file mode 100644 index 00000000..fa844b68 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntObjectImpl.java @@ -0,0 +1,179 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.IntObject; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Int Object'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.IntObjectImpl#getValue Value}
    • + *
+ * + * @generated + */ +public class IntObjectImpl extends DataObjectImpl implements IntObject +{ + /** + * The default value of the '{@link #getValue() Value}' attribute. + * + * + * @see #getValue() + * @generated + * @ordered + */ + protected static final int VALUE_EDEFAULT = 0; + + /** + * The cached value of the '{@link #getValue() Value}' attribute. + * + * + * @see #getValue() + * @generated + * @ordered + */ + protected int value = VALUE_EDEFAULT; + + /** + * + * + * @generated + */ + protected IntObjectImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.INT_OBJECT; + } + + /** + * + * + * @generated + */ + @Override + public int getValue() + { + return value; + } + + /** + * + * + * @generated + */ + @Override + public void setValue(int newValue) + { + int oldValue = value; + value = newValue; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.INT_OBJECT__VALUE, oldValue, value)); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.INT_OBJECT__VALUE: + return getValue(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.INT_OBJECT__VALUE: + setValue((Integer)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.INT_OBJECT__VALUE: + setValue(VALUE_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.INT_OBJECT__VALUE: + return value != VALUE_EDEFAULT; + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (value: "); + result.append(value); + result.append(')'); + return result.toString(); + } + +} //IntObjectImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntegerSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntegerSymbolImpl.java new file mode 100644 index 00000000..bcd978fa --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IntegerSymbolImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Integer Symbol'. + * + * + * @generated + */ +public class IntegerSymbolImpl extends DataSymbolImpl implements IntegerSymbol +{ + /** + * + * + * @generated + */ + protected IntegerSymbolImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.INTEGER_SYMBOL; + } + +} //IntegerSymbolImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/InterpretationImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/InterpretationImpl.java new file mode 100644 index 00000000..fb41d77d --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/InterpretationImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.Interpretation; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Interpretation'. + * + * + * @generated + */ +public class InterpretationImpl extends StatementImpl implements Interpretation +{ + /** + * + * + * @generated + */ + protected InterpretationImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.INTERPRETATION; + } + +} //InterpretationImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IrreflexiveClosureImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IrreflexiveClosureImpl.java new file mode 100644 index 00000000..07ad66f9 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/IrreflexiveClosureImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Irreflexive Closure'. + * + * + * @generated + */ +public class IrreflexiveClosureImpl extends ClosureTypeImpl implements IrreflexiveClosure +{ + /** + * + * + * @generated + */ + protected IrreflexiveClosureImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.IRREFLEXIVE_CLOSURE; + } + +} //IrreflexiveClosureImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LiteralImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LiteralImpl.java new file mode 100644 index 00000000..518aa2b7 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/LiteralImpl.java @@ -0,0 +1,43 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.Literal; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Literal'. + * + * + * @generated + */ +public class LiteralImpl extends MinimalEObjectImpl.Container implements Literal +{ + /** + * + * + * @generated + */ + protected LiteralImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.LITERAL; + } + +} //LiteralImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ModelSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ModelSymbolImpl.java new file mode 100644 index 00000000..bd195572 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ModelSymbolImpl.java @@ -0,0 +1,179 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Model Symbol'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ModelSymbolImpl#getName Name}
    • + *
+ * + * @generated + */ +public class ModelSymbolImpl extends SymbolImpl implements ModelSymbol +{ + /** + * The default value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected static final String NAME_EDEFAULT = null; + + /** + * The cached value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected String name = NAME_EDEFAULT; + + /** + * + * + * @generated + */ + protected ModelSymbolImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.MODEL_SYMBOL; + } + + /** + * + * + * @generated + */ + @Override + public String getName() + { + return name; + } + + /** + * + * + * @generated + */ + @Override + public void setName(String newName) + { + String oldName = name; + name = newName; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MODEL_SYMBOL__NAME, oldName, name)); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.MODEL_SYMBOL__NAME: + return getName(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.MODEL_SYMBOL__NAME: + setName((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.MODEL_SYMBOL__NAME: + setName(NAME_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.MODEL_SYMBOL__NAME: + return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (name: "); + result.append(name); + result.append(')'); + return result.toString(); + } + +} //ModelSymbolImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MultiplicityDefinitionImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MultiplicityDefinitionImpl.java new file mode 100644 index 00000000..a346568c --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/MultiplicityDefinitionImpl.java @@ -0,0 +1,296 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Multiplicity Definition'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl#getLower Lower}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl#getUpper Upper}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.MultiplicityDefinitionImpl#isUnlimitedUpper Unlimited Upper}
    • + *
+ * + * @generated + */ +public class MultiplicityDefinitionImpl extends MinimalEObjectImpl.Container implements MultiplicityDefinition +{ + /** + * The default value of the '{@link #getLower() Lower}' attribute. + * + * + * @see #getLower() + * @generated + * @ordered + */ + protected static final int LOWER_EDEFAULT = 0; + + /** + * The cached value of the '{@link #getLower() Lower}' attribute. + * + * + * @see #getLower() + * @generated + * @ordered + */ + protected int lower = LOWER_EDEFAULT; + + /** + * The default value of the '{@link #getUpper() Upper}' attribute. + * + * + * @see #getUpper() + * @generated + * @ordered + */ + protected static final int UPPER_EDEFAULT = 0; + + /** + * The cached value of the '{@link #getUpper() Upper}' attribute. + * + * + * @see #getUpper() + * @generated + * @ordered + */ + protected int upper = UPPER_EDEFAULT; + + /** + * The default value of the '{@link #isUnlimitedUpper() Unlimited Upper}' attribute. + * + * + * @see #isUnlimitedUpper() + * @generated + * @ordered + */ + protected static final boolean UNLIMITED_UPPER_EDEFAULT = false; + + /** + * The cached value of the '{@link #isUnlimitedUpper() Unlimited Upper}' attribute. + * + * + * @see #isUnlimitedUpper() + * @generated + * @ordered + */ + protected boolean unlimitedUpper = UNLIMITED_UPPER_EDEFAULT; + + /** + * + * + * @generated + */ + protected MultiplicityDefinitionImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.MULTIPLICITY_DEFINITION; + } + + /** + * + * + * @generated + */ + @Override + public int getLower() + { + return lower; + } + + /** + * + * + * @generated + */ + @Override + public void setLower(int newLower) + { + int oldLower = lower; + lower = newLower; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER, oldLower, lower)); + } + + /** + * + * + * @generated + */ + @Override + public int getUpper() + { + return upper; + } + + /** + * + * + * @generated + */ + @Override + public void setUpper(int newUpper) + { + int oldUpper = upper; + upper = newUpper; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER, oldUpper, upper)); + } + + /** + * + * + * @generated + */ + @Override + public boolean isUnlimitedUpper() + { + return unlimitedUpper; + } + + /** + * + * + * @generated + */ + @Override + public void setUnlimitedUpper(boolean newUnlimitedUpper) + { + boolean oldUnlimitedUpper = unlimitedUpper; + unlimitedUpper = newUnlimitedUpper; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER, oldUnlimitedUpper, unlimitedUpper)); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER: + return getLower(); + case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER: + return getUpper(); + case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER: + return isUnlimitedUpper(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER: + setLower((Integer)newValue); + return; + case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER: + setUpper((Integer)newValue); + return; + case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER: + setUnlimitedUpper((Boolean)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER: + setLower(LOWER_EDEFAULT); + return; + case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER: + setUpper(UPPER_EDEFAULT); + return; + case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER: + setUnlimitedUpper(UNLIMITED_UPPER_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.MULTIPLICITY_DEFINITION__LOWER: + return lower != LOWER_EDEFAULT; + case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UPPER: + return upper != UPPER_EDEFAULT; + case SolverLanguagePackage.MULTIPLICITY_DEFINITION__UNLIMITED_UPPER: + return unlimitedUpper != UNLIMITED_UPPER_EDEFAULT; + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (lower: "); + result.append(lower); + result.append(", upper: "); + result.append(upper); + result.append(", unlimitedUpper: "); + result.append(unlimitedUpper); + result.append(')'); + return result.toString(); + } + +} //MultiplicityDefinitionImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NamedObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NamedObjectImpl.java new file mode 100644 index 00000000..9d907661 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NamedObjectImpl.java @@ -0,0 +1,179 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.NamedObject; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Named Object'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.NamedObjectImpl#getName Name}
    • + *
+ * + * @generated + */ +public class NamedObjectImpl extends ObjectImpl implements NamedObject +{ + /** + * The default value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected static final String NAME_EDEFAULT = null; + + /** + * The cached value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected String name = NAME_EDEFAULT; + + /** + * + * + * @generated + */ + protected NamedObjectImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.NAMED_OBJECT; + } + + /** + * + * + * @generated + */ + @Override + public String getName() + { + return name; + } + + /** + * + * + * @generated + */ + @Override + public void setName(String newName) + { + String oldName = name; + name = newName; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.NAMED_OBJECT__NAME, oldName, name)); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.NAMED_OBJECT__NAME: + return getName(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.NAMED_OBJECT__NAME: + setName((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.NAMED_OBJECT__NAME: + setName(NAME_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.NAMED_OBJECT__NAME: + return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (name: "); + result.append(name); + result.append(')'); + return result.toString(); + } + +} //NamedObjectImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NegativeImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NegativeImpl.java new file mode 100644 index 00000000..a30b228f --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/NegativeImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.Negative; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Negative'. + * + * + * @generated + */ +public class NegativeImpl extends PolarityImpl implements Negative +{ + /** + * + * + * @generated + */ + protected NegativeImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.NEGATIVE; + } + +} //NegativeImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectImpl.java new file mode 100644 index 00000000..d2f9b8d9 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ObjectImpl.java @@ -0,0 +1,40 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Object'. + * + * + * @generated + */ +public class ObjectImpl extends ComplexObjectImpl implements org.eclipse.viatra.solver.language.solverLanguage.Object +{ + /** + * + * + * @generated + */ + protected ObjectImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.OBJECT; + } + +} //ObjectImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ParameterImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ParameterImpl.java new file mode 100644 index 00000000..6281c4bc --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ParameterImpl.java @@ -0,0 +1,271 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.Parameter; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.Symbol; +import org.eclipse.viatra.solver.language.solverLanguage.Variable; + +/** + * + * An implementation of the model object 'Parameter'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl#getVariable Variable}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ParameterImpl#getType Type}
    • + *
+ * + * @generated + */ +public class ParameterImpl extends MinimalEObjectImpl.Container implements Parameter +{ + /** + * The cached value of the '{@link #getVariable() Variable}' containment reference. + * + * + * @see #getVariable() + * @generated + * @ordered + */ + protected Variable variable; + + /** + * The cached value of the '{@link #getType() Type}' containment reference. + * + * + * @see #getType() + * @generated + * @ordered + */ + protected Symbol type; + + /** + * + * + * @generated + */ + protected ParameterImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.PARAMETER; + } + + /** + * + * + * @generated + */ + @Override + public Variable getVariable() + { + return variable; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetVariable(Variable newVariable, NotificationChain msgs) + { + Variable oldVariable = variable; + variable = newVariable; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PARAMETER__VARIABLE, oldVariable, newVariable); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setVariable(Variable newVariable) + { + if (newVariable != variable) + { + NotificationChain msgs = null; + if (variable != null) + msgs = ((InternalEObject)variable).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PARAMETER__VARIABLE, null, msgs); + if (newVariable != null) + msgs = ((InternalEObject)newVariable).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PARAMETER__VARIABLE, null, msgs); + msgs = basicSetVariable(newVariable, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PARAMETER__VARIABLE, newVariable, newVariable)); + } + + /** + * + * + * @generated + */ + @Override + public Symbol getType() + { + return type; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetType(Symbol newType, NotificationChain msgs) + { + Symbol oldType = type; + type = newType; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PARAMETER__TYPE, oldType, newType); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setType(Symbol newType) + { + if (newType != type) + { + NotificationChain msgs = null; + if (type != null) + msgs = ((InternalEObject)type).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PARAMETER__TYPE, null, msgs); + if (newType != null) + msgs = ((InternalEObject)newType).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PARAMETER__TYPE, null, msgs); + msgs = basicSetType(newType, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PARAMETER__TYPE, newType, newType)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.PARAMETER__VARIABLE: + return basicSetVariable(null, msgs); + case SolverLanguagePackage.PARAMETER__TYPE: + return basicSetType(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.PARAMETER__VARIABLE: + return getVariable(); + case SolverLanguagePackage.PARAMETER__TYPE: + return getType(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.PARAMETER__VARIABLE: + setVariable((Variable)newValue); + return; + case SolverLanguagePackage.PARAMETER__TYPE: + setType((Symbol)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.PARAMETER__VARIABLE: + setVariable((Variable)null); + return; + case SolverLanguagePackage.PARAMETER__TYPE: + setType((Symbol)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.PARAMETER__VARIABLE: + return variable != null; + case SolverLanguagePackage.PARAMETER__TYPE: + return type != null; + } + return super.eIsSet(featureID); + } + +} //ParameterImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PartialitySymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PartialitySymbolImpl.java new file mode 100644 index 00000000..efc2c5f5 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PartialitySymbolImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Partiality Symbol'. + * + * + * @generated + */ +public class PartialitySymbolImpl extends SymbolImpl implements PartialitySymbol +{ + /** + * + * + * @generated + */ + protected PartialitySymbolImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.PARTIALITY_SYMBOL; + } + +} //PartialitySymbolImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PatternBodyImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PatternBodyImpl.java new file mode 100644 index 00000000..5cd03fbf --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PatternBodyImpl.java @@ -0,0 +1,169 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.emf.ecore.util.EObjectContainmentEList; +import org.eclipse.emf.ecore.util.InternalEList; + +import org.eclipse.viatra.solver.language.solverLanguage.Constraint; +import org.eclipse.viatra.solver.language.solverLanguage.PatternBody; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Pattern Body'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.PatternBodyImpl#getConstraints Constraints}
    • + *
+ * + * @generated + */ +public class PatternBodyImpl extends MinimalEObjectImpl.Container implements PatternBody +{ + /** + * The cached value of the '{@link #getConstraints() Constraints}' containment reference list. + * + * + * @see #getConstraints() + * @generated + * @ordered + */ + protected EList constraints; + + /** + * + * + * @generated + */ + protected PatternBodyImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.PATTERN_BODY; + } + + /** + * + * + * @generated + */ + @Override + public EList getConstraints() + { + if (constraints == null) + { + constraints = new EObjectContainmentEList(Constraint.class, this, SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS); + } + return constraints; + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS: + return ((InternalEList)getConstraints()).basicRemove(otherEnd, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS: + return getConstraints(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS: + getConstraints().clear(); + getConstraints().addAll((Collection)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS: + getConstraints().clear(); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.PATTERN_BODY__CONSTRAINTS: + return constraints != null && !constraints.isEmpty(); + } + return super.eIsSet(featureID); + } + +} //PatternBodyImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PolarityImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PolarityImpl.java new file mode 100644 index 00000000..7c2ae07d --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PolarityImpl.java @@ -0,0 +1,43 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.Polarity; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Polarity'. + * + * + * @generated + */ +public class PolarityImpl extends MinimalEObjectImpl.Container implements Polarity +{ + /** + * + * + * @generated + */ + protected PolarityImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.POLARITY; + } + +} //PolarityImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PositiveImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PositiveImpl.java new file mode 100644 index 00000000..130cfe7a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PositiveImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.Positive; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Positive'. + * + * + * @generated + */ +public class PositiveImpl extends PolarityImpl implements Positive +{ + /** + * + * + * @generated + */ + protected PositiveImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.POSITIVE; + } + +} //PositiveImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateImpl.java new file mode 100644 index 00000000..947d74bb --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateImpl.java @@ -0,0 +1,207 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.util.EObjectContainmentEList; +import org.eclipse.emf.ecore.util.InternalEList; + +import org.eclipse.viatra.solver.language.solverLanguage.Parameter; +import org.eclipse.viatra.solver.language.solverLanguage.PatternBody; +import org.eclipse.viatra.solver.language.solverLanguage.Predicate; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Predicate'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl#getParameters Parameters}
    • + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateImpl#getBodies Bodies}
    • + *
+ * + * @generated + */ +public class PredicateImpl extends StatementImpl implements Predicate +{ + /** + * The cached value of the '{@link #getParameters() Parameters}' containment reference list. + * + * + * @see #getParameters() + * @generated + * @ordered + */ + protected EList parameters; + + /** + * The cached value of the '{@link #getBodies() Bodies}' containment reference list. + * + * + * @see #getBodies() + * @generated + * @ordered + */ + protected EList bodies; + + /** + * + * + * @generated + */ + protected PredicateImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.PREDICATE; + } + + /** + * + * + * @generated + */ + @Override + public EList getParameters() + { + if (parameters == null) + { + parameters = new EObjectContainmentEList(Parameter.class, this, SolverLanguagePackage.PREDICATE__PARAMETERS); + } + return parameters; + } + + /** + * + * + * @generated + */ + @Override + public EList getBodies() + { + if (bodies == null) + { + bodies = new EObjectContainmentEList(PatternBody.class, this, SolverLanguagePackage.PREDICATE__BODIES); + } + return bodies; + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.PREDICATE__PARAMETERS: + return ((InternalEList)getParameters()).basicRemove(otherEnd, msgs); + case SolverLanguagePackage.PREDICATE__BODIES: + return ((InternalEList)getBodies()).basicRemove(otherEnd, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.PREDICATE__PARAMETERS: + return getParameters(); + case SolverLanguagePackage.PREDICATE__BODIES: + return getBodies(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.PREDICATE__PARAMETERS: + getParameters().clear(); + getParameters().addAll((Collection)newValue); + return; + case SolverLanguagePackage.PREDICATE__BODIES: + getBodies().clear(); + getBodies().addAll((Collection)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.PREDICATE__PARAMETERS: + getParameters().clear(); + return; + case SolverLanguagePackage.PREDICATE__BODIES: + getBodies().clear(); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.PREDICATE__PARAMETERS: + return parameters != null && !parameters.isEmpty(); + case SolverLanguagePackage.PREDICATE__BODIES: + return bodies != null && !bodies.isEmpty(); + } + return super.eIsSet(featureID); + } + +} //PredicateImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateSymbolImpl.java new file mode 100644 index 00000000..f49c6701 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/PredicateSymbolImpl.java @@ -0,0 +1,196 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Predicate Symbol'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.PredicateSymbolImpl#getSymbol Symbol}
    • + *
+ * + * @generated + */ +public class PredicateSymbolImpl extends PredicateImpl implements PredicateSymbol +{ + /** + * The cached value of the '{@link #getSymbol() Symbol}' containment reference. + * + * + * @see #getSymbol() + * @generated + * @ordered + */ + protected ModelSymbol symbol; + + /** + * + * + * @generated + */ + protected PredicateSymbolImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.PREDICATE_SYMBOL; + } + + /** + * + * + * @generated + */ + @Override + public ModelSymbol getSymbol() + { + return symbol; + } + + /** + * + * + * @generated + */ + public NotificationChain basicSetSymbol(ModelSymbol newSymbol, NotificationChain msgs) + { + ModelSymbol oldSymbol = symbol; + symbol = newSymbol; + if (eNotificationRequired()) + { + ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL, oldSymbol, newSymbol); + if (msgs == null) msgs = notification; else msgs.add(notification); + } + return msgs; + } + + /** + * + * + * @generated + */ + @Override + public void setSymbol(ModelSymbol newSymbol) + { + if (newSymbol != symbol) + { + NotificationChain msgs = null; + if (symbol != null) + msgs = ((InternalEObject)symbol).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL, null, msgs); + if (newSymbol != null) + msgs = ((InternalEObject)newSymbol).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL, null, msgs); + msgs = basicSetSymbol(newSymbol, msgs); + if (msgs != null) msgs.dispatch(); + } + else if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL, newSymbol, newSymbol)); + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL: + return basicSetSymbol(null, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL: + return getSymbol(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL: + setSymbol((ModelSymbol)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL: + setSymbol((ModelSymbol)null); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.PREDICATE_SYMBOL__SYMBOL: + return symbol != null; + } + return super.eIsSet(featureID); + } + +} //PredicateSymbolImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ProblemImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ProblemImpl.java new file mode 100644 index 00000000..e5cc3585 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ProblemImpl.java @@ -0,0 +1,169 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import java.util.Collection; + +import org.eclipse.emf.common.notify.NotificationChain; + +import org.eclipse.emf.common.util.EList; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.InternalEObject; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.emf.ecore.util.EObjectContainmentEList; +import org.eclipse.emf.ecore.util.InternalEList; + +import org.eclipse.viatra.solver.language.solverLanguage.Problem; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.Statement; + +/** + * + * An implementation of the model object 'Problem'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.ProblemImpl#getStatements Statements}
    • + *
+ * + * @generated + */ +public class ProblemImpl extends MinimalEObjectImpl.Container implements Problem +{ + /** + * The cached value of the '{@link #getStatements() Statements}' containment reference list. + * + * + * @see #getStatements() + * @generated + * @ordered + */ + protected EList statements; + + /** + * + * + * @generated + */ + protected ProblemImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.PROBLEM; + } + + /** + * + * + * @generated + */ + @Override + public EList getStatements() + { + if (statements == null) + { + statements = new EObjectContainmentEList(Statement.class, this, SolverLanguagePackage.PROBLEM__STATEMENTS); + } + return statements; + } + + /** + * + * + * @generated + */ + @Override + public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) + { + switch (featureID) + { + case SolverLanguagePackage.PROBLEM__STATEMENTS: + return ((InternalEList)getStatements()).basicRemove(otherEnd, msgs); + } + return super.eInverseRemove(otherEnd, featureID, msgs); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.PROBLEM__STATEMENTS: + return getStatements(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @SuppressWarnings("unchecked") + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.PROBLEM__STATEMENTS: + getStatements().clear(); + getStatements().addAll((Collection)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.PROBLEM__STATEMENTS: + getStatements().clear(); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.PROBLEM__STATEMENTS: + return statements != null && !statements.isEmpty(); + } + return super.eIsSet(featureID); + } + +} //ProblemImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealObjectImpl.java new file mode 100644 index 00000000..bc32a9a6 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealObjectImpl.java @@ -0,0 +1,181 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import java.math.BigDecimal; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.RealObject; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Real Object'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.RealObjectImpl#getValue Value}
    • + *
+ * + * @generated + */ +public class RealObjectImpl extends DataObjectImpl implements RealObject +{ + /** + * The default value of the '{@link #getValue() Value}' attribute. + * + * + * @see #getValue() + * @generated + * @ordered + */ + protected static final BigDecimal VALUE_EDEFAULT = null; + + /** + * The cached value of the '{@link #getValue() Value}' attribute. + * + * + * @see #getValue() + * @generated + * @ordered + */ + protected BigDecimal value = VALUE_EDEFAULT; + + /** + * + * + * @generated + */ + protected RealObjectImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.REAL_OBJECT; + } + + /** + * + * + * @generated + */ + @Override + public BigDecimal getValue() + { + return value; + } + + /** + * + * + * @generated + */ + @Override + public void setValue(BigDecimal newValue) + { + BigDecimal oldValue = value; + value = newValue; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.REAL_OBJECT__VALUE, oldValue, value)); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.REAL_OBJECT__VALUE: + return getValue(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.REAL_OBJECT__VALUE: + setValue((BigDecimal)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.REAL_OBJECT__VALUE: + setValue(VALUE_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.REAL_OBJECT__VALUE: + return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value); + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (value: "); + result.append(value); + result.append(')'); + return result.toString(); + } + +} //RealObjectImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealSymbolImpl.java new file mode 100644 index 00000000..8cfd0980 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/RealSymbolImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Real Symbol'. + * + * + * @generated + */ +public class RealSymbolImpl extends DataSymbolImpl implements RealSymbol +{ + /** + * + * + * @generated + */ + protected RealSymbolImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.REAL_SYMBOL; + } + +} //RealSymbolImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReflexiveClosureImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReflexiveClosureImpl.java new file mode 100644 index 00000000..111b48cb --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/ReflexiveClosureImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure; +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; + +/** + * + * An implementation of the model object 'Reflexive Closure'. + * + * + * @generated + */ +public class ReflexiveClosureImpl extends ClosureTypeImpl implements ReflexiveClosure +{ + /** + * + * + * @generated + */ + protected ReflexiveClosureImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.REFLEXIVE_CLOSURE; + } + +} //ReflexiveClosureImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java new file mode 100644 index 00000000..12ffc551 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java @@ -0,0 +1,851 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; + +import org.eclipse.emf.ecore.impl.EFactoryImpl; + +import org.eclipse.emf.ecore.plugin.EcorePlugin; + +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 Factory. + * + * @generated + */ +public class SolverLanguageFactoryImpl extends EFactoryImpl implements SolverLanguageFactory +{ + /** + * Creates the default factory implementation. + * + * + * @generated + */ + public static SolverLanguageFactory init() + { + try + { + SolverLanguageFactory theSolverLanguageFactory = (SolverLanguageFactory)EPackage.Registry.INSTANCE.getEFactory(SolverLanguagePackage.eNS_URI); + if (theSolverLanguageFactory != null) + { + return theSolverLanguageFactory; + } + } + catch (Exception exception) + { + EcorePlugin.INSTANCE.log(exception); + } + return new SolverLanguageFactoryImpl(); + } + + /** + * Creates an instance of the factory. + * + * + * @generated + */ + public SolverLanguageFactoryImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + public EObject create(EClass eClass) + { + switch (eClass.getClassifierID()) + { + case SolverLanguagePackage.PROBLEM: return createProblem(); + case SolverLanguagePackage.STATEMENT: return createStatement(); + case SolverLanguagePackage.BOOLEAN_VALUE: return createBooleanValue(); + case SolverLanguagePackage.TRUTH_VALUE: return createTruthValue(); + case SolverLanguagePackage.INTERPRETATION: return createInterpretation(); + case SolverLanguagePackage.BASIC_INTERPRETATION: return createBasicInterpretation(); + case SolverLanguagePackage.SYMBOL: return createSymbol(); + case SolverLanguagePackage.MODEL_SYMBOL: return createModelSymbol(); + case SolverLanguagePackage.PARTIALITY_SYMBOL: return createPartialitySymbol(); + case SolverLanguagePackage.EXIST_SYMBOL: return createExistSymbol(); + case SolverLanguagePackage.EQUALS_SYMBOL: return createEqualsSymbol(); + case SolverLanguagePackage.DATA_SYMBOL: return createDataSymbol(); + case SolverLanguagePackage.BOOLEAN_SYMBOL: return createBooleanSymbol(); + case SolverLanguagePackage.INTEGER_SYMBOL: return createIntegerSymbol(); + case SolverLanguagePackage.REAL_SYMBOL: return createRealSymbol(); + case SolverLanguagePackage.STRING_SYMBOL: return createStringSymbol(); + case SolverLanguagePackage.COMPLEX_OBJECT: return createComplexObject(); + case SolverLanguagePackage.OBJECT: return createObject(); + case SolverLanguagePackage.NAMED_OBJECT: return createNamedObject(); + case SolverLanguagePackage.UNNAMED_OBJECT: return createUnnamedObject(); + case SolverLanguagePackage.DATA_OBJECT: return createDataObject(); + case SolverLanguagePackage.BOOLEAN_OBJECT: return createBooleanObject(); + case SolverLanguagePackage.INT_OBJECT: return createIntObject(); + case SolverLanguagePackage.REAL_OBJECT: return createRealObject(); + case SolverLanguagePackage.STRING_OBJECT: return createStringObject(); + case SolverLanguagePackage.PREDICATE: return createPredicate(); + case SolverLanguagePackage.PREDICATE_SYMBOL: return createPredicateSymbol(); + case SolverLanguagePackage.ERROR_PREDICATE: return createErrorPredicate(); + case SolverLanguagePackage.PARAMETER: return createParameter(); + case SolverLanguagePackage.PATTERN_BODY: return createPatternBody(); + case SolverLanguagePackage.POLARITY: return createPolarity(); + case SolverLanguagePackage.CONSTRAINT: return createConstraint(); + case SolverLanguagePackage.CLOSURE_TYPE: return createClosureType(); + case SolverLanguagePackage.LITERAL: return createLiteral(); + case SolverLanguagePackage.VARIABLE: return createVariable(); + case SolverLanguagePackage.ALL_INSTANCES: return createAllInstances(); + case SolverLanguagePackage.ALL_OBJECTS: return createAllObjects(); + case SolverLanguagePackage.DEFAULT_INTERPRETATION: return createDefaultInterpretation(); + case SolverLanguagePackage.CD_INTERPRETATION: return createCDInterpretation(); + case SolverLanguagePackage.CLASS_INTERPRETATION: return createClassInterpretation(); + case SolverLanguagePackage.ENUM_INTERPRETATION: return createEnumInterpretation(); + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION: return createFieldRelationInterpretation(); + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION: return createGlobalRelationInterpretation(); + case SolverLanguagePackage.MULTIPLICITY_DEFINITION: return createMultiplicityDefinition(); + case SolverLanguagePackage.BOOLEAN_TRUE: return createBooleanTrue(); + case SolverLanguagePackage.BOOLEAN_FALSE: return createBooleanFalse(); + case SolverLanguagePackage.TRUE: return createTrue(); + case SolverLanguagePackage.FALSE: return createFalse(); + case SolverLanguagePackage.UNKNOWN: return createUnknown(); + case SolverLanguagePackage.ERROR: return createError(); + case SolverLanguagePackage.POSITIVE: return createPositive(); + case SolverLanguagePackage.NEGATIVE: return createNegative(); + case SolverLanguagePackage.REFLEXIVE_CLOSURE: return createReflexiveClosure(); + case SolverLanguagePackage.IRREFLEXIVE_CLOSURE: return createIrreflexiveClosure(); + default: + throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); + } + } + + /** + * + * + * @generated + */ + @Override + public Problem createProblem() + { + ProblemImpl problem = new ProblemImpl(); + return problem; + } + + /** + * + * + * @generated + */ + @Override + public Statement createStatement() + { + StatementImpl statement = new StatementImpl(); + return statement; + } + + /** + * + * + * @generated + */ + @Override + public BooleanValue createBooleanValue() + { + BooleanValueImpl booleanValue = new BooleanValueImpl(); + return booleanValue; + } + + /** + * + * + * @generated + */ + @Override + public TruthValue createTruthValue() + { + TruthValueImpl truthValue = new TruthValueImpl(); + return truthValue; + } + + /** + * + * + * @generated + */ + @Override + public Interpretation createInterpretation() + { + InterpretationImpl interpretation = new InterpretationImpl(); + return interpretation; + } + + /** + * + * + * @generated + */ + @Override + public BasicInterpretation createBasicInterpretation() + { + BasicInterpretationImpl basicInterpretation = new BasicInterpretationImpl(); + return basicInterpretation; + } + + /** + * + * + * @generated + */ + @Override + public Symbol createSymbol() + { + SymbolImpl symbol = new SymbolImpl(); + return symbol; + } + + /** + * + * + * @generated + */ + @Override + public ModelSymbol createModelSymbol() + { + ModelSymbolImpl modelSymbol = new ModelSymbolImpl(); + return modelSymbol; + } + + /** + * + * + * @generated + */ + @Override + public PartialitySymbol createPartialitySymbol() + { + PartialitySymbolImpl partialitySymbol = new PartialitySymbolImpl(); + return partialitySymbol; + } + + /** + * + * + * @generated + */ + @Override + public ExistSymbol createExistSymbol() + { + ExistSymbolImpl existSymbol = new ExistSymbolImpl(); + return existSymbol; + } + + /** + * + * + * @generated + */ + @Override + public EqualsSymbol createEqualsSymbol() + { + EqualsSymbolImpl equalsSymbol = new EqualsSymbolImpl(); + return equalsSymbol; + } + + /** + * + * + * @generated + */ + @Override + public DataSymbol createDataSymbol() + { + DataSymbolImpl dataSymbol = new DataSymbolImpl(); + return dataSymbol; + } + + /** + * + * + * @generated + */ + @Override + public BooleanSymbol createBooleanSymbol() + { + BooleanSymbolImpl booleanSymbol = new BooleanSymbolImpl(); + return booleanSymbol; + } + + /** + * + * + * @generated + */ + @Override + public IntegerSymbol createIntegerSymbol() + { + IntegerSymbolImpl integerSymbol = new IntegerSymbolImpl(); + return integerSymbol; + } + + /** + * + * + * @generated + */ + @Override + public RealSymbol createRealSymbol() + { + RealSymbolImpl realSymbol = new RealSymbolImpl(); + return realSymbol; + } + + /** + * + * + * @generated + */ + @Override + public StringSymbol createStringSymbol() + { + StringSymbolImpl stringSymbol = new StringSymbolImpl(); + return stringSymbol; + } + + /** + * + * + * @generated + */ + @Override + public ComplexObject createComplexObject() + { + ComplexObjectImpl complexObject = new ComplexObjectImpl(); + return complexObject; + } + + /** + * + * + * @generated + */ + @Override + public org.eclipse.viatra.solver.language.solverLanguage.Object createObject() + { + ObjectImpl object = new ObjectImpl(); + return object; + } + + /** + * + * + * @generated + */ + @Override + public NamedObject createNamedObject() + { + NamedObjectImpl namedObject = new NamedObjectImpl(); + return namedObject; + } + + /** + * + * + * @generated + */ + @Override + public UnnamedObject createUnnamedObject() + { + UnnamedObjectImpl unnamedObject = new UnnamedObjectImpl(); + return unnamedObject; + } + + /** + * + * + * @generated + */ + @Override + public DataObject createDataObject() + { + DataObjectImpl dataObject = new DataObjectImpl(); + return dataObject; + } + + /** + * + * + * @generated + */ + @Override + public BooleanObject createBooleanObject() + { + BooleanObjectImpl booleanObject = new BooleanObjectImpl(); + return booleanObject; + } + + /** + * + * + * @generated + */ + @Override + public IntObject createIntObject() + { + IntObjectImpl intObject = new IntObjectImpl(); + return intObject; + } + + /** + * + * + * @generated + */ + @Override + public RealObject createRealObject() + { + RealObjectImpl realObject = new RealObjectImpl(); + return realObject; + } + + /** + * + * + * @generated + */ + @Override + public StringObject createStringObject() + { + StringObjectImpl stringObject = new StringObjectImpl(); + return stringObject; + } + + /** + * + * + * @generated + */ + @Override + public Predicate createPredicate() + { + PredicateImpl predicate = new PredicateImpl(); + return predicate; + } + + /** + * + * + * @generated + */ + @Override + public PredicateSymbol createPredicateSymbol() + { + PredicateSymbolImpl predicateSymbol = new PredicateSymbolImpl(); + return predicateSymbol; + } + + /** + * + * + * @generated + */ + @Override + public ErrorPredicate createErrorPredicate() + { + ErrorPredicateImpl errorPredicate = new ErrorPredicateImpl(); + return errorPredicate; + } + + /** + * + * + * @generated + */ + @Override + public Parameter createParameter() + { + ParameterImpl parameter = new ParameterImpl(); + return parameter; + } + + /** + * + * + * @generated + */ + @Override + public PatternBody createPatternBody() + { + PatternBodyImpl patternBody = new PatternBodyImpl(); + return patternBody; + } + + /** + * + * + * @generated + */ + @Override + public Polarity createPolarity() + { + PolarityImpl polarity = new PolarityImpl(); + return polarity; + } + + /** + * + * + * @generated + */ + @Override + public Constraint createConstraint() + { + ConstraintImpl constraint = new ConstraintImpl(); + return constraint; + } + + /** + * + * + * @generated + */ + @Override + public ClosureType createClosureType() + { + ClosureTypeImpl closureType = new ClosureTypeImpl(); + return closureType; + } + + /** + * + * + * @generated + */ + @Override + public Literal createLiteral() + { + LiteralImpl literal = new LiteralImpl(); + return literal; + } + + /** + * + * + * @generated + */ + @Override + public Variable createVariable() + { + VariableImpl variable = new VariableImpl(); + return variable; + } + + /** + * + * + * @generated + */ + @Override + public AllInstances createAllInstances() + { + AllInstancesImpl allInstances = new AllInstancesImpl(); + return allInstances; + } + + /** + * + * + * @generated + */ + @Override + public AllObjects createAllObjects() + { + AllObjectsImpl allObjects = new AllObjectsImpl(); + return allObjects; + } + + /** + * + * + * @generated + */ + @Override + public DefaultInterpretation createDefaultInterpretation() + { + DefaultInterpretationImpl defaultInterpretation = new DefaultInterpretationImpl(); + return defaultInterpretation; + } + + /** + * + * + * @generated + */ + @Override + public CDInterpretation createCDInterpretation() + { + CDInterpretationImpl cdInterpretation = new CDInterpretationImpl(); + return cdInterpretation; + } + + /** + * + * + * @generated + */ + @Override + public ClassInterpretation createClassInterpretation() + { + ClassInterpretationImpl classInterpretation = new ClassInterpretationImpl(); + return classInterpretation; + } + + /** + * + * + * @generated + */ + @Override + public EnumInterpretation createEnumInterpretation() + { + EnumInterpretationImpl enumInterpretation = new EnumInterpretationImpl(); + return enumInterpretation; + } + + /** + * + * + * @generated + */ + @Override + public FieldRelationInterpretation createFieldRelationInterpretation() + { + FieldRelationInterpretationImpl fieldRelationInterpretation = new FieldRelationInterpretationImpl(); + return fieldRelationInterpretation; + } + + /** + * + * + * @generated + */ + @Override + public GlobalRelationInterpretation createGlobalRelationInterpretation() + { + GlobalRelationInterpretationImpl globalRelationInterpretation = new GlobalRelationInterpretationImpl(); + return globalRelationInterpretation; + } + + /** + * + * + * @generated + */ + @Override + public MultiplicityDefinition createMultiplicityDefinition() + { + MultiplicityDefinitionImpl multiplicityDefinition = new MultiplicityDefinitionImpl(); + return multiplicityDefinition; + } + + /** + * + * + * @generated + */ + @Override + public BooleanTrue createBooleanTrue() + { + BooleanTrueImpl booleanTrue = new BooleanTrueImpl(); + return booleanTrue; + } + + /** + * + * + * @generated + */ + @Override + public BooleanFalse createBooleanFalse() + { + BooleanFalseImpl booleanFalse = new BooleanFalseImpl(); + return booleanFalse; + } + + /** + * + * + * @generated + */ + @Override + public True createTrue() + { + TrueImpl true_ = new TrueImpl(); + return true_; + } + + /** + * + * + * @generated + */ + @Override + public False createFalse() + { + FalseImpl false_ = new FalseImpl(); + return false_; + } + + /** + * + * + * @generated + */ + @Override + public Unknown createUnknown() + { + UnknownImpl unknown = new UnknownImpl(); + return unknown; + } + + /** + * + * + * @generated + */ + @Override + public org.eclipse.viatra.solver.language.solverLanguage.Error createError() + { + ErrorImpl error = new ErrorImpl(); + return error; + } + + /** + * + * + * @generated + */ + @Override + public Positive createPositive() + { + PositiveImpl positive = new PositiveImpl(); + return positive; + } + + /** + * + * + * @generated + */ + @Override + public Negative createNegative() + { + NegativeImpl negative = new NegativeImpl(); + return negative; + } + + /** + * + * + * @generated + */ + @Override + public ReflexiveClosure createReflexiveClosure() + { + ReflexiveClosureImpl reflexiveClosure = new ReflexiveClosureImpl(); + return reflexiveClosure; + } + + /** + * + * + * @generated + */ + @Override + public IrreflexiveClosure createIrreflexiveClosure() + { + IrreflexiveClosureImpl irreflexiveClosure = new IrreflexiveClosureImpl(); + return irreflexiveClosure; + } + + /** + * + * + * @generated + */ + @Override + public SolverLanguagePackage getSolverLanguagePackage() + { + return (SolverLanguagePackage)getEPackage(); + } + + /** + * + * + * @deprecated + * @generated + */ + @Deprecated + public static SolverLanguagePackage getPackage() + { + return SolverLanguagePackage.eINSTANCE; + } + +} //SolverLanguageFactoryImpl 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 diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StatementImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StatementImpl.java new file mode 100644 index 00000000..6e660396 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StatementImpl.java @@ -0,0 +1,43 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.Statement; + +/** + * + * An implementation of the model object 'Statement'. + * + * + * @generated + */ +public class StatementImpl extends MinimalEObjectImpl.Container implements Statement +{ + /** + * + * + * @generated + */ + protected StatementImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.STATEMENT; + } + +} //StatementImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringObjectImpl.java new file mode 100644 index 00000000..7a7866a7 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringObjectImpl.java @@ -0,0 +1,179 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.StringObject; + +/** + * + * An implementation of the model object 'String Object'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.StringObjectImpl#getValue Value}
    • + *
+ * + * @generated + */ +public class StringObjectImpl extends DataObjectImpl implements StringObject +{ + /** + * The default value of the '{@link #getValue() Value}' attribute. + * + * + * @see #getValue() + * @generated + * @ordered + */ + protected static final String VALUE_EDEFAULT = null; + + /** + * The cached value of the '{@link #getValue() Value}' attribute. + * + * + * @see #getValue() + * @generated + * @ordered + */ + protected String value = VALUE_EDEFAULT; + + /** + * + * + * @generated + */ + protected StringObjectImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.STRING_OBJECT; + } + + /** + * + * + * @generated + */ + @Override + public String getValue() + { + return value; + } + + /** + * + * + * @generated + */ + @Override + public void setValue(String newValue) + { + String oldValue = value; + value = newValue; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.STRING_OBJECT__VALUE, oldValue, value)); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.STRING_OBJECT__VALUE: + return getValue(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.STRING_OBJECT__VALUE: + setValue((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.STRING_OBJECT__VALUE: + setValue(VALUE_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.STRING_OBJECT__VALUE: + return VALUE_EDEFAULT == null ? value != null : !VALUE_EDEFAULT.equals(value); + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (value: "); + result.append(value); + result.append(')'); + return result.toString(); + } + +} //StringObjectImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringSymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringSymbolImpl.java new file mode 100644 index 00000000..faf3f06a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/StringSymbolImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol; + +/** + * + * An implementation of the model object 'String Symbol'. + * + * + * @generated + */ +public class StringSymbolImpl extends DataSymbolImpl implements StringSymbol +{ + /** + * + * + * @generated + */ + protected StringSymbolImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.STRING_SYMBOL; + } + +} //StringSymbolImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SymbolImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SymbolImpl.java new file mode 100644 index 00000000..15d1294e --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SymbolImpl.java @@ -0,0 +1,43 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.Symbol; + +/** + * + * An implementation of the model object 'Symbol'. + * + * + * @generated + */ +public class SymbolImpl extends MinimalEObjectImpl.Container implements Symbol +{ + /** + * + * + * @generated + */ + protected SymbolImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.SYMBOL; + } + +} //SymbolImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TrueImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TrueImpl.java new file mode 100644 index 00000000..c0e04a9a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TrueImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.True; + +/** + * + * An implementation of the model object 'True'. + * + * + * @generated + */ +public class TrueImpl extends TruthValueImpl implements True +{ + /** + * + * + * @generated + */ + protected TrueImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.TRUE; + } + +} //TrueImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TruthValueImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TruthValueImpl.java new file mode 100644 index 00000000..f5b0fba6 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/TruthValueImpl.java @@ -0,0 +1,43 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.MinimalEObjectImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.TruthValue; + +/** + * + * An implementation of the model object 'Truth Value'. + * + * + * @generated + */ +public class TruthValueImpl extends MinimalEObjectImpl.Container implements TruthValue +{ + /** + * + * + * @generated + */ + protected TruthValueImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.TRUTH_VALUE; + } + +} //TruthValueImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnknownImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnknownImpl.java new file mode 100644 index 00000000..44195feb --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnknownImpl.java @@ -0,0 +1,41 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.Unknown; + +/** + * + * An implementation of the model object 'Unknown'. + * + * + * @generated + */ +public class UnknownImpl extends TruthValueImpl implements Unknown +{ + /** + * + * + * @generated + */ + protected UnknownImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.UNKNOWN; + } + +} //UnknownImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedObjectImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedObjectImpl.java new file mode 100644 index 00000000..39bec164 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/UnnamedObjectImpl.java @@ -0,0 +1,179 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject; + +/** + * + * An implementation of the model object 'Unnamed Object'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.UnnamedObjectImpl#getName Name}
    • + *
+ * + * @generated + */ +public class UnnamedObjectImpl extends ObjectImpl implements UnnamedObject +{ + /** + * The default value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected static final String NAME_EDEFAULT = null; + + /** + * The cached value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected String name = NAME_EDEFAULT; + + /** + * + * + * @generated + */ + protected UnnamedObjectImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.UNNAMED_OBJECT; + } + + /** + * + * + * @generated + */ + @Override + public String getName() + { + return name; + } + + /** + * + * + * @generated + */ + @Override + public void setName(String newName) + { + String oldName = name; + name = newName; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.UNNAMED_OBJECT__NAME, oldName, name)); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.UNNAMED_OBJECT__NAME: + return getName(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.UNNAMED_OBJECT__NAME: + setName((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.UNNAMED_OBJECT__NAME: + setName(NAME_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.UNNAMED_OBJECT__NAME: + return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (name: "); + result.append(name); + result.append(')'); + return result.toString(); + } + +} //UnnamedObjectImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/VariableImpl.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/VariableImpl.java new file mode 100644 index 00000000..9a254023 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/VariableImpl.java @@ -0,0 +1,179 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.common.notify.Notification; + +import org.eclipse.emf.ecore.EClass; + +import org.eclipse.emf.ecore.impl.ENotificationImpl; + +import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; +import org.eclipse.viatra.solver.language.solverLanguage.Variable; + +/** + * + * An implementation of the model object 'Variable'. + * + *

+ * The following features are implemented: + *

+ *
    + *
  • {@link org.eclipse.viatra.solver.language.solverLanguage.impl.VariableImpl#getName Name}
    • + *
+ * + * @generated + */ +public class VariableImpl extends LiteralImpl implements Variable +{ + /** + * The default value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected static final String NAME_EDEFAULT = null; + + /** + * The cached value of the '{@link #getName() Name}' attribute. + * + * + * @see #getName() + * @generated + * @ordered + */ + protected String name = NAME_EDEFAULT; + + /** + * + * + * @generated + */ + protected VariableImpl() + { + super(); + } + + /** + * + * + * @generated + */ + @Override + protected EClass eStaticClass() + { + return SolverLanguagePackage.Literals.VARIABLE; + } + + /** + * + * + * @generated + */ + @Override + public String getName() + { + return name; + } + + /** + * + * + * @generated + */ + @Override + public void setName(String newName) + { + String oldName = name; + name = newName; + if (eNotificationRequired()) + eNotify(new ENotificationImpl(this, Notification.SET, SolverLanguagePackage.VARIABLE__NAME, oldName, name)); + } + + /** + * + * + * @generated + */ + @Override + public Object eGet(int featureID, boolean resolve, boolean coreType) + { + switch (featureID) + { + case SolverLanguagePackage.VARIABLE__NAME: + return getName(); + } + return super.eGet(featureID, resolve, coreType); + } + + /** + * + * + * @generated + */ + @Override + public void eSet(int featureID, Object newValue) + { + switch (featureID) + { + case SolverLanguagePackage.VARIABLE__NAME: + setName((String)newValue); + return; + } + super.eSet(featureID, newValue); + } + + /** + * + * + * @generated + */ + @Override + public void eUnset(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.VARIABLE__NAME: + setName(NAME_EDEFAULT); + return; + } + super.eUnset(featureID); + } + + /** + * + * + * @generated + */ + @Override + public boolean eIsSet(int featureID) + { + switch (featureID) + { + case SolverLanguagePackage.VARIABLE__NAME: + return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name); + } + return super.eIsSet(featureID); + } + + /** + * + * + * @generated + */ + @Override + public String toString() + { + if (eIsProxy()) return super.toString(); + + StringBuilder result = new StringBuilder(super.toString()); + result.append(" (name: "); + result.append(name); + result.append(')'); + return result.toString(); + } + +} //VariableImpl diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java new file mode 100644 index 00000000..e76e359a --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageAdapterFactory.java @@ -0,0 +1,1245 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.util; + +import org.eclipse.emf.common.notify.Adapter; +import org.eclipse.emf.common.notify.Notifier; + +import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl; + +import org.eclipse.emf.ecore.EObject; + +import org.eclipse.viatra.solver.language.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.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; + +/** + * + * The Adapter Factory for the model. + * It provides an adapter createXXX method for each class of the model. + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage + * @generated + */ +public class SolverLanguageAdapterFactory extends AdapterFactoryImpl +{ + /** + * The cached model package. + * + * + * @generated + */ + protected static SolverLanguagePackage modelPackage; + + /** + * Creates an instance of the adapter factory. + * + * + * @generated + */ + public SolverLanguageAdapterFactory() + { + if (modelPackage == null) + { + modelPackage = SolverLanguagePackage.eINSTANCE; + } + } + + /** + * Returns whether this factory is applicable for the type of the object. + * + * This implementation returns true if the object is either the model's package or is an instance object of the model. + * + * @return whether this factory is applicable for the type of the object. + * @generated + */ + @Override + public boolean isFactoryForType(Object object) + { + if (object == modelPackage) + { + return true; + } + if (object instanceof EObject) + { + return ((EObject)object).eClass().getEPackage() == modelPackage; + } + return false; + } + + /** + * The switch that delegates to the createXXX methods. + * + * + * @generated + */ + protected SolverLanguageSwitch modelSwitch = + new SolverLanguageSwitch() + { + @Override + public Adapter caseProblem(Problem object) + { + return createProblemAdapter(); + } + @Override + public Adapter caseStatement(Statement object) + { + return createStatementAdapter(); + } + @Override + public Adapter caseBooleanValue(BooleanValue object) + { + return createBooleanValueAdapter(); + } + @Override + public Adapter caseTruthValue(TruthValue object) + { + return createTruthValueAdapter(); + } + @Override + public Adapter caseInterpretation(Interpretation object) + { + return createInterpretationAdapter(); + } + @Override + public Adapter caseBasicInterpretation(BasicInterpretation object) + { + return createBasicInterpretationAdapter(); + } + @Override + public Adapter caseSymbol(Symbol object) + { + return createSymbolAdapter(); + } + @Override + public Adapter caseModelSymbol(ModelSymbol object) + { + return createModelSymbolAdapter(); + } + @Override + public Adapter casePartialitySymbol(PartialitySymbol object) + { + return createPartialitySymbolAdapter(); + } + @Override + public Adapter caseExistSymbol(ExistSymbol object) + { + return createExistSymbolAdapter(); + } + @Override + public Adapter caseEqualsSymbol(EqualsSymbol object) + { + return createEqualsSymbolAdapter(); + } + @Override + public Adapter caseDataSymbol(DataSymbol object) + { + return createDataSymbolAdapter(); + } + @Override + public Adapter caseBooleanSymbol(BooleanSymbol object) + { + return createBooleanSymbolAdapter(); + } + @Override + public Adapter caseIntegerSymbol(IntegerSymbol object) + { + return createIntegerSymbolAdapter(); + } + @Override + public Adapter caseRealSymbol(RealSymbol object) + { + return createRealSymbolAdapter(); + } + @Override + public Adapter caseStringSymbol(StringSymbol object) + { + return createStringSymbolAdapter(); + } + @Override + public Adapter caseComplexObject(ComplexObject object) + { + return createComplexObjectAdapter(); + } + @Override + public Adapter caseObject(org.eclipse.viatra.solver.language.solverLanguage.Object object) + { + return createObjectAdapter(); + } + @Override + public Adapter caseNamedObject(NamedObject object) + { + return createNamedObjectAdapter(); + } + @Override + public Adapter caseUnnamedObject(UnnamedObject object) + { + return createUnnamedObjectAdapter(); + } + @Override + public Adapter caseDataObject(DataObject object) + { + return createDataObjectAdapter(); + } + @Override + public Adapter caseBooleanObject(BooleanObject object) + { + return createBooleanObjectAdapter(); + } + @Override + public Adapter caseIntObject(IntObject object) + { + return createIntObjectAdapter(); + } + @Override + public Adapter caseRealObject(RealObject object) + { + return createRealObjectAdapter(); + } + @Override + public Adapter caseStringObject(StringObject object) + { + return createStringObjectAdapter(); + } + @Override + public Adapter casePredicate(Predicate object) + { + return createPredicateAdapter(); + } + @Override + public Adapter casePredicateSymbol(PredicateSymbol object) + { + return createPredicateSymbolAdapter(); + } + @Override + public Adapter caseErrorPredicate(ErrorPredicate object) + { + return createErrorPredicateAdapter(); + } + @Override + public Adapter caseParameter(Parameter object) + { + return createParameterAdapter(); + } + @Override + public Adapter casePatternBody(PatternBody object) + { + return createPatternBodyAdapter(); + } + @Override + public Adapter casePolarity(Polarity object) + { + return createPolarityAdapter(); + } + @Override + public Adapter caseConstraint(Constraint object) + { + return createConstraintAdapter(); + } + @Override + public Adapter caseClosureType(ClosureType object) + { + return createClosureTypeAdapter(); + } + @Override + public Adapter caseLiteral(Literal object) + { + return createLiteralAdapter(); + } + @Override + public Adapter caseVariable(Variable object) + { + return createVariableAdapter(); + } + @Override + public Adapter caseAllInstances(AllInstances object) + { + return createAllInstancesAdapter(); + } + @Override + public Adapter caseAllObjects(AllObjects object) + { + return createAllObjectsAdapter(); + } + @Override + public Adapter caseDefaultInterpretation(DefaultInterpretation object) + { + return createDefaultInterpretationAdapter(); + } + @Override + public Adapter caseCDInterpretation(CDInterpretation object) + { + return createCDInterpretationAdapter(); + } + @Override + public Adapter caseClassInterpretation(ClassInterpretation object) + { + return createClassInterpretationAdapter(); + } + @Override + public Adapter caseEnumInterpretation(EnumInterpretation object) + { + return createEnumInterpretationAdapter(); + } + @Override + public Adapter caseFieldRelationInterpretation(FieldRelationInterpretation object) + { + return createFieldRelationInterpretationAdapter(); + } + @Override + public Adapter caseGlobalRelationInterpretation(GlobalRelationInterpretation object) + { + return createGlobalRelationInterpretationAdapter(); + } + @Override + public Adapter caseMultiplicityDefinition(MultiplicityDefinition object) + { + return createMultiplicityDefinitionAdapter(); + } + @Override + public Adapter caseBooleanTrue(BooleanTrue object) + { + return createBooleanTrueAdapter(); + } + @Override + public Adapter caseBooleanFalse(BooleanFalse object) + { + return createBooleanFalseAdapter(); + } + @Override + public Adapter caseTrue(True object) + { + return createTrueAdapter(); + } + @Override + public Adapter caseFalse(False object) + { + return createFalseAdapter(); + } + @Override + public Adapter caseUnknown(Unknown object) + { + return createUnknownAdapter(); + } + @Override + public Adapter caseError(org.eclipse.viatra.solver.language.solverLanguage.Error object) + { + return createErrorAdapter(); + } + @Override + public Adapter casePositive(Positive object) + { + return createPositiveAdapter(); + } + @Override + public Adapter caseNegative(Negative object) + { + return createNegativeAdapter(); + } + @Override + public Adapter caseReflexiveClosure(ReflexiveClosure object) + { + return createReflexiveClosureAdapter(); + } + @Override + public Adapter caseIrreflexiveClosure(IrreflexiveClosure object) + { + return createIrreflexiveClosureAdapter(); + } + @Override + public Adapter defaultCase(EObject object) + { + return createEObjectAdapter(); + } + }; + + /** + * Creates an adapter for the target. + * + * + * @param target the object to adapt. + * @return the adapter for the target. + * @generated + */ + @Override + public Adapter createAdapter(Notifier target) + { + return modelSwitch.doSwitch((EObject)target); + } + + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Problem Problem}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Problem + * @generated + */ + public Adapter createProblemAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Statement Statement}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Statement + * @generated + */ + public Adapter createStatementAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanValue Boolean Value}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanValue + * @generated + */ + public Adapter createBooleanValueAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.TruthValue Truth Value}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.TruthValue + * @generated + */ + public Adapter createTruthValueAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Interpretation Interpretation}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Interpretation + * @generated + */ + public Adapter createInterpretationAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation Basic Interpretation}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation + * @generated + */ + public Adapter createBasicInterpretationAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Symbol Symbol}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Symbol + * @generated + */ + public Adapter createSymbolAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol Model Symbol}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol + * @generated + */ + public Adapter createModelSymbolAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol Partiality Symbol}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.PartialitySymbol + * @generated + */ + public Adapter createPartialitySymbolAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol Exist Symbol}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol + * @generated + */ + public Adapter createExistSymbolAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol Equals Symbol}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol + * @generated + */ + public Adapter createEqualsSymbolAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.DataSymbol Data Symbol}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.DataSymbol + * @generated + */ + public Adapter createDataSymbolAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol Boolean Symbol}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol + * @generated + */ + public Adapter createBooleanSymbolAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol Integer Symbol}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol + * @generated + */ + public Adapter createIntegerSymbolAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealSymbol Real Symbol}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.RealSymbol + * @generated + */ + public Adapter createRealSymbolAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringSymbol String Symbol}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.StringSymbol + * @generated + */ + public Adapter createStringSymbolAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ComplexObject Complex Object}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.ComplexObject + * @generated + */ + public Adapter createComplexObjectAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Object Object}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Object + * @generated + */ + public Adapter createObjectAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.NamedObject Named Object}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.NamedObject + * @generated + */ + public Adapter createNamedObjectAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject Unnamed Object}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject + * @generated + */ + public Adapter createUnnamedObjectAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.DataObject Data Object}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.DataObject + * @generated + */ + public Adapter createDataObjectAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanObject Boolean Object}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanObject + * @generated + */ + public Adapter createBooleanObjectAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.IntObject Int Object}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.IntObject + * @generated + */ + public Adapter createIntObjectAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.RealObject Real Object}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.RealObject + * @generated + */ + public Adapter createRealObjectAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.StringObject String Object}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.StringObject + * @generated + */ + public Adapter createStringObjectAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Predicate Predicate}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Predicate + * @generated + */ + public Adapter createPredicateAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol Predicate Symbol}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol + * @generated + */ + public Adapter createPredicateSymbolAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate Error Predicate}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate + * @generated + */ + public Adapter createErrorPredicateAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Parameter Parameter}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Parameter + * @generated + */ + public Adapter createParameterAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.PatternBody Pattern Body}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.PatternBody + * @generated + */ + public Adapter createPatternBodyAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Polarity Polarity}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Polarity + * @generated + */ + public Adapter createPolarityAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Constraint Constraint}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Constraint + * @generated + */ + public Adapter createConstraintAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClosureType Closure Type}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.ClosureType + * @generated + */ + public Adapter createClosureTypeAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Literal Literal}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Literal + * @generated + */ + public Adapter createLiteralAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Variable Variable}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Variable + * @generated + */ + public Adapter createVariableAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.AllInstances All Instances}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.AllInstances + * @generated + */ + public Adapter createAllInstancesAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.AllObjects All Objects}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.AllObjects + * @generated + */ + public Adapter createAllObjectsAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation Default Interpretation}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation + * @generated + */ + public Adapter createDefaultInterpretationAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation CD Interpretation}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.CDInterpretation + * @generated + */ + public Adapter createCDInterpretationAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation Class Interpretation}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation + * @generated + */ + public Adapter createClassInterpretationAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation Enum Interpretation}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation + * @generated + */ + public Adapter createEnumInterpretationAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation Field Relation Interpretation}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation + * @generated + */ + public Adapter createFieldRelationInterpretationAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation Global Relation Interpretation}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation + * @generated + */ + public Adapter createGlobalRelationInterpretationAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition Multiplicity Definition}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition + * @generated + */ + public Adapter createMultiplicityDefinitionAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue Boolean True}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue + * @generated + */ + public Adapter createBooleanTrueAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse Boolean False}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse + * @generated + */ + public Adapter createBooleanFalseAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.True True}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.True + * @generated + */ + public Adapter createTrueAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.False False}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.False + * @generated + */ + public Adapter createFalseAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Unknown Unknown}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Unknown + * @generated + */ + public Adapter createUnknownAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Error Error}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Error + * @generated + */ + public Adapter createErrorAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Positive Positive}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Positive + * @generated + */ + public Adapter createPositiveAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.Negative Negative}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.Negative + * @generated + */ + public Adapter createNegativeAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure Reflexive Closure}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure + * @generated + */ + public Adapter createReflexiveClosureAdapter() + { + return null; + } + + /** + * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure Irreflexive Closure}'. + * + * This default implementation returns null so that we can easily ignore cases; + * it's useful to ignore a case when inheritance will catch all the cases anyway. + * + * @return the new adapter. + * @see org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure + * @generated + */ + public Adapter createIrreflexiveClosureAdapter() + { + return null; + } + + /** + * Creates a new adapter for the default case. + * + * This default implementation returns null. + * + * @return the new adapter. + * @generated + */ + public Adapter createEObjectAdapter() + { + return null; + } + +} //SolverLanguageAdapterFactory diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java new file mode 100644 index 00000000..9bc874e3 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/solverLanguage/util/SolverLanguageSwitch.java @@ -0,0 +1,1464 @@ +/** + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.solverLanguage.util; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; + +import org.eclipse.emf.ecore.util.Switch; + +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.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; + +/** + * + * The Switch for the model's inheritance hierarchy. + * It supports the call {@link #doSwitch(EObject) doSwitch(object)} + * to invoke the caseXXX method for each class of the model, + * starting with the actual class of the object + * and proceeding up the inheritance hierarchy + * until a non-null result is returned, + * which is the result of the switch. + * + * @see org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage + * @generated + */ +public class SolverLanguageSwitch extends Switch +{ + /** + * The cached model package + * + * + * @generated + */ + protected static SolverLanguagePackage modelPackage; + + /** + * Creates an instance of the switch. + * + * + * @generated + */ + public SolverLanguageSwitch() + { + if (modelPackage == null) + { + modelPackage = SolverLanguagePackage.eINSTANCE; + } + } + + /** + * Checks whether this is a switch for the given package. + * + * + * @param ePackage the package in question. + * @return whether this is a switch for the given package. + * @generated + */ + @Override + protected boolean isSwitchFor(EPackage ePackage) + { + return ePackage == modelPackage; + } + + /** + * Calls caseXXX for each class of the model until one returns a non null result; it yields that result. + * + * + * @return the first non-null result returned by a caseXXX call. + * @generated + */ + @Override + protected T doSwitch(int classifierID, EObject theEObject) + { + switch (classifierID) + { + case SolverLanguagePackage.PROBLEM: + { + Problem problem = (Problem)theEObject; + T result = caseProblem(problem); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.STATEMENT: + { + Statement statement = (Statement)theEObject; + T result = caseStatement(statement); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.BOOLEAN_VALUE: + { + BooleanValue booleanValue = (BooleanValue)theEObject; + T result = caseBooleanValue(booleanValue); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.TRUTH_VALUE: + { + TruthValue truthValue = (TruthValue)theEObject; + T result = caseTruthValue(truthValue); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.INTERPRETATION: + { + Interpretation interpretation = (Interpretation)theEObject; + T result = caseInterpretation(interpretation); + if (result == null) result = caseStatement(interpretation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.BASIC_INTERPRETATION: + { + BasicInterpretation basicInterpretation = (BasicInterpretation)theEObject; + T result = caseBasicInterpretation(basicInterpretation); + if (result == null) result = caseInterpretation(basicInterpretation); + if (result == null) result = caseStatement(basicInterpretation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.SYMBOL: + { + Symbol symbol = (Symbol)theEObject; + T result = caseSymbol(symbol); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.MODEL_SYMBOL: + { + ModelSymbol modelSymbol = (ModelSymbol)theEObject; + T result = caseModelSymbol(modelSymbol); + if (result == null) result = caseSymbol(modelSymbol); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.PARTIALITY_SYMBOL: + { + PartialitySymbol partialitySymbol = (PartialitySymbol)theEObject; + T result = casePartialitySymbol(partialitySymbol); + if (result == null) result = caseSymbol(partialitySymbol); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.EXIST_SYMBOL: + { + ExistSymbol existSymbol = (ExistSymbol)theEObject; + T result = caseExistSymbol(existSymbol); + if (result == null) result = casePartialitySymbol(existSymbol); + if (result == null) result = caseSymbol(existSymbol); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.EQUALS_SYMBOL: + { + EqualsSymbol equalsSymbol = (EqualsSymbol)theEObject; + T result = caseEqualsSymbol(equalsSymbol); + if (result == null) result = casePartialitySymbol(equalsSymbol); + if (result == null) result = caseSymbol(equalsSymbol); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.DATA_SYMBOL: + { + DataSymbol dataSymbol = (DataSymbol)theEObject; + T result = caseDataSymbol(dataSymbol); + if (result == null) result = caseSymbol(dataSymbol); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.BOOLEAN_SYMBOL: + { + BooleanSymbol booleanSymbol = (BooleanSymbol)theEObject; + T result = caseBooleanSymbol(booleanSymbol); + if (result == null) result = caseDataSymbol(booleanSymbol); + if (result == null) result = caseSymbol(booleanSymbol); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.INTEGER_SYMBOL: + { + IntegerSymbol integerSymbol = (IntegerSymbol)theEObject; + T result = caseIntegerSymbol(integerSymbol); + if (result == null) result = caseDataSymbol(integerSymbol); + if (result == null) result = caseSymbol(integerSymbol); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.REAL_SYMBOL: + { + RealSymbol realSymbol = (RealSymbol)theEObject; + T result = caseRealSymbol(realSymbol); + if (result == null) result = caseDataSymbol(realSymbol); + if (result == null) result = caseSymbol(realSymbol); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.STRING_SYMBOL: + { + StringSymbol stringSymbol = (StringSymbol)theEObject; + T result = caseStringSymbol(stringSymbol); + if (result == null) result = caseDataSymbol(stringSymbol); + if (result == null) result = caseSymbol(stringSymbol); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.COMPLEX_OBJECT: + { + ComplexObject complexObject = (ComplexObject)theEObject; + T result = caseComplexObject(complexObject); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.OBJECT: + { + org.eclipse.viatra.solver.language.solverLanguage.Object object = (org.eclipse.viatra.solver.language.solverLanguage.Object)theEObject; + T result = caseObject(object); + if (result == null) result = caseComplexObject(object); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.NAMED_OBJECT: + { + NamedObject namedObject = (NamedObject)theEObject; + T result = caseNamedObject(namedObject); + if (result == null) result = caseObject(namedObject); + if (result == null) result = caseComplexObject(namedObject); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.UNNAMED_OBJECT: + { + UnnamedObject unnamedObject = (UnnamedObject)theEObject; + T result = caseUnnamedObject(unnamedObject); + if (result == null) result = caseObject(unnamedObject); + if (result == null) result = caseComplexObject(unnamedObject); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.DATA_OBJECT: + { + DataObject dataObject = (DataObject)theEObject; + T result = caseDataObject(dataObject); + if (result == null) result = caseObject(dataObject); + if (result == null) result = caseLiteral(dataObject); + if (result == null) result = caseComplexObject(dataObject); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.BOOLEAN_OBJECT: + { + BooleanObject booleanObject = (BooleanObject)theEObject; + T result = caseBooleanObject(booleanObject); + if (result == null) result = caseDataObject(booleanObject); + if (result == null) result = caseObject(booleanObject); + if (result == null) result = caseLiteral(booleanObject); + if (result == null) result = caseComplexObject(booleanObject); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.INT_OBJECT: + { + IntObject intObject = (IntObject)theEObject; + T result = caseIntObject(intObject); + if (result == null) result = caseDataObject(intObject); + if (result == null) result = caseObject(intObject); + if (result == null) result = caseLiteral(intObject); + if (result == null) result = caseComplexObject(intObject); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.REAL_OBJECT: + { + RealObject realObject = (RealObject)theEObject; + T result = caseRealObject(realObject); + if (result == null) result = caseDataObject(realObject); + if (result == null) result = caseObject(realObject); + if (result == null) result = caseLiteral(realObject); + if (result == null) result = caseComplexObject(realObject); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.STRING_OBJECT: + { + StringObject stringObject = (StringObject)theEObject; + T result = caseStringObject(stringObject); + if (result == null) result = caseDataObject(stringObject); + if (result == null) result = caseObject(stringObject); + if (result == null) result = caseLiteral(stringObject); + if (result == null) result = caseComplexObject(stringObject); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.PREDICATE: + { + Predicate predicate = (Predicate)theEObject; + T result = casePredicate(predicate); + if (result == null) result = caseStatement(predicate); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.PREDICATE_SYMBOL: + { + PredicateSymbol predicateSymbol = (PredicateSymbol)theEObject; + T result = casePredicateSymbol(predicateSymbol); + if (result == null) result = casePredicate(predicateSymbol); + if (result == null) result = caseStatement(predicateSymbol); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.ERROR_PREDICATE: + { + ErrorPredicate errorPredicate = (ErrorPredicate)theEObject; + T result = caseErrorPredicate(errorPredicate); + if (result == null) result = casePredicate(errorPredicate); + if (result == null) result = caseStatement(errorPredicate); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.PARAMETER: + { + Parameter parameter = (Parameter)theEObject; + T result = caseParameter(parameter); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.PATTERN_BODY: + { + PatternBody patternBody = (PatternBody)theEObject; + T result = casePatternBody(patternBody); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.POLARITY: + { + Polarity polarity = (Polarity)theEObject; + T result = casePolarity(polarity); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.CONSTRAINT: + { + Constraint constraint = (Constraint)theEObject; + T result = caseConstraint(constraint); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.CLOSURE_TYPE: + { + ClosureType closureType = (ClosureType)theEObject; + T result = caseClosureType(closureType); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.LITERAL: + { + Literal literal = (Literal)theEObject; + T result = caseLiteral(literal); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.VARIABLE: + { + Variable variable = (Variable)theEObject; + T result = caseVariable(variable); + if (result == null) result = caseLiteral(variable); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.ALL_INSTANCES: + { + AllInstances allInstances = (AllInstances)theEObject; + T result = caseAllInstances(allInstances); + if (result == null) result = caseComplexObject(allInstances); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.ALL_OBJECTS: + { + AllObjects allObjects = (AllObjects)theEObject; + T result = caseAllObjects(allObjects); + if (result == null) result = caseComplexObject(allObjects); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.DEFAULT_INTERPRETATION: + { + DefaultInterpretation defaultInterpretation = (DefaultInterpretation)theEObject; + T result = caseDefaultInterpretation(defaultInterpretation); + if (result == null) result = caseInterpretation(defaultInterpretation); + if (result == null) result = caseStatement(defaultInterpretation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.CD_INTERPRETATION: + { + CDInterpretation cdInterpretation = (CDInterpretation)theEObject; + T result = caseCDInterpretation(cdInterpretation); + if (result == null) result = caseInterpretation(cdInterpretation); + if (result == null) result = caseStatement(cdInterpretation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.CLASS_INTERPRETATION: + { + ClassInterpretation classInterpretation = (ClassInterpretation)theEObject; + T result = caseClassInterpretation(classInterpretation); + if (result == null) result = caseCDInterpretation(classInterpretation); + if (result == null) result = caseInterpretation(classInterpretation); + if (result == null) result = caseStatement(classInterpretation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.ENUM_INTERPRETATION: + { + EnumInterpretation enumInterpretation = (EnumInterpretation)theEObject; + T result = caseEnumInterpretation(enumInterpretation); + if (result == null) result = caseCDInterpretation(enumInterpretation); + if (result == null) result = caseInterpretation(enumInterpretation); + if (result == null) result = caseStatement(enumInterpretation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION: + { + FieldRelationInterpretation fieldRelationInterpretation = (FieldRelationInterpretation)theEObject; + T result = caseFieldRelationInterpretation(fieldRelationInterpretation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION: + { + GlobalRelationInterpretation globalRelationInterpretation = (GlobalRelationInterpretation)theEObject; + T result = caseGlobalRelationInterpretation(globalRelationInterpretation); + if (result == null) result = caseCDInterpretation(globalRelationInterpretation); + if (result == null) result = caseInterpretation(globalRelationInterpretation); + if (result == null) result = caseStatement(globalRelationInterpretation); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.MULTIPLICITY_DEFINITION: + { + MultiplicityDefinition multiplicityDefinition = (MultiplicityDefinition)theEObject; + T result = caseMultiplicityDefinition(multiplicityDefinition); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.BOOLEAN_TRUE: + { + BooleanTrue booleanTrue = (BooleanTrue)theEObject; + T result = caseBooleanTrue(booleanTrue); + if (result == null) result = caseBooleanValue(booleanTrue); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.BOOLEAN_FALSE: + { + BooleanFalse booleanFalse = (BooleanFalse)theEObject; + T result = caseBooleanFalse(booleanFalse); + if (result == null) result = caseBooleanValue(booleanFalse); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.TRUE: + { + True true_ = (True)theEObject; + T result = caseTrue(true_); + if (result == null) result = caseTruthValue(true_); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.FALSE: + { + False false_ = (False)theEObject; + T result = caseFalse(false_); + if (result == null) result = caseTruthValue(false_); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.UNKNOWN: + { + Unknown unknown = (Unknown)theEObject; + T result = caseUnknown(unknown); + if (result == null) result = caseTruthValue(unknown); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.ERROR: + { + org.eclipse.viatra.solver.language.solverLanguage.Error error = (org.eclipse.viatra.solver.language.solverLanguage.Error)theEObject; + T result = caseError(error); + if (result == null) result = caseTruthValue(error); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.POSITIVE: + { + Positive positive = (Positive)theEObject; + T result = casePositive(positive); + if (result == null) result = casePolarity(positive); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.NEGATIVE: + { + Negative negative = (Negative)theEObject; + T result = caseNegative(negative); + if (result == null) result = casePolarity(negative); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.REFLEXIVE_CLOSURE: + { + ReflexiveClosure reflexiveClosure = (ReflexiveClosure)theEObject; + T result = caseReflexiveClosure(reflexiveClosure); + if (result == null) result = caseClosureType(reflexiveClosure); + if (result == null) result = defaultCase(theEObject); + return result; + } + case SolverLanguagePackage.IRREFLEXIVE_CLOSURE: + { + IrreflexiveClosure irreflexiveClosure = (IrreflexiveClosure)theEObject; + T result = caseIrreflexiveClosure(irreflexiveClosure); + if (result == null) result = caseClosureType(irreflexiveClosure); + if (result == null) result = defaultCase(theEObject); + return result; + } + default: return defaultCase(theEObject); + } + } + + /** + * Returns the result of interpreting the object as an instance of 'Problem'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Problem'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseProblem(Problem object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Statement'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Statement'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseStatement(Statement object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Boolean Value'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Boolean Value'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseBooleanValue(BooleanValue object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Truth Value'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Truth Value'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseTruthValue(TruthValue object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Interpretation'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Interpretation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseInterpretation(Interpretation object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Basic Interpretation'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Basic Interpretation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseBasicInterpretation(BasicInterpretation object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Symbol'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Symbol'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseSymbol(Symbol object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Model Symbol'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Model Symbol'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseModelSymbol(ModelSymbol object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Partiality Symbol'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Partiality Symbol'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePartialitySymbol(PartialitySymbol object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Exist Symbol'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Exist Symbol'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseExistSymbol(ExistSymbol object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Equals Symbol'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Equals Symbol'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseEqualsSymbol(EqualsSymbol object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Data Symbol'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Data Symbol'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseDataSymbol(DataSymbol object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Boolean Symbol'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Boolean Symbol'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseBooleanSymbol(BooleanSymbol object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Integer Symbol'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Integer Symbol'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseIntegerSymbol(IntegerSymbol object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Real Symbol'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Real Symbol'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseRealSymbol(RealSymbol object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'String Symbol'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'String Symbol'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseStringSymbol(StringSymbol object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Complex Object'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Complex Object'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseComplexObject(ComplexObject object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Object'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Object'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseObject(org.eclipse.viatra.solver.language.solverLanguage.Object object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Named Object'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Named Object'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseNamedObject(NamedObject object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Unnamed Object'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Unnamed Object'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseUnnamedObject(UnnamedObject object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Data Object'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Data Object'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseDataObject(DataObject object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Boolean Object'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Boolean Object'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseBooleanObject(BooleanObject object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Int Object'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Int Object'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseIntObject(IntObject object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Real Object'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Real Object'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseRealObject(RealObject object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'String Object'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'String Object'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseStringObject(StringObject object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Predicate'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Predicate'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePredicate(Predicate object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Predicate Symbol'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Predicate Symbol'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePredicateSymbol(PredicateSymbol object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Error Predicate'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Error Predicate'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseErrorPredicate(ErrorPredicate object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Parameter'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Parameter'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseParameter(Parameter object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Pattern Body'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Pattern Body'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePatternBody(PatternBody object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Polarity'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Polarity'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePolarity(Polarity object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Constraint'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Constraint'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseConstraint(Constraint object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Closure Type'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Closure Type'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseClosureType(ClosureType object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Literal'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Literal'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseLiteral(Literal object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Variable'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Variable'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseVariable(Variable object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'All Instances'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'All Instances'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseAllInstances(AllInstances object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'All Objects'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'All Objects'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseAllObjects(AllObjects object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Default Interpretation'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Default Interpretation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseDefaultInterpretation(DefaultInterpretation object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'CD Interpretation'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'CD Interpretation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseCDInterpretation(CDInterpretation object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Class Interpretation'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Class Interpretation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseClassInterpretation(ClassInterpretation object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Enum Interpretation'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Enum Interpretation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseEnumInterpretation(EnumInterpretation object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Field Relation Interpretation'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Field Relation Interpretation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseFieldRelationInterpretation(FieldRelationInterpretation object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Global Relation Interpretation'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Global Relation Interpretation'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseGlobalRelationInterpretation(GlobalRelationInterpretation object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Multiplicity Definition'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Multiplicity Definition'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseMultiplicityDefinition(MultiplicityDefinition object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Boolean True'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Boolean True'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseBooleanTrue(BooleanTrue object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Boolean False'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Boolean False'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseBooleanFalse(BooleanFalse object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'True'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'True'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseTrue(True object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'False'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'False'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseFalse(False object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Unknown'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Unknown'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseUnknown(Unknown object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Error'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Error'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseError(org.eclipse.viatra.solver.language.solverLanguage.Error object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Positive'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Positive'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T casePositive(Positive object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Negative'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Negative'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseNegative(Negative object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Reflexive Closure'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Reflexive Closure'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseReflexiveClosure(ReflexiveClosure object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'Irreflexive Closure'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'Irreflexive Closure'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) + * @generated + */ + public T caseIrreflexiveClosure(IrreflexiveClosure object) + { + return null; + } + + /** + * Returns the result of interpreting the object as an instance of 'EObject'. + * + * This implementation returns null; + * returning a non-null result will terminate the switch, but this is the last case anyway. + * + * @param object the target of the switch. + * @return the result of interpreting the object as an instance of 'EObject'. + * @see #doSwitch(org.eclipse.emf.ecore.EObject) + * @generated + */ + @Override + public T defaultCase(EObject object) + { + return null; + } + +} //SolverLanguageSwitch diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java new file mode 100644 index 00000000..e4313a24 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/AbstractSolverLanguageValidator.java @@ -0,0 +1,19 @@ +/* + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.validation; + +import java.util.ArrayList; +import java.util.List; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.xtext.validation.AbstractDeclarativeValidator; + +public abstract class AbstractSolverLanguageValidator extends AbstractDeclarativeValidator { + + @Override + protected List getEPackages() { + List result = new ArrayList(); + result.add(org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage.eINSTANCE); + return result; + } +} diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java new file mode 100644 index 00000000..4247dc60 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/validation/SolverLanguageConfigurableIssueCodesProvider.java @@ -0,0 +1,22 @@ +/* + * generated by Xtext 2.18.0.M3 + */ +package org.eclipse.viatra.solver.language.validation; + +import org.eclipse.xtext.preferences.PreferenceKey; +import org.eclipse.xtext.util.IAcceptor; +import org.eclipse.xtext.validation.ConfigurableIssueCodesProvider; +import org.eclipse.xtext.validation.SeverityConverter; + +@SuppressWarnings("restriction") +public class SolverLanguageConfigurableIssueCodesProvider extends ConfigurableIssueCodesProvider { + protected static final String ISSUE_CODE_PREFIX = "org.eclipse.viatra.solver.language."; + + public static final String DEPRECATED_MODEL_PART = ISSUE_CODE_PREFIX + "deprecatedModelPart"; + + @Override + protected void initialize(IAcceptor acceptor) { + super.initialize(acceptor); + acceptor.accept(create(DEPRECATED_MODEL_PART, SeverityConverter.SEVERITY_WARNING)); + } +} -- cgit v1.2.3-54-g00ecf