public override SequenceFilterCallBase CreateSequenceMatchClassFilterCall(String matchClassName, String matchClassPackage,
String packagePrefix, String filterBase, List <String> entities,
SequenceVariable initArrayAccess, SequenceExpression initExpr,
SequenceVariable arrayAccess, SequenceVariable previousAccumulationAccess,
SequenceVariable index, SequenceVariable element, SequenceExpression lambdaExpr)
{
String packagePrefixedMatchClassName = matchClassPackage != null ? matchClassPackage + "::" + matchClassName : matchClassName; // no (further) resolving of match classes in interpreted sequences cause there is no package context existing
MatchClassFilterer matchClass = actions.GetMatchClass(packagePrefixedMatchClassName); // may be null, match class is part of filter call, was not checked before
if (matchClass == null)
{
throw new SequenceParserException(packagePrefixedMatchClassName, packagePrefixedMatchClassName + "." + filterBase, SequenceParserError.MatchClassError);
}
String filterName = GetFilterName(filterBase, entities);
String packagePrefixedName = filterName;
if (entities.Count == 1 && filterBase == "assignStartWithAccumulateBy")
{
return(new SequenceFilterCallLambdaExpressionInterpreted(matchClass, filterBase, entities[0],
initArrayAccess, initExpr,
arrayAccess, previousAccumulationAccess, index, element, lambdaExpr));
}
else
{
throw new SequenceParserException(packagePrefixedMatchClassName, packagePrefixedName, SequenceParserError.FilterError);
}
}
public override SequenceFilterCallBase CreateSequenceMatchClassFilterCall(String matchClassName, String matchClassPackage,
String packagePrefix, String filterBase, List <String> entities,
SequenceVariable initArrayAccess, SequenceExpression initExpr,
SequenceVariable arrayAccess, SequenceVariable previousAccumulationAccess,
SequenceVariable index, SequenceVariable element, SequenceExpression lambdaExpr)
{
String resolvedMatchClassPackage; // match class not yet resolved (impossible before as only part of filter call), resolve it here
String packagePrefixedMatchClassName;
bool contextMatchClassNameExists = actionNames.matchClassesToFilters.ContainsKey(PackagePrefixedName(matchClassName, packageContext));
ResolvePackage(matchClassName, matchClassPackage, packageContext, contextMatchClassNameExists,
out resolvedMatchClassPackage, out packagePrefixedMatchClassName);
if (!actionNames.ContainsMatchClass(packagePrefixedMatchClassName))
{
throw new SequenceParserException(packagePrefixedMatchClassName, packagePrefixedMatchClassName + "." + filterBase, SequenceParserError.MatchClassError);
}
String filterName = GetFilterName(filterBase, entities);
String packagePrefixedName = filterName;
if (entities.Count == 1 && filterBase == "assignStartWithAccumulateBy")
{
return(new SequenceFilterCallLambdaExpressionCompiled(matchClassName, resolvedMatchClassPackage, packagePrefixedMatchClassName,
filterBase, entities[0],
initArrayAccess, initExpr,
arrayAccess, previousAccumulationAccess, index, element, lambdaExpr));
}
else
{
throw new SequenceParserException(packagePrefixedMatchClassName, packagePrefixedName, SequenceParserError.FilterError);
}
}
public SH_ObjectSequence(IStream element, int index, eTypeObjectCollection typeCollection, string text)
: base(element, index, typeCollection)
{
string @string = text.Trim();
if (@string.StartsWith("="))
{
@string = @string.Substring(1).Trim();
if (DoubleValue.IsCheck(@string))
{
Value = new DoubleValue(@string);
}
else if (CheckedVariableName(ref @string))
{
Variable = new SequenceVariable(@string, new DoubleValue(0), new DoubleValue(-100), new DoubleValue(100), null);
}
else
{
Type = eTypeObjectStream.Default;
}
}
else if (DoubleValue.IsCheck(@string))
{
Value = new DoubleValue(@string);
}
else if (CheckedTableName(ref @string))
{
Table = new GradientWaveformTableSequence(this, @string);
}
else
{
Type = eTypeObjectStream.Default;
}
}
/// <summary>
/// Emit variable declarations needed (only once for every variable)
/// </summary>
private void EmitVarIfNew(SequenceVariable var, SourceBuilder source)
{
if (!var.Visited)
{
var.Visited = true;
source.AppendFront(seqHelper.DeclareVar(var));
}
}
/// <summary>
/// Returns string containing a C# expression to get the value of the sequence-local variable / graph-global variable given
/// </summary>
public string GetVar(SequenceVariable seqVar)
{
if (seqVar.Type == "")
{
return("procEnv.GetVariableValue(\"" + seqVar.PureName + "\")");
}
else
{
return("var_" + seqVar.Prefix + seqVar.PureName);
}
}
/// <summary>
/// Returns string containing a C# assignment to set the sequence-local variable / graph-global variable given
/// to the value as computed by the C# expression in the string given
/// </summary>
public string SetVar(SequenceVariable seqVar, String valueToWrite)
{
if (seqVar.Type == "")
{
return("procEnv.SetVariableValue(\"" + seqVar.PureName + "\", " + valueToWrite + ");\n");
}
else
{
String cast = "(" + TypesHelper.XgrsTypeToCSharpType(seqVar.Type, model) + ")";
return("var_" + seqVar.Prefix + seqVar.PureName + " = " + cast + "(" + valueToWrite + ");\n");
}
}
public O1_ObjectSequence(IStream element, int index, eTypeObjectCollection typeCollection, string text)
: base(element, index, typeCollection)
{
string @string = text.Trim();
if (typeCollection == eTypeObjectCollection._1D)
{
if (@string.StartsWith("="))
{
@string = @string.Substring(1).Trim();
if (FrequencyValue.IsCheck(@string))
{
Value = new FrequencyValue(@string);
}
else if (CheckedVariableName(ref @string))
{
Variable = new SequenceVariable(@string, new FrequencyValue(0));
}
else
{
Type = eTypeObjectStream.Default;
}
}
else if (FrequencyValue.IsCheck(@string))
{
Value = new FrequencyValue(@string);
}
else if (CheckedTableName(ref @string))
{
Table = new FrequencyTableSequence(this, @string);
}
else
{
Type = eTypeObjectStream.Default;
}
}
else
{
if (CheckedTableName(ref @string))
{
Table = new FrequencyTableSequence(this, @string);
}
else
{
Type = eTypeObjectStream.Default;
}
}
}
/// <summary>
/// Returns string containing a C# declaration of the variable given
/// </summary>
public string DeclareVar(SequenceVariable seqVar)
{
if (seqVar.Type != "")
{
StringBuilder sb = new StringBuilder();
sb.Append(TypesHelper.XgrsTypeToCSharpType(seqVar.Type, model));
sb.Append(" ");
sb.Append("var_" + seqVar.Prefix + seqVar.PureName);
sb.Append(" = ");
sb.Append(TypesHelper.DefaultValueString(seqVar.Type, model));
sb.Append(";\n");
return(sb.ToString());
}
else
{
return("");
}
}
public override SequenceFilterCallBase CreateSequenceFilterCall(String ruleName, String rulePackage,
String packagePrefix, String filterBase, List <String> entities,
SequenceVariable initArrayAccess, SequenceExpression initExpr,
SequenceVariable arrayAccess, SequenceVariable previousAccumulationAccess,
SequenceVariable index, SequenceVariable element, SequenceExpression lambdaExpr)
{
String packagePrefixedRuleName = rulePackage != null ? rulePackage + "::" + ruleName : ruleName; // rulePackage already resolved, concatenation sufficient
String filterName = GetFilterName(filterBase, entities);
String packagePrefixedName = filterName;
if (entities.Count == 1 && filterBase == "assignStartWithAccumulateBy")
{
return(new SequenceFilterCallLambdaExpressionCompiled(filterBase, entities[0],
initArrayAccess, initExpr,
arrayAccess, previousAccumulationAccess, index, element, lambdaExpr));
}
else
{
throw new SequenceParserException(packagePrefixedRuleName, filterName, SequenceParserError.FilterError);
}
}
public override SequenceFilterCallBase CreateSequenceFilterCall(String ruleName, String rulePackage,
String packagePrefix, String filterBase, List <String> entities,
SequenceVariable initArrayAccess, SequenceExpression initExpr,
SequenceVariable arrayAccess, SequenceVariable previousAccumulationAccess,
SequenceVariable index, SequenceVariable element, SequenceExpression lambdaExpr)
{
String packagePrefixedRuleName = !PackageIsNullOrGlobal(rulePackage) ? rulePackage + "::" + ruleName : ruleName; // no (further) resolving of rules in interpreted sequences cause there is no package context existing
IAction action = actions.GetAction(packagePrefixedRuleName); // must be not null due to preceeding checks of rule call resolving result
String filterName = GetFilterName(filterBase, entities);
String packagePrefixedName = filterName;
if (entities.Count == 1 && filterBase == "assignStartWithAccumulateBy")
{
return(new SequenceFilterCallLambdaExpressionInterpreted(/*action, */ filterBase, entities[0],
initArrayAccess, initExpr,
arrayAccess, previousAccumulationAccess, index, element, lambdaExpr));
}
else
{
throw new SequenceParserException(action.PackagePrefixedName, packagePrefixedName, SequenceParserError.FilterError);
}
}
public override SequenceRuleCountAllCall CreateSequenceRuleCountAllCall(String ruleName, String packagePrefix,
List <SequenceExpression> argExprs, List <SequenceVariable> returnVars, SequenceVariable subgraph,
bool special, bool test)
{
String package;
String packagePrefixedName;
ResolvePackage(ruleName, packagePrefix, packageContext, actionNames.ContainsRule(PackagePrefixedName(ruleName, packageContext)),
out package, out packagePrefixedName);
if (!actionNames.ContainsRule(packagePrefixedName))
{
throw new SequenceParserException(packagePrefixedName, DefinitionType.Action, SequenceParserError.UnknownRuleOrSequence);
}
SequenceRuleCountAllCall seqRuleCountAllCall = new SequenceRuleCountAllCallCompiled(ruleName, package, packagePrefixedName,
argExprs, returnVars, subgraph,
special, test);
return(seqRuleCountAllCall);
}
public override SequenceRuleAllCall CreateSequenceRuleAllCall(String ruleName, String packagePrefix,
List <SequenceExpression> argExprs, List <SequenceVariable> returnVars, SequenceVariable subgraph,
bool special, bool test,
bool chooseRandom, SequenceVariable varChooseRandom,
bool chooseRandom2, SequenceVariable varChooseRandom2, bool choice)
{
String packagePrefixedName = !PackageIsNullOrGlobal(packagePrefix) ? packagePrefix + "::" + ruleName : ruleName;
IAction action = actions.GetAction(packagePrefixedName);
if (action == null)
{
throw new SequenceParserException(packagePrefixedName, DefinitionType.Action, SequenceParserError.UnknownRuleOrSequence);
}
return(new SequenceRuleAllCallInterpreted(action,
argExprs, returnVars, subgraph,
special, test,
chooseRandom, varChooseRandom,
chooseRandom2, varChooseRandom2, choice));
}
public override SequenceSequenceCall CreateSequenceSequenceCall(String sequenceName, String packagePrefix,
List <SequenceExpression> argExprs, List <SequenceVariable> returnVars, SequenceVariable subgraph,
bool special)
{
String packagePrefixedName = !PackageIsNullOrGlobal(packagePrefix) ? packagePrefix + "::" + sequenceName : sequenceName;
ISequenceDefinition sequenceDef = actions.GetSequenceDefinition(packagePrefixedName);
if (sequenceDef == null)
{
throw new SequenceParserException(packagePrefixedName, DefinitionType.Sequence, SequenceParserError.UnknownRuleOrSequence);
}
return(new SequenceSequenceCallInterpreted(sequenceDef,
argExprs, returnVars, subgraph,
special));
}
/// <summary>
/// Устанавливаем данные импорта
/// </summary>
public void SetDataImport(PulseSequence pulseSequence)
{
List <Variable> variablelist = new List <Variable>();
List <TableSequence> tableList = new List <TableSequence>( );
List <StreamSequence> streamList = new List <StreamSequence>( );
if (pulseSequence.sequenceParameters.variableSequence != null)
{
foreach (SequenceParameters.Parameter parametr in pulseSequence.sequenceParameters.variableSequence)
{
SequenceVariable variable = new SequenceVariable( );
Type typeValue = Value.GetAutoType(parametr.value, parametr.minimum, parametr.maximum);
variable.Name = parametr.name;
variable.IsReadOnly = parametr.isReadOnly;
if (!string.IsNullOrWhiteSpace(parametr.minimum))
{
variable.Min = (Value)Activator.CreateInstance(typeValue, new object[] { parametr.minimum, null });
}
if (!string.IsNullOrWhiteSpace(parametr.maximum))
{
variable.Max = (Value)Activator.CreateInstance(typeValue, new object[] { parametr.maximum, null });
}
variable.Value = (Value)Activator.CreateInstance(typeValue, new object[] { parametr.value, null });
variablelist.Add(variable);
}
}
SequenceVariables = variablelist.ToArray( );
variablelist.Clear( );
if (pulseSequence.sequenceParameters.variableTable != null)
{
foreach (SequenceParameters.Parameter parametr in pulseSequence.sequenceParameters.variableTable)
{
TableVariable variable = new TableVariable( );
variable.Name = parametr.name;
variable.IsReadOnly = parametr.isReadOnly;
if (!string.IsNullOrWhiteSpace(parametr.minimum))
{
variable.Min = Value.CreateInstance(parametr.minimum);
}
if (!string.IsNullOrWhiteSpace(parametr.maximum))
{
if (variable.Min != null)
{
variable.Max = (Value)Activator.CreateInstance(variable.Min.GetType( ), new object[] { parametr.maximum, null });
}
else
{
variable.Max = Value.CreateInstance(parametr.maximum);
}
}
if (variable.Min != null)
{
variable.Value = (Value)Activator.CreateInstance(variable.Min.GetType( ), new object[] { parametr.value, null });
}
else if (variable.Max != null)
{
variable.Value = (Value)Activator.CreateInstance(variable.Max.GetType( ), new object[] { parametr.value, null });
}
else
{
variable.Value = Value.CreateInstance(parametr.value);
}
variablelist.Add(variable);
}
}
TableVariables = variablelist.ToArray( );
foreach (SequenceTable table in pulseSequence.sequenceTables)
{
tableList.Add(TableSequence.CreateInstance(table));
}
Tables = tableList.ToArray( );
foreach (SequenceRow row in pulseSequence.sequenceRows)
{
streamList.Add(new StreamSequence(row));
}
Streams = streamList.ToArray( );
}
