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();
