From b3c1c5b30ae8ea7ebad391c9250b4509d5a4cc9b Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Tue, 19 May 2020 21:18:06 +0200 Subject: Config language WIP --- .../impl/SolverLanguageFactoryImpl.java | 905 +++++++++++++++++++++ 1 file changed, 905 insertions(+) create mode 100644 Application/org.eclipse.viatra.solver.language/ecore-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java (limited to 'Application/org.eclipse.viatra.solver.language/ecore-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java') diff --git a/Application/org.eclipse.viatra.solver.language/ecore-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java b/Application/org.eclipse.viatra.solver.language/ecore-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java new file mode 100644 index 00000000..5787175b --- /dev/null +++ b/Application/org.eclipse.viatra.solver.language/ecore-gen/org/eclipse/viatra/solver/language/solverLanguage/impl/SolverLanguageFactoryImpl.java @@ -0,0 +1,905 @@ +/** + * generated by Xtext 2.21.0 + */ +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.PROBLEM: return createProblem(); + case SolverLanguagePackage.STATEMENT: return createStatement(); + case SolverLanguagePackage.PREDICATE_DEFINITION: return createPredicateDefinition(); + case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION: return createUnnamedErrorPrediateDefinition(); + case SolverLanguagePackage.DEFAULT_DEFINITION: return createDefaultDefinition(); + case SolverLanguagePackage.METRIC_DEFINITION: return createMetricDefinition(); + case SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION: return createExternPredicateDefinition(); + case SolverLanguagePackage.EXTERN_METRIC_DEFINITION: return createExternMetricDefinition(); + case SolverLanguagePackage.EXTERN_AGGREGATOR_DEFINITION: return createExternAggregatorDefinition(); + case SolverLanguagePackage.EXTERN_DATATYPE_DEFINITION: return createExternDatatypeDefinition(); + case SolverLanguagePackage.NAMED_ELEMENT: return createNamedElement(); + case SolverLanguagePackage.IF_ELSE: return createIfElse(); + case SolverLanguagePackage.LET: return createLet(); + case SolverLanguagePackage.LET_BINDING: return createLetBinding(); + case SolverLanguagePackage.CASE: return createCase(); + case SolverLanguagePackage.LOCAL_VARIABLES: return createLocalVariables(); + case SolverLanguagePackage.QUANTIFIED_EXPRESSION: return createQuantifiedExpression(); + case SolverLanguagePackage.AGGREGATION: return createAggregation(); + case SolverLanguagePackage.CALL: return createCall(); + case SolverLanguagePackage.ARGUMENT_LIST: return createArgumentList(); + case SolverLanguagePackage.ARGUMENT: return createArgument(); + case SolverLanguagePackage.EXPRESSION_ARGUMENT: return createExpressionArgument(); + case SolverLanguagePackage.STAR_ARGUMENT: return createStarArgument(); + case SolverLanguagePackage.TYPED_ARGUMENT: return createTypedArgument(); + case SolverLanguagePackage.TYPED_STAR_ARGUMENT: return createTypedStarArgument(); + case SolverLanguagePackage.REFERENCE: return createReference(); + case SolverLanguagePackage.INTERVAL: return createInterval(); + case SolverLanguagePackage.LITERAL: return createLiteral(); + case SolverLanguagePackage.LOGIC_LITERAL: return createLogicLiteral(); + case SolverLanguagePackage.NUMERIC_LITERAL: return createNumericLiteral(); + case SolverLanguagePackage.INFINITY_LITERAL: return createInfinityLiteral(); + case SolverLanguagePackage.EMPTY_INTERVAL_LITERAL: return createEmptyIntervalLiteral(); + case SolverLanguagePackage.STRING_LITERAL: return createStringLiteral(); + case SolverLanguagePackage.CLASS_DEFINITION: return createClassDefinition(); + case SolverLanguagePackage.MEMBER_DEFINITION: return createMemberDefinition(); + case SolverLanguagePackage.MULTIPLICITY: return createMultiplicity(); + case SolverLanguagePackage.MANY_MULTIPLICITY: return createManyMultiplicity(); + case SolverLanguagePackage.EXACT_MULTIPLICITY: return createExactMultiplicity(); + case SolverLanguagePackage.BOUNDED_MULTIPLICITY: return createBoundedMultiplicity(); + case SolverLanguagePackage.SCOPE_DEFINITION: return createScopeDefinition(); + case SolverLanguagePackage.EXACT_SCOPE_DEFINITION: return createExactScopeDefinition(); + case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION: return createBoundedScopeDefinition(); + case SolverLanguagePackage.LOWER_BOUNDED_SCOPE_DEFINITION: return createLowerBoundedScopeDefinition(); + case SolverLanguagePackage.OBJECTIVE_DEFINITION: return createObjectiveDefinition(); + case SolverLanguagePackage.INTERPRETATION: return createInterpretation(); + case SolverLanguagePackage.VARIABLE: return createVariable(); + case SolverLanguagePackage.DISJUNCTION: return createDisjunction(); + case SolverLanguagePackage.SWITCH: return createSwitch(); + case SolverLanguagePackage.CONJUNCTION: return createConjunction(); + case SolverLanguagePackage.COMPARISON: return createComparison(); + case SolverLanguagePackage.BINARY_EXPRESSION: return createBinaryExpression(); + case SolverLanguagePackage.CAST_EXPRESSION: return createCastExpression(); + case SolverLanguagePackage.UNARY_EXPRESSION: return createUnaryExpression(); + case SolverLanguagePackage.NODE: return createNode(); + case SolverLanguagePackage.PREDICATE: return createPredicate(); + case SolverLanguagePackage.METRIC: return createMetric(); + 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.BINARY_OPERATOR: + return createBinaryOperatorFromString(eDataType, initialValue); + case SolverLanguagePackage.UNARY_OP: + return createUnaryOpFromString(eDataType, initialValue); + case SolverLanguagePackage.LOGIC_VALUE: + return createLogicValueFromString(eDataType, initialValue); + case SolverLanguagePackage.OBJECTIVE_KIND: + return createObjectiveKindFromString(eDataType, initialValue); + case SolverLanguagePackage.QUANTIFIER: + return createQuantifierFromString(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.BINARY_OPERATOR: + return convertBinaryOperatorToString(eDataType, instanceValue); + case SolverLanguagePackage.UNARY_OP: + return convertUnaryOpToString(eDataType, instanceValue); + case SolverLanguagePackage.LOGIC_VALUE: + return convertLogicValueToString(eDataType, instanceValue); + case SolverLanguagePackage.OBJECTIVE_KIND: + return convertObjectiveKindToString(eDataType, instanceValue); + case SolverLanguagePackage.QUANTIFIER: + return convertQuantifierToString(eDataType, instanceValue); + default: + throw new IllegalArgumentException("The datatype '" + eDataType.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 PredicateDefinition createPredicateDefinition() { + PredicateDefinitionImpl predicateDefinition = new PredicateDefinitionImpl(); + return predicateDefinition; + } + + /** + * + * + * @generated + */ + @Override + public UnnamedErrorPrediateDefinition createUnnamedErrorPrediateDefinition() { + UnnamedErrorPrediateDefinitionImpl unnamedErrorPrediateDefinition = new UnnamedErrorPrediateDefinitionImpl(); + return unnamedErrorPrediateDefinition; + } + + /** + * + * + * @generated + */ + @Override + public DefaultDefinition createDefaultDefinition() { + DefaultDefinitionImpl defaultDefinition = new DefaultDefinitionImpl(); + return defaultDefinition; + } + + /** + * + * + * @generated + */ + @Override + public MetricDefinition createMetricDefinition() { + MetricDefinitionImpl metricDefinition = new MetricDefinitionImpl(); + return metricDefinition; + } + + /** + * + * + * @generated + */ + @Override + public ExternPredicateDefinition createExternPredicateDefinition() { + ExternPredicateDefinitionImpl externPredicateDefinition = new ExternPredicateDefinitionImpl(); + return externPredicateDefinition; + } + + /** + * + * + * @generated + */ + @Override + public ExternMetricDefinition createExternMetricDefinition() { + ExternMetricDefinitionImpl externMetricDefinition = new ExternMetricDefinitionImpl(); + return externMetricDefinition; + } + + /** + * + * + * @generated + */ + @Override + public ExternAggregatorDefinition createExternAggregatorDefinition() { + ExternAggregatorDefinitionImpl externAggregatorDefinition = new ExternAggregatorDefinitionImpl(); + return externAggregatorDefinition; + } + + /** + * + * + * @generated + */ + @Override + public ExternDatatypeDefinition createExternDatatypeDefinition() { + ExternDatatypeDefinitionImpl externDatatypeDefinition = new ExternDatatypeDefinitionImpl(); + return externDatatypeDefinition; + } + + /** + * + * + * @generated + */ + @Override + public NamedElement createNamedElement() { + NamedElementImpl namedElement = new NamedElementImpl(); + return namedElement; + } + + /** + * + * + * @generated + */ + @Override + public IfElse createIfElse() { + IfElseImpl ifElse = new IfElseImpl(); + return ifElse; + } + + /** + * + * + * @generated + */ + @Override + public Let createLet() { + LetImpl let = new LetImpl(); + return let; + } + + /** + * + * + * @generated + */ + @Override + public LetBinding createLetBinding() { + LetBindingImpl letBinding = new LetBindingImpl(); + return letBinding; + } + + /** + * + * + * @generated + */ + @Override + public Case createCase() { + CaseImpl case_ = new CaseImpl(); + return case_; + } + + /** + * + * + * @generated + */ + @Override + public LocalVariables createLocalVariables() { + LocalVariablesImpl localVariables = new LocalVariablesImpl(); + return localVariables; + } + + /** + * + * + * @generated + */ + @Override + public QuantifiedExpression createQuantifiedExpression() { + QuantifiedExpressionImpl quantifiedExpression = new QuantifiedExpressionImpl(); + return quantifiedExpression; + } + + /** + * + * + * @generated + */ + @Override + public Aggregation createAggregation() { + AggregationImpl aggregation = new AggregationImpl(); + return aggregation; + } + + /** + * + * + * @generated + */ + @Override + public Call createCall() { + CallImpl call = new CallImpl(); + return call; + } + + /** + * + * + * @generated + */ + @Override + public ArgumentList createArgumentList() { + ArgumentListImpl argumentList = new ArgumentListImpl(); + return argumentList; + } + + /** + * + * + * @generated + */ + @Override + public Argument createArgument() { + ArgumentImpl argument = new ArgumentImpl(); + return argument; + } + + /** + * + * + * @generated + */ + @Override + public ExpressionArgument createExpressionArgument() { + ExpressionArgumentImpl expressionArgument = new ExpressionArgumentImpl(); + return expressionArgument; + } + + /** + * + * + * @generated + */ + @Override + public StarArgument createStarArgument() { + StarArgumentImpl starArgument = new StarArgumentImpl(); + return starArgument; + } + + /** + * + * + * @generated + */ + @Override + public TypedArgument createTypedArgument() { + TypedArgumentImpl typedArgument = new TypedArgumentImpl(); + return typedArgument; + } + + /** + * + * + * @generated + */ + @Override + public TypedStarArgument createTypedStarArgument() { + TypedStarArgumentImpl typedStarArgument = new TypedStarArgumentImpl(); + return typedStarArgument; + } + + /** + * + * + * @generated + */ + @Override + public Reference createReference() { + ReferenceImpl reference = new ReferenceImpl(); + return reference; + } + + /** + * + * + * @generated + */ + @Override + public Interval createInterval() { + IntervalImpl interval = new IntervalImpl(); + return interval; + } + + /** + * + * + * @generated + */ + @Override + public Literal createLiteral() { + LiteralImpl literal = new LiteralImpl(); + return literal; + } + + /** + * + * + * @generated + */ + @Override + public LogicLiteral createLogicLiteral() { + LogicLiteralImpl logicLiteral = new LogicLiteralImpl(); + return logicLiteral; + } + + /** + * + * + * @generated + */ + @Override + public NumericLiteral createNumericLiteral() { + NumericLiteralImpl numericLiteral = new NumericLiteralImpl(); + return numericLiteral; + } + + /** + * + * + * @generated + */ + @Override + public InfinityLiteral createInfinityLiteral() { + InfinityLiteralImpl infinityLiteral = new InfinityLiteralImpl(); + return infinityLiteral; + } + + /** + * + * + * @generated + */ + @Override + public EmptyIntervalLiteral createEmptyIntervalLiteral() { + EmptyIntervalLiteralImpl emptyIntervalLiteral = new EmptyIntervalLiteralImpl(); + return emptyIntervalLiteral; + } + + /** + * + * + * @generated + */ + @Override + public StringLiteral createStringLiteral() { + StringLiteralImpl stringLiteral = new StringLiteralImpl(); + return stringLiteral; + } + + /** + * + * + * @generated + */ + @Override + public ClassDefinition createClassDefinition() { + ClassDefinitionImpl classDefinition = new ClassDefinitionImpl(); + return classDefinition; + } + + /** + * + * + * @generated + */ + @Override + public MemberDefinition createMemberDefinition() { + MemberDefinitionImpl memberDefinition = new MemberDefinitionImpl(); + return memberDefinition; + } + + /** + * + * + * @generated + */ + @Override + public Multiplicity createMultiplicity() { + MultiplicityImpl multiplicity = new MultiplicityImpl(); + return multiplicity; + } + + /** + * + * + * @generated + */ + @Override + public ManyMultiplicity createManyMultiplicity() { + ManyMultiplicityImpl manyMultiplicity = new ManyMultiplicityImpl(); + return manyMultiplicity; + } + + /** + * + * + * @generated + */ + @Override + public ExactMultiplicity createExactMultiplicity() { + ExactMultiplicityImpl exactMultiplicity = new ExactMultiplicityImpl(); + return exactMultiplicity; + } + + /** + * + * + * @generated + */ + @Override + public BoundedMultiplicity createBoundedMultiplicity() { + BoundedMultiplicityImpl boundedMultiplicity = new BoundedMultiplicityImpl(); + return boundedMultiplicity; + } + + /** + * + * + * @generated + */ + @Override + public ScopeDefinition createScopeDefinition() { + ScopeDefinitionImpl scopeDefinition = new ScopeDefinitionImpl(); + return scopeDefinition; + } + + /** + * + * + * @generated + */ + @Override + public ExactScopeDefinition createExactScopeDefinition() { + ExactScopeDefinitionImpl exactScopeDefinition = new ExactScopeDefinitionImpl(); + return exactScopeDefinition; + } + + /** + * + * + * @generated + */ + @Override + public BoundedScopeDefinition createBoundedScopeDefinition() { + BoundedScopeDefinitionImpl boundedScopeDefinition = new BoundedScopeDefinitionImpl(); + return boundedScopeDefinition; + } + + /** + * + * + * @generated + */ + @Override + public LowerBoundedScopeDefinition createLowerBoundedScopeDefinition() { + LowerBoundedScopeDefinitionImpl lowerBoundedScopeDefinition = new LowerBoundedScopeDefinitionImpl(); + return lowerBoundedScopeDefinition; + } + + /** + * + * + * @generated + */ + @Override + public ObjectiveDefinition createObjectiveDefinition() { + ObjectiveDefinitionImpl objectiveDefinition = new ObjectiveDefinitionImpl(); + return objectiveDefinition; + } + + /** + * + * + * @generated + */ + @Override + public Interpretation createInterpretation() { + InterpretationImpl interpretation = new InterpretationImpl(); + return interpretation; + } + + /** + * + * + * @generated + */ + @Override + public Variable createVariable() { + VariableImpl variable = new VariableImpl(); + return variable; + } + + /** + * + * + * @generated + */ + @Override + public Disjunction createDisjunction() { + DisjunctionImpl disjunction = new DisjunctionImpl(); + return disjunction; + } + + /** + * + * + * @generated + */ + @Override + public Switch createSwitch() { + SwitchImpl switch_ = new SwitchImpl(); + return switch_; + } + + /** + * + * + * @generated + */ + @Override + public Conjunction createConjunction() { + ConjunctionImpl conjunction = new ConjunctionImpl(); + return conjunction; + } + + /** + * + * + * @generated + */ + @Override + public Comparison createComparison() { + ComparisonImpl comparison = new ComparisonImpl(); + return comparison; + } + + /** + * + * + * @generated + */ + @Override + public BinaryExpression createBinaryExpression() { + BinaryExpressionImpl binaryExpression = new BinaryExpressionImpl(); + return binaryExpression; + } + + /** + * + * + * @generated + */ + @Override + public CastExpression createCastExpression() { + CastExpressionImpl castExpression = new CastExpressionImpl(); + return castExpression; + } + + /** + * + * + * @generated + */ + @Override + public UnaryExpression createUnaryExpression() { + UnaryExpressionImpl unaryExpression = new UnaryExpressionImpl(); + return unaryExpression; + } + + /** + * + * + * @generated + */ + @Override + public Node createNode() { + NodeImpl node = new NodeImpl(); + return node; + } + + /** + * + * + * @generated + */ + @Override + public Predicate createPredicate() { + PredicateImpl predicate = new PredicateImpl(); + return predicate; + } + + /** + * + * + * @generated + */ + @Override + public Metric createMetric() { + MetricImpl metric = new MetricImpl(); + return metric; + } + + /** + * + * + * @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 UnaryOp createUnaryOpFromString(EDataType eDataType, String initialValue) { + UnaryOp result = UnaryOp.get(initialValue); + if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); + return result; + } + + /** + * + * + * @generated + */ + public String convertUnaryOpToString(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 Quantifier createQuantifierFromString(EDataType eDataType, String initialValue) { + Quantifier result = Quantifier.get(initialValue); + if (result == null) throw new IllegalArgumentException("The value '" + initialValue + "' is not a valid enumerator of '" + eDataType.getName() + "'"); + return result; + } + + /** + * + * + * @generated + */ + public String convertQuantifierToString(EDataType eDataType, Object instanceValue) { + return instanceValue == null ? null : instanceValue.toString(); + } + + /** + * + * + * @generated + */ + @Override + public SolverLanguagePackage getSolverLanguagePackage() { + return (SolverLanguagePackage)getEPackage(); + } + + /** + * + * + * @deprecated + * @generated + */ + @Deprecated + public static SolverLanguagePackage getPackage() { + return SolverLanguagePackage.eINSTANCE; + } + +} //SolverLanguageFactoryImpl -- cgit v1.2.3-54-g00ecf