/** */ 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