From 42c58bbeead1dae09c51f47abc8e10dfbb9c3f9f Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Tue, 23 Jun 2020 15:17:00 +0200 Subject: New configuration language parser WIP --- .../impl/SolverLanguageFactoryImpl.java | 985 +++++++++++++++++++++ 1 file changed, 985 insertions(+) create mode 100644 Application/org.eclipse.viatra.solver.language.model/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java (limited to 'Application/org.eclipse.viatra.solver.language.model/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java') diff --git a/Application/org.eclipse.viatra.solver.language.model/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java b/Application/org.eclipse.viatra.solver.language.model/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java new file mode 100644 index 00000000..96e741b9 --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language.model/src-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java @@ -0,0 +1,985 @@ +/** + */ +package org.eclipse.viatra.solver.language.solverLanguage.impl; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EDataType; +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.*; + +/** + * + * 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.PATH_COMPONENT: + return createPathComponent(); + case SolverLanguagePackage.CALL: + return createCall(); + case SolverLanguagePackage.REFERENCE: + return createReference(); + case SolverLanguagePackage.ARGUMENT_LIST: + return createArgumentList(); + case SolverLanguagePackage.EXPRESSION_ARGUMENT: + return createExpressionArgument(); + case SolverLanguagePackage.STAR_ARGUMENT: + return createStarArgument(); + case SolverLanguagePackage.VARIABLE: + return createVariable(); + case SolverLanguagePackage.UNARY_EXPRESSION: + return createUnaryExpression(); + case SolverLanguagePackage.BINARY_EXPRESSION: + return createBinaryExpression(); + case SolverLanguagePackage.DISJUNCTION: + return createDisjunction(); + case SolverLanguagePackage.CONJUNCTION: + return createConjunction(); + case SolverLanguagePackage.CONDITIONAL_EXPRESSION: + return createConditionalExpression(); + case SolverLanguagePackage.SWITCH: + return createSwitch(); + case SolverLanguagePackage.CASE: + return createCase(); + case SolverLanguagePackage.LET_EXPRESSION: + return createLetExpression(); + case SolverLanguagePackage.LET_BINDING: + return createLetBinding(); + case SolverLanguagePackage.INT_LITERAL: + return createIntLiteral(); + case SolverLanguagePackage.REAL_LITERAL: + return createRealLiteral(); + case SolverLanguagePackage.STRING_LITERAL: + return createStringLiteral(); + case SolverLanguagePackage.LOGIC_LITERAL: + return createLogicLiteral(); + case SolverLanguagePackage.EMPTY_LITERAL: + return createEmptyLiteral(); + case SolverLanguagePackage.CAST_EXPRESSION: + return createCastExpression(); + case SolverLanguagePackage.COUNT: + return createCount(); + case SolverLanguagePackage.AGGREGATION: + return createAggregation(); + case SolverLanguagePackage.FORALL: + return createForall(); + case SolverLanguagePackage.TYPE_REFERENCE: + return createTypeReference(); + case SolverLanguagePackage.INFINITY_LITERAL: + return createInfinityLiteral(); + case SolverLanguagePackage.INTERVAL: + return createInterval(); + case SolverLanguagePackage.BASE_RELATION: + return createBaseRelation(); + case SolverLanguagePackage.PREDICATE: + return createPredicate(); + case SolverLanguagePackage.DATATYPE: + return createDatatype(); + case SolverLanguagePackage.METRIC: + return createMetric(); + case SolverLanguagePackage.OPERATOR: + return createOperator(); + case SolverLanguagePackage.NODE: + return createNode(); + case SolverLanguagePackage.PREDICATE_DEFINITION: + return createPredicateDefinition(); + case SolverLanguagePackage.FUNCTION_DEFINITION: + return createFunctionDefinition(); + case SolverLanguagePackage.EXTERN_PREDICATE_DECLARATION: + return createExternPredicateDeclaration(); + case SolverLanguagePackage.EXTERN_FUNCTION_DECLARATION: + return createExternFunctionDeclaration(); + case SolverLanguagePackage.EXTERN_AGGREGATION_OPERATOR_DECLARATION: + return createExternAggregationOperatorDeclaration(); + case SolverLanguagePackage.EXTERN_DATATYPE_DECLARATION: + return createExternDatatypeDeclaration(); + case SolverLanguagePackage.CLASS_DECLARATION: + return createClassDeclaration(); + case SolverLanguagePackage.ENUM_DECLARATION: + return createEnumDeclaration(); + case SolverLanguagePackage.ENUM_LITERAL: + return createEnumLiteral(); + case SolverLanguagePackage.FIELD: + return createField(); + case SolverLanguagePackage.DEFAULT_ASSERTION: + return createDefaultAssertion(); + case SolverLanguagePackage.ASSERTION: + return createAssertion(); + case SolverLanguagePackage.UNBOUNDED_MULTIPLICITY: + return createUnboundedMultiplicity(); + case SolverLanguagePackage.EXACT_MULTIPLICITY: + return createExactMultiplicity(); + case SolverLanguagePackage.BOUNDED_MULTIPLICITY: + return createBoundedMultiplicity(); + case SolverLanguagePackage.AGGREGATION_OPERATOR: + return createAggregationOperator(); + case SolverLanguagePackage.PROBLEM: + return createProblem(); + case SolverLanguagePackage.TYPED_STAR_ARGUMENT: + return createTypedStarArgument(); + case SolverLanguagePackage.TYPED_VARIABLE_ARGUMENT: + return createTypedVariableArgument(); + case SolverLanguagePackage.UNNAMED_ERROR_PREDICATE_DEFINTION: + return createUnnamedErrorPredicateDefintion(); + case SolverLanguagePackage.OBJECTIVE_DECLARATION: + return createObjectiveDeclaration(); + case SolverLanguagePackage.SCOPE_DECLARATION: + return createScopeDeclaration(); + case SolverLanguagePackage.EXACT_SCOPE: + return createExactScope(); + case SolverLanguagePackage.BOUNDED_SCOPE: + return createBoundedScope(); + case SolverLanguagePackage.LOWER_BOUNDED_SCOPE: + return createLowerBoundedScope(); + case SolverLanguagePackage.NAMESPACE_IMPORT: + return createNamespaceImport(); + case SolverLanguagePackage.IMPORT: + return createImport(); + case SolverLanguagePackage.URI_IMPORT: + return createUriImport(); + default: + throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier"); + } + } + + /** + * + * + * @generated + */ + @Override + public Object createFromString(EDataType eDataType, String initialValue) { + switch (eDataType.getClassifierID()) { + case SolverLanguagePackage.UNARY_OPERATOR: + return createUnaryOperatorFromString(eDataType, initialValue); + case SolverLanguagePackage.BINARY_OPERATOR: + return createBinaryOperatorFromString(eDataType, initialValue); + case SolverLanguagePackage.LOGIC_VALUE: + return createLogicValueFromString(eDataType, initialValue); + case SolverLanguagePackage.OBJECTIVE_KIND: + return createObjectiveKindFromString(eDataType, initialValue); + case SolverLanguagePackage.ATTRIBUTE_KIND: + return createAttributeKindFromString(eDataType, initialValue); + default: + throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier"); + } + } + + /** + * + * + * @generated + */ + @Override + public String convertToString(EDataType eDataType, Object instanceValue) { + switch (eDataType.getClassifierID()) { + case SolverLanguagePackage.UNARY_OPERATOR: + return convertUnaryOperatorToString(eDataType, instanceValue); + case SolverLanguagePackage.BINARY_OPERATOR: + return convertBinaryOperatorToString(eDataType, instanceValue); + case SolverLanguagePackage.LOGIC_VALUE: + return convertLogicValueToString(eDataType, instanceValue); + case SolverLanguagePackage.OBJECTIVE_KIND: + return convertObjectiveKindToString(eDataType, instanceValue); + case SolverLanguagePackage.ATTRIBUTE_KIND: + return convertAttributeKindToString(eDataType, instanceValue); + default: + throw new IllegalArgumentException("The datatype '" + eDataType.getName() + "' is not a valid classifier"); + } + } + + /** + * + * + * @generated + */ + public PathComponent createPathComponent() { + PathComponentImpl pathComponent = new PathComponentImpl(); + return pathComponent; + } + + /** + * + * + * @generated + */ + public Call createCall() { + CallImpl call = new CallImpl(); + return call; + } + + /** + * + * + * @generated + */ + public Reference createReference() { + ReferenceImpl reference = new ReferenceImpl(); + return reference; + } + + /** + * + * + * @generated + */ + public ArgumentList createArgumentList() { + ArgumentListImpl argumentList = new ArgumentListImpl(); + return argumentList; + } + + /** + * + * + * @generated + */ + public ExpressionArgument createExpressionArgument() { + ExpressionArgumentImpl expressionArgument = new ExpressionArgumentImpl(); + return expressionArgument; + } + + /** + * + * + * @generated + */ + public StarArgument createStarArgument() { + StarArgumentImpl starArgument = new StarArgumentImpl(); + return starArgument; + } + + /** + * + * + * @generated + */ + public Variable createVariable() { + VariableImpl variable = new VariableImpl(); + return variable; + } + + /** + * + * + * @generated + */ + public UnaryExpression createUnaryExpression() { + UnaryExpressionImpl unaryExpression = new UnaryExpressionImpl(); + return unaryExpression; + } + + /** + * + * + * @generated + */ + public BinaryExpression createBinaryExpression() { + BinaryExpressionImpl binaryExpression = new BinaryExpressionImpl(); + return binaryExpression; + } + + /** + * + * + * @generated + */ + public Disjunction createDisjunction() { + DisjunctionImpl disjunction = new DisjunctionImpl(); + return disjunction; + } + + /** + * + * + * @generated + */ + public Conjunction createConjunction() { + ConjunctionImpl conjunction = new ConjunctionImpl(); + return conjunction; + } + + /** + * + * + * @generated + */ + public ConditionalExpression createConditionalExpression() { + ConditionalExpressionImpl conditionalExpression = new ConditionalExpressionImpl(); + return conditionalExpression; + } + + /** + * + * + * @generated + */ + public Switch createSwitch() { + SwitchImpl switch_ = new SwitchImpl(); + return switch_; + } + + /** + * + * + * @generated + */ + public Case createCase() { + CaseImpl case_ = new CaseImpl(); + return case_; + } + + /** + * + * + * @generated + */ + public LetExpression createLetExpression() { + LetExpressionImpl letExpression = new LetExpressionImpl(); + return letExpression; + } + + /** + * + * + * @generated + */ + public LetBinding createLetBinding() { + LetBindingImpl letBinding = new LetBindingImpl(); + return letBinding; + } + + /** + * + * + * @generated + */ + public IntLiteral createIntLiteral() { + IntLiteralImpl intLiteral = new IntLiteralImpl(); + return intLiteral; + } + + /** + * + * + * @generated + */ + public RealLiteral createRealLiteral() { + RealLiteralImpl realLiteral = new RealLiteralImpl(); + return realLiteral; + } + + /** + * + * + * @generated + */ + public StringLiteral createStringLiteral() { + StringLiteralImpl stringLiteral = new StringLiteralImpl(); + return stringLiteral; + } + + /** + * + * + * @generated + */ + public LogicLiteral createLogicLiteral() { + LogicLiteralImpl logicLiteral = new LogicLiteralImpl(); + return logicLiteral; + } + + /** + * + * + * @generated + */ + public EmptyLiteral createEmptyLiteral() { + EmptyLiteralImpl emptyLiteral = new EmptyLiteralImpl(); + return emptyLiteral; + } + + /** + * + * + * @generated + */ + public CastExpression createCastExpression() { + CastExpressionImpl castExpression = new CastExpressionImpl(); + return castExpression; + } + + /** + * + * + * @generated + */ + public Count createCount() { + CountImpl count = new CountImpl(); + return count; + } + + /** + * + * + * @generated + */ + public Aggregation createAggregation() { + AggregationImpl aggregation = new AggregationImpl(); + return aggregation; + } + + /** + * + * + * @generated + */ + public Forall createForall() { + ForallImpl forall = new ForallImpl(); + return forall; + } + + /** + * + * + * @generated + */ + public TypeReference createTypeReference() { + TypeReferenceImpl typeReference = new TypeReferenceImpl(); + return typeReference; + } + + /** + * + * + * @generated + */ + public InfinityLiteral createInfinityLiteral() { + InfinityLiteralImpl infinityLiteral = new InfinityLiteralImpl(); + return infinityLiteral; + } + + /** + * + * + * @generated + */ + public Interval createInterval() { + IntervalImpl interval = new IntervalImpl(); + return interval; + } + + /** + * + * + * @generated + */ + public BaseRelation createBaseRelation() { + BaseRelationImpl baseRelation = new BaseRelationImpl(); + return baseRelation; + } + + /** + * + * + * @generated + */ + public Predicate createPredicate() { + PredicateImpl predicate = new PredicateImpl(); + return predicate; + } + + /** + * + * + * @generated + */ + public Datatype createDatatype() { + DatatypeImpl datatype = new DatatypeImpl(); + return datatype; + } + + /** + * + * + * @generated + */ + public Metric createMetric() { + MetricImpl metric = new MetricImpl(); + return metric; + } + + /** + * + * + * @generated + */ + public Operator createOperator() { + OperatorImpl operator = new OperatorImpl(); + return operator; + } + + /** + * + * + * @generated + */ + public Node createNode() { + NodeImpl node = new NodeImpl(); + return node; + } + + /** + * + * + * @generated + */ + public PredicateDefinition createPredicateDefinition() { + PredicateDefinitionImpl predicateDefinition = new PredicateDefinitionImpl(); + return predicateDefinition; + } + + /** + * + * + * @generated + */ + public FunctionDefinition createFunctionDefinition() { + FunctionDefinitionImpl functionDefinition = new FunctionDefinitionImpl(); + return functionDefinition; + } + + /** + * + * + * @generated + */ + public ExternPredicateDeclaration createExternPredicateDeclaration() { + ExternPredicateDeclarationImpl externPredicateDeclaration = new ExternPredicateDeclarationImpl(); + return externPredicateDeclaration; + } + + /** + * + * + * @generated + */ + public ExternFunctionDeclaration createExternFunctionDeclaration() { + ExternFunctionDeclarationImpl externFunctionDeclaration = new ExternFunctionDeclarationImpl(); + return externFunctionDeclaration; + } + + /** + * + * + * @generated + */ + public ExternAggregationOperatorDeclaration createExternAggregationOperatorDeclaration() { + ExternAggregationOperatorDeclarationImpl externAggregationOperatorDeclaration = new ExternAggregationOperatorDeclarationImpl(); + return externAggregationOperatorDeclaration; + } + + /** + * + * + * @generated + */ + public ExternDatatypeDeclaration createExternDatatypeDeclaration() { + ExternDatatypeDeclarationImpl externDatatypeDeclaration = new ExternDatatypeDeclarationImpl(); + return externDatatypeDeclaration; + } + + /** + * + * + * @generated + */ + public ClassDeclaration createClassDeclaration() { + ClassDeclarationImpl classDeclaration = new ClassDeclarationImpl(); + return classDeclaration; + } + + /** + * + * + * @generated + */ + public EnumDeclaration createEnumDeclaration() { + EnumDeclarationImpl enumDeclaration = new EnumDeclarationImpl(); + return enumDeclaration; + } + + /** + * + * + * @generated + */ + public EnumLiteral createEnumLiteral() { + EnumLiteralImpl enumLiteral = new EnumLiteralImpl(); + return enumLiteral; + } + + /** + * + * + * @generated + */ + public Field createField() { + FieldImpl field = new FieldImpl(); + return field; + } + + /** + * + * + * @generated + */ + public DefaultAssertion createDefaultAssertion() { + DefaultAssertionImpl defaultAssertion = new DefaultAssertionImpl(); + return defaultAssertion; + } + + /** + * + * + * @generated + */ + public Assertion createAssertion() { + AssertionImpl assertion = new AssertionImpl(); + return assertion; + } + + /** + * + * + * @generated + */ + public UnboundedMultiplicity createUnboundedMultiplicity() { + UnboundedMultiplicityImpl unboundedMultiplicity = new UnboundedMultiplicityImpl(); + return unboundedMultiplicity; + } + + /** + * + * + * @generated + */ + public ExactMultiplicity createExactMultiplicity() { + ExactMultiplicityImpl exactMultiplicity = new ExactMultiplicityImpl(); + return exactMultiplicity; + } + + /** + * + * + * @generated + */ + public BoundedMultiplicity createBoundedMultiplicity() { + BoundedMultiplicityImpl boundedMultiplicity = new BoundedMultiplicityImpl(); + return boundedMultiplicity; + } + + /** + * + * + * @generated + */ + public AggregationOperator createAggregationOperator() { + AggregationOperatorImpl aggregationOperator = new AggregationOperatorImpl(); + return aggregationOperator; + } + + /** + * + * + * @generated + */ + public Problem createProblem() { + ProblemImpl problem = new ProblemImpl(); + return problem; + } + + /** + * + * + * @generated + */ + public TypedStarArgument createTypedStarArgument() { + TypedStarArgumentImpl typedStarArgument = new TypedStarArgumentImpl(); + return typedStarArgument; + } + + /** + * + * + * @generated + */ + public TypedVariableArgument createTypedVariableArgument() { + TypedVariableArgumentImpl typedVariableArgument = new TypedVariableArgumentImpl(); + return typedVariableArgument; + } + + /** + * + * + * @generated + */ + public UnnamedErrorPredicateDefintion createUnnamedErrorPredicateDefintion() { + UnnamedErrorPredicateDefintionImpl unnamedErrorPredicateDefintion = new UnnamedErrorPredicateDefintionImpl(); + return unnamedErrorPredicateDefintion; + } + + /** + * + * + * @generated + */ + public ObjectiveDeclaration createObjectiveDeclaration() { + ObjectiveDeclarationImpl objectiveDeclaration = new ObjectiveDeclarationImpl(); + return objectiveDeclaration; + } + + /** + * + * + * @generated + */ + public ScopeDeclaration createScopeDeclaration() { + ScopeDeclarationImpl scopeDeclaration = new ScopeDeclarationImpl(); + return scopeDeclaration; + } + + /** + * + * + * @generated + */ + public ExactScope createExactScope() { + ExactScopeImpl exactScope = new ExactScopeImpl(); + return exactScope; + } + + /** + * + * + * @generated + */ + public BoundedScope createBoundedScope() { + BoundedScopeImpl boundedScope = new BoundedScopeImpl(); + return boundedScope; + } + + /** + * + * + * @generated + */ + public LowerBoundedScope createLowerBoundedScope() { + LowerBoundedScopeImpl lowerBoundedScope = new LowerBoundedScopeImpl(); + return lowerBoundedScope; + } + + /** + * + * + * @generated + */ + public NamespaceImport createNamespaceImport() { + NamespaceImportImpl namespaceImport = new NamespaceImportImpl(); + return namespaceImport; + } + + /** + * + * + * @generated + */ + public Import createImport() { + ImportImpl import_ = new ImportImpl(); + return import_; + } + + /** + * + * + * @generated + */ + public UriImport createUriImport() { + UriImportImpl uriImport = new UriImportImpl(); + return uriImport; + } + + /** + * + * + * @generated + */ + public UnaryOperator createUnaryOperatorFromString(EDataType eDataType, String initialValue) { + UnaryOperator result = UnaryOperator.get(initialValue); + if (result == null) + throw new IllegalArgumentException( + "The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); + return result; + } + + /** + * + * + * @generated + */ + public String convertUnaryOperatorToString(EDataType eDataType, Object instanceValue) { + return instanceValue == null ? null : instanceValue.toString(); + } + + /** + * + * + * @generated + */ + public BinaryOperator createBinaryOperatorFromString(EDataType eDataType, String initialValue) { + BinaryOperator result = BinaryOperator.get(initialValue); + if (result == null) + throw new IllegalArgumentException( + "The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); + return result; + } + + /** + * + * + * @generated + */ + public String convertBinaryOperatorToString(EDataType eDataType, Object instanceValue) { + return instanceValue == null ? null : instanceValue.toString(); + } + + /** + * + * + * @generated + */ + public LogicValue createLogicValueFromString(EDataType eDataType, String initialValue) { + LogicValue result = LogicValue.get(initialValue); + if (result == null) + throw new IllegalArgumentException( + "The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); + return result; + } + + /** + * + * + * @generated + */ + public String convertLogicValueToString(EDataType eDataType, Object instanceValue) { + return instanceValue == null ? null : instanceValue.toString(); + } + + /** + * + * + * @generated + */ + public ObjectiveKind createObjectiveKindFromString(EDataType eDataType, String initialValue) { + ObjectiveKind result = ObjectiveKind.get(initialValue); + if (result == null) + throw new IllegalArgumentException( + "The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); + return result; + } + + /** + * + * + * @generated + */ + public String convertObjectiveKindToString(EDataType eDataType, Object instanceValue) { + return instanceValue == null ? null : instanceValue.toString(); + } + + /** + * + * + * @generated + */ + public AttributeKind createAttributeKindFromString(EDataType eDataType, String initialValue) { + AttributeKind result = AttributeKind.get(initialValue); + if (result == null) + throw new IllegalArgumentException( + "The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); + return result; + } + + /** + * + * + * @generated + */ + public String convertAttributeKindToString(EDataType eDataType, Object instanceValue) { + return instanceValue == null ? null : instanceValue.toString(); + } + + /** + * + * + * @generated + */ + public SolverLanguagePackage getSolverLanguagePackage() { + return (SolverLanguagePackage) getEPackage(); + } + + /** + * + * + * @deprecated + * @generated + */ + @Deprecated + public static SolverLanguagePackage getPackage() { + return SolverLanguagePackage.eINSTANCE; + } + +} //SolverLanguageFactoryImpl -- cgit v1.2.3-70-g09d2