public static TriggerExpression Parse(Metamodel metaModel, string expressionText) { try { if (FullMatch(Syntax.EmptyCondition, expressionText) != null) { return(null); } if (FullMatch(Syntax.Condition, expressionText) != null) { return(ConditionExpression.Parse(metaModel, expressionText)); } if (FullMatch(Syntax.Unary, expressionText) != null) { return(UnaryExpression.Parse(metaModel, expressionText)); } if (FullMatch(Syntax.Nary, expressionText) != null) { return(NaryExpression.Parse(metaModel, expressionText)); } throw new Exception($"Unmatched {nameof(TriggerExpression)} {expressionText}"); } catch (Exception e) { throw new ApplicationException("Parsing Error", e); } }
public static ActionsExpression Parse(Metamodel metaModel, string expressionText) { try { // Empty actions if (FullMatch(Syntax.EmptyAction, expressionText) != null) { return(new ActionsExpression(new List <ActionExpression>())); } // List of 1 or more Action if (FullMatch(Syntax.Actions, expressionText) != null) { List <ActionExpression> actionExpressions = new List <ActionExpression>(); expressionText.Split(Syntax.ActionSeparator) .ToList() .ForEach(actionExpressionText => { actionExpressions.Add(ActionExpression.Parse(metaModel, actionExpressionText)); }); return(new ActionsExpression(actionExpressions)); } throw new ApplicationException($"Unmatched {nameof(ActionExpression)}"); } catch (Exception e) { throw new ApplicationException("Parsing Error", e); } }
public new static NaryExpression Parse(Metamodel metaModel, string expressionText) { BinaryOperator @operator; Match match; if ((match = FullMatch(Syntax.And, expressionText)) != null) { @operator = BinaryOperator.And; } else if ((match = FullMatch(Syntax.Or, expressionText)) != null) { @operator = BinaryOperator.Or; } else { throw new Exception($"Unmatched binary operator expression {expressionText}"); } var matchGroup = match.Groups[1]; // Split the sub-clauses, mindful of nested sub-expression List <TriggerExpression> subClauses = new List <TriggerExpression>(); string parametersText = matchGroup.Value[1..^ 1];
// Handle - e.g Boolean:True internal static Parameter Parse(Metamodel metaModel, EnumParameterTypeMapping enumParameterTypeMapping, string parameterText) { string[] parameterElements = parameterText.Split(Syntax.ParameterQualifier); if (parameterElements.Length != 3) { throw new Exception($"Invalid Name:Type:Value format Parameter Value {parameterText}"); } string name = parameterElements[0]; ScriptType type; if (!Enum.TryParse <ScriptType>(parameterElements[1], out type)) { throw new Exception($"Unknown Parameter Type {parameterElements[1]} - {parameterText}"); } string valueText = parameterElements[2]; dynamic value = null; switch (type) { case ScriptType.Boolean: bool boolValue; if (!Boolean.TryParse(valueText, out boolValue)) { throw new ApplicationException($"Invalid {nameof(Boolean)} value {valueText}"); } value = boolValue; break; case ScriptType.Int32: int intValue; if (!Int32.TryParse(valueText, out intValue)) { throw new ApplicationException($"Invalid {nameof(Int32)} value {valueText}"); } value = intValue; break; case ScriptType.Double: double doubleValue; if (!Double.TryParse(valueText, out doubleValue)) { throw new ApplicationException($"Invalid {nameof(Double)} value {valueText}"); } value = doubleValue; break; case ScriptType.String: if (valueText.Length < 2 || valueText[0] != Syntax.StringQuotation || valueText[^ 1] != Syntax.StringQuotation) { throw new Exception($"Unquoted string {nameof(Parameter)} {valueText}"); } // Remove leading and trailing " chars value = valueText[1..^ 1];
protected override IReflector Reflector(Metamodel metamodel, ILoggerFactory lf) { var config = new CoreConfiguration(); ClassStrategy = new SystemTypeClassStrategy(config); var systemTypeFacetFactorySet = new SystemTypeFacetFactorySet(FacetFactories.OfType <IObjectFacetFactoryProcessor>()); var mockLogger1 = new Mock <ILogger <AbstractParallelReflector> >().Object; return(new SystemTypeReflector(systemTypeFacetFactorySet, (SystemTypeClassStrategy)ClassStrategy, metamodel, config, new IFacetDecorator[] { }, lf, mockLogger1)); }
protected virtual IReflector Reflector(Metamodel metamodel, ILoggerFactory lf) { var config = new ObjectReflectorConfiguration(new[] { typeof(TestPoco), typeof(TestDomainObject), typeof(ArrayList) }, new Type[] { }); var objectFactFactorySet = new ObjectFacetFactorySet(FacetFactories.OfType <IObjectFacetFactoryProcessor>().ToArray()); ClassStrategy = new ObjectClassStrategy(config); var mockLogger1 = new Mock <ILogger <AbstractParallelReflector> >().Object; return(new ObjectReflector(objectFactFactorySet, (ObjectClassStrategy)ClassStrategy, metamodel, config, new IFacetDecorator[] { }, lf, mockLogger1)); }
public new static UnaryExpression Parse(Metamodel metaModel, string expressionText) { Match match = FullMatch(Syntax.Unary, expressionText); if (match == null) { throw new Exception($"Unmatched {nameof(UnaryExpression)} {expressionText}"); } var matchGroup = match.Groups[1]; string subExpressionText = matchGroup.Value[1..^ 1];
public virtual void SetUp() { var cache = new ImmutableInMemorySpecCache(); var config = new ReflectorConfiguration(new[] { typeof(List <TestPoco>), typeof(ArrayList) }, new Type[] { }, new Type[] { }, new Type[] { }, new[] { typeof(TestPoco).Namespace }); var menuFactory = new NullMenuFactory(); var classStrategy = new DefaultClassStrategy(config); var metamodel = new Metamodel(classStrategy, cache); var reflector = new Reflector(classStrategy, metamodel, config, menuFactory, new IFacetDecorator[] { }, facetFactories); Specification = LoadSpecification(reflector); Metamodel = metamodel; }
public static MethodNameExpression Parse(Metamodel metaModel, string expressionText) { Match methodNameMatch = FullMatch(MethodNameRegularExpression, expressionText); if (methodNameMatch == null) { throw new Exception($"Parsing Error {nameof(MethodNameExpression)} {expressionText}"); } ; return(new MethodNameExpression(methodNameMatch.Groups[1].Value, methodNameMatch.Groups[2].Value)); }
public override void SetUp() { base.SetUp(); var cache = new ImmutableInMemorySpecCache(); var reflectorConfiguration = new ReflectorConfiguration(new Type[] { }, new Type[] { }, new Type[] { }, new Type[] { }, new string[] { }); facetFactory = new RemoveEventHandlerMethodsFacetFactory(0); var menuFactory = new NullMenuFactory(); var classStrategy = new DefaultClassStrategy(reflectorConfiguration); var metamodel = new Metamodel(classStrategy, cache); Reflector = new Reflector(classStrategy, metamodel, reflectorConfiguration, menuFactory, new IFacetDecorator[] {}, new IFacetFactory[] { facetFactory }); }
// e.g. CaseId:Int32:1,IncludeInactive:Boolean:True internal static Parameters Parse(Metamodel metaModel, EnumParameterTypeMapping enumParameterTypeMapping, string expressionText) { Parameters parameters = new Parameters(); if (!string.IsNullOrWhiteSpace(expressionText)) { Split(expressionText).ForEach(parameterText => { parameters.Add(Parameter.Parse(metaModel, enumParameterTypeMapping, parameterText)); }); } return(parameters); }
public override void SetUp() { base.SetUp(); var cache = new ImmutableInMemorySpecCache(); var config = new ReflectorConfiguration(new Type[] { }, new Type[] { }, new Type[] { }, new Type[] { }, new[] { typeof(Customer).Namespace }); var menuFactory = new NullMenuFactory(); facetFactory = new UnsupportedMethodFilteringFactory(0); var classStrategy = new DefaultClassStrategy(config); var metamodel = new Metamodel(classStrategy, cache); Reflector = new Reflector(classStrategy, metamodel, config, menuFactory, new IFacetDecorator[] {}, new IFacetFactory[] { facetFactory }); }
internal static object Parse(Metamodel metaModel, string stringExpression) { if (FullMatch(Syntax.Rule, stringExpression) == null) { throw new Exception($"Unmatched {nameof(RuleExpression)} {stringExpression}"); } var subClauses = stringExpression.Split(Syntax.Implies); TriggerExpression triggerExpression = TriggerExpression.Parse(metaModel, subClauses[0]); ActionsExpression actionsExpression = ActionsExpression.Parse(metaModel, subClauses[1]); return(new RuleExpression(triggerExpression, actionsExpression)); }
public new static ConditionExpression Parse(Metamodel metaModel, string expressionText) { var groupedMatches = Syntax.Condition.Matches(expressionText)[0].Groups; // e.g - Func.GreaterThan:Int32:1,Logic.IsTrue:Boolean:True string methodNameText = groupedMatches[1].Value; string parametersText = groupedMatches[5].Value; MethodMapping methodMapping = metaModel.Conditions[methodNameText]; MethodNameExpression methodNameExpression = MethodNameExpression.Parse(metaModel, methodNameText); Parameters parameters = Parameters.Parse(metaModel, methodMapping.EnumParameterTypes, parametersText); return(new ConditionExpression(methodNameExpression, parameters)); }
public static ActionExpression Parse(Metamodel metaModel, string expressionText) { Match match = FullMatch(Syntax.Action, expressionText); if (match == null) { throw new Exception($"Unmatched {nameof(ActionExpression)} {expressionText}"); } ; MethodNameExpression methodNameExpression = MethodNameExpression.Parse(metaModel, match.Groups[1].Value); MethodMapping methodMapping = metaModel.Actions[methodNameExpression.ToString()]; Parameters parameters = Parameters.Parse(metaModel, methodMapping.EnumParameterTypes, match.Groups[5].Value); return(new ActionExpression(methodNameExpression, parameters)); }
public override void SetUp() { base.SetUp(); var cache = new ImmutableInMemorySpecCache(); ReflectorConfiguration.NoValidate = true; var reflectorConfiguration = new ReflectorConfiguration(new Type[] { }, new Type[] { }, new string[] { }); facetFactory = new RemoveIgnoredMethodsFacetFactory(0, LoggerFactory); var menuFactory = new NullMenuFactory(); var classStrategy = new DefaultClassStrategy(reflectorConfiguration); var metamodel = new Metamodel(classStrategy, cache, null); var mockLogger = new Mock <ILogger <Reflector> >().Object; var mockLoggerFactory = new Mock <ILoggerFactory>().Object; Reflector = new Reflector(classStrategy, metamodel, reflectorConfiguration, menuFactory, new IFacetDecorator[] { }, new IFacetFactory[] { facetFactory }, mockLoggerFactory, mockLogger); }
public virtual void SetUp() { var cache = new ImmutableInMemorySpecCache(); ReflectorConfiguration.NoValidate = true; var config = new ReflectorConfiguration(new[] { typeof(List <TestPoco>), typeof(ArrayList) }, new Type[] { }, new[] { typeof(TestPoco).Namespace }); var menuFactory = new NullMenuFactory(); var classStrategy = new DefaultClassStrategy(config); var mockLogger = new Mock <ILogger <Metamodel> >().Object; var metamodel = new Metamodel(classStrategy, cache, mockLogger); var mockLogger1 = new Mock <ILogger <Reflector> >().Object; var mockLoggerFactory = new Mock <ILoggerFactory>().Object; var reflector = new Reflector(classStrategy, metamodel, config, menuFactory, new IFacetDecorator[] { }, facetFactories, mockLoggerFactory, mockLogger1); Specification = LoadSpecification(reflector); Metamodel = metamodel; }
public override void SetUp() { base.SetUp(); var cache = new ImmutableInMemorySpecCache(); ObjectReflectorConfiguration.NoValidate = true; var reflectorConfiguration = new ObjectReflectorConfiguration(new Type[] { }, new Type[] { }); facetFactory = new RemoveIgnoredMethodsFacetFactory(GetOrder <RemoveIgnoredMethodsFacetFactory>(), LoggerFactory); var objectFactFactorySet = new ObjectFacetFactorySet(new IObjectFacetFactoryProcessor[] { facetFactory }); var classStrategy = new ObjectClassStrategy(reflectorConfiguration); var metamodel = new Metamodel(cache, null); var mockLogger = new Mock <ILogger <AbstractParallelReflector> >().Object; var mockLoggerFactory = new Mock <ILoggerFactory>().Object; Reflector = new ObjectReflector(objectFactFactorySet, classStrategy, metamodel, reflectorConfiguration, new IFacetDecorator[] { }, mockLoggerFactory, mockLogger); }
public override void SetUp() { base.SetUp(); var cache = new ImmutableInMemorySpecCache(); ReflectorConfiguration.NoValidate = true; var config = new ReflectorConfiguration(new Type[] { }, new Type[] { }, new[] { typeof(Customer).Namespace }); var menuFactory = new NullMenuFactory(); facetFactory = new SystemClassMethodFilteringFactory(0, LoggerFactory); var classStrategy = new DefaultClassStrategy(config); var metamodel = new Metamodel(classStrategy, cache, null); var mockLogger = new Mock <ILogger <Reflector> >().Object; var mockLoggerFactory = new Mock <ILoggerFactory>().Object; Reflector = new Reflector(classStrategy, metamodel, config, menuFactory, new IFacetDecorator[] { }, new IFacetFactory[] { facetFactory }, mockLoggerFactory, mockLogger); }
private void okButton_Click(object sender, EventArgs e) { if (this.selectedSourceMetamodel != null && this.selectedTargetMetamodel != null) { //create rule package if (newTGGProject.Packages.Count == 0) { EA.Package rulesPackage = newTGGProject.getRealPackage().Packages.AddNew("Rules", TGGModelingMain.TggRulePackageStereotype) as EA.Package; rulesPackage.Update(); TGGRulePackage rPackage = new TGGRulePackage(repository.GetPackageByID(rulesPackage.PackageID), repository); rPackage.saveTreeToEATaggedValue(true); EA.Diagram rulesDiagram = rulesPackage.Diagrams.AddNew("Rules", TGGModelingMain.TggRulesDiagramMetatype[0]) as EA.Diagram; rulesDiagram.Update(); newTGGProject.Packages.Refresh(); } Metamodel sourceMetamodel = new Metamodel(repository, this.selectedSourceMetamodel); Metamodel targetMetamodel = new Metamodel(repository, this.selectedTargetMetamodel); Metamodel correspondenceMetamodel = new Metamodel(repository, repository.GetPackageByID(newTGGProject.PackageID)); Domain sourceDomain = new Domain(sourceMetamodel, DomainType.SOURCE); Domain targetDomain = new Domain(targetMetamodel, DomainType.TARGET); Domain correspondenceDomain = new Domain(correspondenceMetamodel, DomainType.CORRESPONDENCE); tgg.Metamodels.Clear(); tgg.Domains.Clear(); tgg.Metamodels.Add(sourceMetamodel); tgg.Metamodels.Add(targetMetamodel); tgg.Metamodels.Add(correspondenceMetamodel); tgg.Domains.Add(sourceDomain); tgg.Domains.Add(targetDomain); tgg.Domains.Add(correspondenceDomain); tgg.EaPackage.getRealPackage().Name = textBoxName.Text; tgg.saveTreeToEATaggedValue(true); Close(); } }
public virtual void SetUp() { var cache = new ImmutableInMemorySpecCache(); ObjectReflectorConfiguration.NoValidate = true; var mockLogger = new Mock <ILogger <Metamodel> >().Object; var metamodel = new Metamodel(cache, mockLogger); var mockLoggerFactory = new Mock <ILoggerFactory>().Object; var reflector = Reflector(metamodel, mockLoggerFactory); ITypeSpecBuilder spec; (spec, Metamodel) = LoadSpecification(reflector); Specification = spec as IObjectSpecImmutable; }
public void Save(SaveModelType type) { switch (type) { case SaveModelType.MetamodelData: var strJson0 = Metamodel.ToString(Formatting.Indented); strJson0.FixBomIfNeeded(); StringUtilities.WriteAllTextNoBom(_metamodelPath, strJson0, out _); break; case SaveModelType.OccData: Occ.Save(); break; case SaveModelType.RouteData: var strJson2 = Routes.ToString(Formatting.Indented); strJson2.FixBomIfNeeded(); StringUtilities.WriteAllTextNoBom(_routePath, strJson2, out _); break; case SaveModelType.LocomotivesData: var strJson3 = LocomotivesData.ToJsonString(); strJson3.FixBomIfNeeded(); StringUtilities.WriteAllTextNoBom(LocomotivesData.LocomotivesPath, strJson3, out _); break; case SaveModelType.FeedbacksData: var strJson4 = FeedbacksData.ToJsonString(); strJson4.FixBomIfNeeded(); StringUtilities.WriteAllTextNoBom(FeedbacksData.FeedbacksPath, strJson4, out _); break; case SaveModelType.LocomotivesDurationsData: var strJson5 = LocomotivesDurationData.ToJsonString(); strJson5.FixBomIfNeeded(); StringUtilities.WriteAllTextNoBom(LocomotivesDurationData.DurationsPath, strJson5, out _); break; } }
private IList <IActionSpecImmutable> ActionsForType(Type type) => Metamodel.GetSpecification(type).ObjectActions.ToList();