public void TestRandomDeferredConfig(int low, int?high)
{
string variableName = "myRnd";
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
jsonParameters.Add("low", low);
if (high.HasValue)
{
jsonParameters.Add("high", high);
}
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("RandomMacro", null, variableName, jsonParameters);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
RandomMacro macro = new RandomMacro();
IMacroConfig realConfig = macro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(_engineEnvironmentSettings, variables, realConfig, parameters, setter);
ITemplateParameter valueParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out valueParam));
long randomValue = (long)parameters.ResolvedValues[valueParam];
Assert.True(randomValue >= low);
if (high.HasValue)
{
Assert.True(randomValue <= high);
}
}
public void EvaluateDeferredConfig(IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
GeneratedSymbolDeferredMacroConfig deferredConfig = rawConfig as GeneratedSymbolDeferredMacroConfig;
if (deferredConfig == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as a GeneratedSymbolDeferredMacroConfig");
}
JToken formatToken;
if (!deferredConfig.Parameters.TryGetValue("format", out formatToken))
{
throw new ArgumentNullException("format");
}
string format = formatToken.ToString();
bool utc;
JToken utcToken;
if (deferredConfig.Parameters.TryGetValue("utc", out utcToken))
{
utc = utcToken.ToBool();
}
else
{
utc = false;
}
IMacroConfig realConfig = new NowMacroConfig(deferredConfig.VariableName, format, utc);
EvaluateConfig(vars, realConfig, parameters, setter);
}
public void EvaluateNowDeferredConfig()
{
string variableName = "nowString";
string format = "";
bool utc = false;
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
jsonParameters.Add("format", format);
jsonParameters.Add("utc", utc);
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("NowMacro", variableName, jsonParameters);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = new SimpleConfigModel();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(EngineEnvironmentSettings, parameters);
NowMacro macro = new NowMacro();
IMacroConfig realConfig = macro.CreateConfig(EngineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(EngineEnvironmentSettings, variables, realConfig, parameters, setter);
ITemplateParameter resultParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out resultParam));
string macroNowString = (string)parameters.ResolvedValues[resultParam];
DateTime macroNowTime = Convert.ToDateTime(macroNowString);
TimeSpan difference = macroNowTime.Subtract(DateTime.Now);
// 10 seconds is quite a lot of wiggle room, but should be fine, and safe.
Assert.True(difference.TotalSeconds < 10);
}
public void EvaluateConfig(IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
EvaluateMacroConfig config = rawConfig as EvaluateMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as EvaluateMacroConfig");
}
ConditionEvaluator evaluator = EvaluatorSelector.Select(config.Evaluator);
byte[] data = Encoding.UTF8.GetBytes(config.Value);
int len = data.Length;
int pos = 0;
IProcessorState state = new GlobalRunSpec.ProcessorState(vars, data, Encoding.UTF8);
bool faulted;
bool result = evaluator(state, ref len, ref pos, out faulted);
Parameter p = new Parameter
{
IsVariable = true,
Name = config.VariableName
};
setter(p, result.ToString());
}
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars,
IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
JoinMacroConfig config = rawConfig as JoinMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as ConcatenationMacroConfig");
}
List <string> values = new List <string>();
foreach (KeyValuePair <string, string> symbol in config.Symbols)
{
switch (symbol.Key)
{
case "ref":
string value;
if (!vars.TryGetValue(symbol.Value, out object working))
{
if (parameters.TryGetRuntimeValue(environmentSettings, symbol.Value,
out object resolvedValue, true))
{
value = resolvedValue.ToString();
}
else
{
value = string.Empty;
}
}
public void TestConstantDeferredConfig()
{
string variableName = "myConstant";
string value = "1048576";
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
jsonParameters.Add("value", value);
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("ConstantMacro", null, variableName, jsonParameters);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
ConstantMacro macro = new ConstantMacro();
IMacroConfig realConfig = macro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(_engineEnvironmentSettings, variables, realConfig, parameters, setter);
ITemplateParameter constParameter;
Assert.True(parameters.TryGetParameterDefinition(variableName, out constParameter));
string constParamValue = (parameters.ResolvedValues[constParameter]).ToString();
Assert.Equal(constParamValue, value);
}
public void EvaluateNowOverrideDatatypeInConfig(string type)
{
string variableName = "nowString";
string format = "";
bool utc = false;
Dictionary<string, JToken> jsonParameters = new Dictionary<string, JToken>();
jsonParameters.Add("format", format);
jsonParameters.Add("utc", utc);
jsonParameters.Add("datatype", type);
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("NowMacro", type, variableName, jsonParameters);
NowMacro macro = new NowMacro();
IMacroConfig realConfig = macro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
Assert.Equal("string", (realConfig as NowMacroConfig)?.DataType);
}
public void TestSwitchDeferredConfig()
{
string variableName = "mySwitchVar";
string evaluator = "C++";
string dataType = "string";
string expectedValue = "this one";
string switchCases = @"[
{
'condition': '(3 > 10)',
'value': 'three greater than ten'
},
{
'condition': '(false)',
'value': 'false value'
},
{
'condition': '(10 > 0)',
'value': '" + expectedValue + @"'
},
{
'condition': '(5 > 4)',
'value': 'not this one'
}
]";
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
jsonParameters.Add("evaluator", evaluator);
jsonParameters.Add("datatype", dataType);
jsonParameters.Add("cases", JArray.Parse(switchCases));
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("SwitchMacro", null, variableName, jsonParameters);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = new SimpleConfigModel();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
SwitchMacro macro = new SwitchMacro();
IMacroConfig realConfig = macro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(_engineEnvironmentSettings, variables, realConfig, parameters, setter);
ITemplateParameter resultParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out resultParam));
string resultValue = (string)parameters.ResolvedValues[resultParam];
Assert.Equal(resultValue, expectedValue);
}
public void EvaluateConfig(IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
SwitchMacroConfig config = rawConfig as SwitchMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as SwitchMacroConfig");
}
ConditionEvaluator evaluator = EvaluatorSelector.Select(config.Evaluator);
string result = string.Empty; // default if no condition assigns a value
foreach (KeyValuePair <string, string> switchInfo in config.Switches)
{
string condition = switchInfo.Key;
string value = switchInfo.Value;
if (string.IsNullOrEmpty(condition))
{ // no condition, this is the default.
result = value;
break;
}
else
{
byte[] conditionBytes = Encoding.UTF8.GetBytes(condition);
int length = conditionBytes.Length;
int position = 0;
IProcessorState state = new GlobalRunSpec.ProcessorState(vars, conditionBytes, Encoding.UTF8);
bool faulted;
if (evaluator(state, ref length, ref position, out faulted))
{
result = value;
break;
}
}
}
Parameter p = new Parameter
{
IsVariable = true,
Name = config.VariableName,
DataType = config.DataType
};
setter(p, result.ToString());
}
public void EvaluateConfig(IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
string value = null;
RegexMacroConfig config = rawConfig as RegexMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as RegexMacroConfig");
}
object working;
if (!vars.TryGetValue(config.SourceVariable, out working))
{
ITemplateParameter param;
object resolvedValue;
if (!parameters.TryGetParameterDefinition(config.SourceVariable, out param) || !parameters.ResolvedValues.TryGetValue(param, out resolvedValue))
{
value = string.Empty;
}
else
{
value = (string)resolvedValue;
}
}
else
{
value = working?.ToString() ?? "";
}
if (config.Steps != null)
{
foreach (KeyValuePair <string, string> stepInfo in config.Steps)
{
value = Regex.Replace(value, stepInfo.Key, stepInfo.Value);
}
}
Parameter p = new Parameter
{
IsVariable = true,
Name = config.VariableName
};
setter(p, value);
}
public void EvaluateConfig(IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
ConstantMacroConfig config = rawConfig as ConstantMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as ConstantMacroConfig");
}
Parameter p = new Parameter
{
IsVariable = true,
Name = config.VariableName
};
setter(p, config.Value);
}
public void TestRegexDeferredConfig()
{
string variableName = "myRegex";
string sourceVariable = "originalValue";
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
jsonParameters.Add("source", sourceVariable);
string jsonSteps = @"[
{
'regex': 'A',
'replacement': 'Z'
}
]";
jsonParameters.Add("steps", JArray.Parse(jsonSteps));
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("RegexMacro", variableName, jsonParameters);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = new SimpleConfigModel();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(EngineEnvironmentSettings, parameters);
string sourceValue = "ABCAABBCC";
string expectedValue = "ZBCZZBBCC";
Parameter sourceParam = new Parameter
{
IsVariable = true,
Name = sourceVariable
};
variables[sourceVariable] = sourceValue;
setter(sourceParam, sourceValue);
RegexMacro macro = new RegexMacro();
IMacroConfig realConfig = macro.CreateConfig(EngineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(EngineEnvironmentSettings, variables, realConfig, parameters, setter);
ITemplateParameter newParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out newParam));
string newValue = (string)parameters.ResolvedValues[newParam];
Assert.Equal(newValue, expectedValue);
}
public void TestDeferredJoinConfig(string separator)
{
string variableName = "joinedParameter";
string referenceSymbolName = "referenceSymbol";
string referenceSymbolValue = "referenceValue";
string constantValue = "constantValue";
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
string symbols =
$"[ {{\"type\":\"const\" , \"value\":\"{constantValue}\" }}, {{\"type\":\"ref\" , \"value\":\"{referenceSymbolName}\" }} ]";
jsonParameters.Add("symbols", JArray.Parse(symbols));
if (!string.IsNullOrEmpty(separator))
{
jsonParameters.Add("separator", separator);
}
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("JoinMacro", null, variableName, jsonParameters);
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = new SimpleConfigModel();
IParameterSet parameters = new RunnableProjectGenerator.ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(EngineEnvironmentSettings, parameters);
Parameter referenceParam = new Parameter
{
IsVariable = true,
Name = referenceSymbolName
};
variables[referenceSymbolName] = referenceSymbolValue;
setter(referenceParam, referenceSymbolValue);
JoinMacro macro = new JoinMacro();
IMacroConfig realConfig = macro.CreateConfig(EngineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(EngineEnvironmentSettings, variables, realConfig, parameters, setter);
Assert.True(parameters.TryGetParameterDefinition(variableName, out ITemplateParameter convertedParam));
string convertedValue = (string)parameters.ResolvedValues[convertedParam];
string expectedValue = string.Join(separator, constantValue, referenceSymbolValue);
Assert.Equal(convertedValue, expectedValue);
}
public void EvaluateConfig(IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
GuidMacroConfig config = rawConfig as GuidMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as GuidMacroConfig");
}
if (config.Format != null)
{
Guid g = Guid.NewGuid();
string value = char.IsUpper(config.Format[0]) ? g.ToString(config.Format[0].ToString()).ToUpperInvariant() : g.ToString(config.Format[0].ToString()).ToLowerInvariant();
Parameter p = new Parameter
{
IsVariable = true,
Name = config.VariableName
};
setter(p, value);
}
else
{
Guid g = Guid.NewGuid();
string guidFormats = GuidMacroConfig.DefaultFormats;
for (int i = 0; i < guidFormats.Length; ++i)
{
string value = char.IsUpper(guidFormats[i]) ? g.ToString(guidFormats[i].ToString()).ToUpperInvariant() : g.ToString(guidFormats[i].ToString()).ToLowerInvariant();
Parameter p = new Parameter
{
IsVariable = true,
Name = config.VariableName + "-" + guidFormats[i]
};
setter(p, value);
}
Parameter pd = new Parameter
{
IsVariable = true,
Name = config.VariableName
};
setter(pd, g.ToString("D"));
}
}
public void EvaluateDeferredConfig(IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
GeneratedSymbolDeferredMacroConfig deferredConfig = rawConfig as GeneratedSymbolDeferredMacroConfig;
if (deferredConfig == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as a SwitchMacroConfig");
}
JToken evaluatorToken;
string evaluator = null;
if (deferredConfig.Parameters.TryGetValue("evaluator", out evaluatorToken))
{
evaluator = evaluatorToken.ToString();
}
JToken dataTypeToken;
string dataType = null;
if (deferredConfig.Parameters.TryGetValue("datatype", out dataTypeToken))
{
dataType = dataTypeToken.ToString();
}
JToken switchListToken;
List <KeyValuePair <string, string> > switchList = new List <KeyValuePair <string, string> >();
if (deferredConfig.Parameters.TryGetValue("cases", out switchListToken))
{
JArray switchJArray = (JArray)switchListToken;
foreach (JToken switchInfo in switchJArray)
{
JObject map = (JObject)switchInfo;
string condition = map.ToString("condition");
string value = map.ToString("value");
switchList.Add(new KeyValuePair <string, string>(condition, value));
}
}
IMacroConfig realConfig = new SwitchMacroConfig(deferredConfig.VariableName, evaluator, dataType, switchList);
EvaluateConfig(vars, realConfig, parameters, setter);
}
public void TestDeferredGuidConfig()
{
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
jsonParameters.Add("format", null);
string variableName = "myGuid1";
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("GuidMacro", "string", variableName, jsonParameters);
GuidMacro guidMacro = new GuidMacro();
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = new SimpleConfigModel();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(EngineEnvironmentSettings, parameters);
IMacroConfig realConfig = guidMacro.CreateConfig(EngineEnvironmentSettings, deferredConfig);
guidMacro.EvaluateConfig(EngineEnvironmentSettings, variables, realConfig, parameters, setter);
ValidateGuidMacroCreatedParametersWithResolvedValues(variableName, parameters);
}
public void EvaluateConfig(IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
NowMacroConfig config = rawConfig as NowMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as NowMacroConfig");
}
DateTime time = config.Utc ? DateTime.UtcNow : DateTime.Now;
string value = time.ToString(config.Format);
Parameter p = new Parameter
{
IsVariable = true,
Name = config.VariableName
};
setter(p, value);
}
public void EvaluateConfig(IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
RandomMacroConfig config = rawConfig as RandomMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as RandomMacroConfig");
}
Random rnd = new Random();
int value = rnd.Next(config.Low, config.High);
Parameter p = new Parameter
{
IsVariable = true,
Name = config.VariableName
};
setter(p, value.ToString());
}
public void EvaluateDeferredConfig(IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
GeneratedSymbolDeferredMacroConfig deferredConfig = rawConfig as GeneratedSymbolDeferredMacroConfig;
if (deferredConfig == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as a GeneratedSymbolDeferredMacroConfig");
}
JToken valueToken;
if (!deferredConfig.Parameters.TryGetValue("value", out valueToken))
{
throw new ArgumentNullException("value");
}
string value = valueToken.ToString();
IMacroConfig realConfig = new ConstantMacroConfig(deferredConfig.VariableName, value);
EvaluateConfig(vars, realConfig, parameters, setter);
}
public void TestDeferredCaseChangeConfig()
{
string variableName = "myString";
Dictionary <string, JToken> jsonParameters = new Dictionary <string, JToken>();
string sourceVariable = "sourceString";
jsonParameters.Add("source", sourceVariable);
jsonParameters.Add("toLower", false);
GeneratedSymbolDeferredMacroConfig deferredConfig = new GeneratedSymbolDeferredMacroConfig("CaseChangeMacro", null, variableName, jsonParameters);
CaseChangeMacro macro = new CaseChangeMacro();
IVariableCollection variables = new VariableCollection();
IRunnableProjectConfig config = A.Fake <IRunnableProjectConfig>();
IParameterSet parameters = new ParameterSet(config);
ParameterSetter setter = MacroTestHelpers.TestParameterSetter(_engineEnvironmentSettings, parameters);
string sourceValue = "Original Value SomethingCamelCase";
Parameter sourceParam = new Parameter
{
IsVariable = true,
Name = sourceVariable
};
variables[sourceVariable] = sourceValue;
setter(sourceParam, sourceValue);
IMacroConfig realConfig = macro.CreateConfig(_engineEnvironmentSettings, deferredConfig);
macro.EvaluateConfig(_engineEnvironmentSettings, variables, realConfig, parameters, setter);
ITemplateParameter convertedParam;
Assert.True(parameters.TryGetParameterDefinition(variableName, out convertedParam));
string convertedValue = (string)parameters.ResolvedValues[convertedParam];
Assert.Equal(convertedValue, sourceValue.ToUpper());
}
public void EvaluateDeferredConfig(IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
GeneratedSymbolDeferredMacroConfig deferredConfig = rawConfig as GeneratedSymbolDeferredMacroConfig;
if (deferredConfig == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as a GeneratedSymbolDeferredMacroConfig");
}
JToken sourceVarToken;
if (!deferredConfig.Parameters.TryGetValue("source", out sourceVarToken))
{
throw new ArgumentNullException("source");
}
string sourceVariable = sourceVarToken.ToString();
JToken stepListToken;
List <KeyValuePair <string, string> > replacementSteps = new List <KeyValuePair <string, string> >();
if (deferredConfig.Parameters.TryGetValue("steps", out stepListToken))
{
JArray stepList = (JArray)stepListToken;
foreach (JToken step in stepList)
{
JObject map = (JObject)step;
string regex = map.ToString("regex");
string replaceWith = map.ToString("replacement");
replacementSteps.Add(new KeyValuePair <string, string>(regex, replaceWith));
}
}
IMacroConfig realConfig = new RegexMacroConfig(deferredConfig.VariableName, sourceVariable, replacementSteps);
EvaluateConfig(vars, realConfig, parameters, setter);
}
public void EvaluateDeferredConfig(IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
GeneratedSymbolDeferredMacroConfig deferredConfig = rawConfig as GeneratedSymbolDeferredMacroConfig;
if (deferredConfig == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as a GeneratedSymbolDeferredMacroConfig");
}
JToken lowToken;
JToken highToken;
int low;
int high;
if (!deferredConfig.Parameters.TryGetValue("low", out lowToken))
{
throw new ArgumentNullException("low");
}
else
{
low = lowToken.Value <int>();
}
if (!deferredConfig.Parameters.TryGetValue("high", out highToken))
{
high = int.MaxValue;
}
else
{
high = highToken.Value <int>();
}
IMacroConfig realConfig = new RandomMacroConfig(deferredConfig.VariableName, low, high);
EvaluateConfig(vars, realConfig, parameters, setter);
}
public IMacroConfig CreateConfig(IEngineEnvironmentSettings environmentSettings, IMacroConfig rawConfig)
{
GeneratedSymbolDeferredMacroConfig deferredConfig = rawConfig as GeneratedSymbolDeferredMacroConfig;
if (deferredConfig == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as a GeneratedSymbolDeferredMacroConfig");
}
deferredConfig.Parameters.TryGetValue("format", out JToken formatToken);
string format = formatToken?.ToString();
deferredConfig.Parameters.TryGetValue("defaultFormat", out JToken defaultFormatToken);
string defaultFormat = defaultFormatToken?.ToString();
IMacroConfig realConfig = new GuidMacroConfig(deferredConfig.VariableName, deferredConfig.DataType, format, defaultFormat);
return(realConfig);
}
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
GuidMacroConfig config = rawConfig as GuidMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as GuidMacroConfig");
}
string guidFormats;
if (!string.IsNullOrEmpty(config.Format))
{
guidFormats = config.Format;
}
else
{
guidFormats = GuidMacroConfig.DefaultFormats;
}
Guid g = Guid.NewGuid();
for (int i = 0; i < guidFormats.Length; ++i)
{
string value = char.IsUpper(guidFormats[i]) ? g.ToString(guidFormats[i].ToString()).ToUpperInvariant() : g.ToString(guidFormats[i].ToString()).ToLowerInvariant();
Parameter p = new Parameter
{
IsVariable = true,
Name = config.VariableName + "-" + guidFormats[i],
DataType = config.DataType
};
vars[p.Name] = value;
setter(p, value);
}
Parameter pd;
if (parameters.TryGetParameterDefinition(config.VariableName, out ITemplateParameter existingParam))
{
// If there is an existing parameter with this name, it must be reused so it can be referenced by name
// for other processing, for example: if the parameter had value forms defined for creating variants.
// When the param already exists, use its definition, but set IsVariable = true for consistency.
pd = (Parameter)existingParam;
pd.IsVariable = true;
}
else
{
pd = new Parameter
{
IsVariable = true,
Name = config.VariableName
};
}
string value = char.IsUpper(config.DefaultFormat) ? g.ToString(config.DefaultFormat.ToString()).ToUpperInvariant() : g.ToString(config.DefaultFormat.ToString()).ToLowerInvariant();
vars[config.VariableName] = value;
setter(pd, value);
}
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig config, IParameterSet parameters, ParameterSetter setter)
{
CoalesceMacroConfig realConfig = config as CoalesceMacroConfig;
if (realConfig == null)
{
throw new InvalidCastException("Unable to cast config as a CoalesceMacroConfig");
}
object targetValue = null;
string datatype = realConfig.DataType;
if (vars.TryGetValue(realConfig.SourceVariableName, out object currentSourceValue) && !Equals(currentSourceValue ?? string.Empty, realConfig.DefaultValue ?? string.Empty))
{
targetValue = currentSourceValue;
if (parameters.TryGetParameterDefinition(realConfig.SourceVariableName, out ITemplateParameter sourceParameter))
{
datatype = sourceParameter.DataType;
}
}
else
{
if (!vars.TryGetValue(realConfig.FallbackVariableName, out targetValue))
{
environmentSettings.Host.LogDiagnosticMessage("Unable to find a variable to fall back to called " + realConfig.FallbackVariableName, "Authoring", realConfig.SourceVariableName, realConfig.DefaultValue);
targetValue = realConfig.DefaultValue;
}
else if (parameters.TryGetParameterDefinition(realConfig.FallbackVariableName, out ITemplateParameter sourceParameter))
{
datatype = sourceParameter.DataType;
}
}
Parameter p;
if (parameters.TryGetParameterDefinition(config.VariableName, out ITemplateParameter existingParam))
{
// If there is an existing parameter with this name, it must be reused so it can be referenced by name
// for other processing, for example: if the parameter had value forms defined for creating variants.
// When the param already exists, use its definition, but set IsVariable = true for consistency.
p = (Parameter)existingParam;
p.IsVariable = true;
if (string.IsNullOrEmpty(p.DataType))
{
p.DataType = datatype;
}
}
else
{
p = new Parameter
{
IsVariable = true,
Name = config.VariableName,
DataType = datatype
};
}
vars[config.VariableName] = targetValue?.ToString();
setter(p, targetValue?.ToString());
}
public IMacroConfig CreateConfig(IEngineEnvironmentSettings environmentSettings, IMacroConfig rawConfig)
{
GeneratedSymbolDeferredMacroConfig deferredConfig = rawConfig as GeneratedSymbolDeferredMacroConfig;
if (deferredConfig == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as a GeneratedSymbolDeferredMacroConfig");
}
string sourceVariableName = null;
if (deferredConfig.Parameters.TryGetValue("sourceVariableName", out JToken sourceVariableToken) && sourceVariableToken.Type == JTokenType.String)
{
sourceVariableName = sourceVariableToken.ToString();
}
string defaultValue = null;
if (deferredConfig.Parameters.TryGetValue("defaultValue", out JToken defaultValueToken) && defaultValueToken.Type == JTokenType.String)
{
defaultValue = defaultValueToken.ToString();
}
string fallbackVariableName = null;
if (deferredConfig.Parameters.TryGetValue("fallbackVariableName", out JToken fallbackVariableNameToken) && fallbackVariableNameToken.Type == JTokenType.String)
{
fallbackVariableName = fallbackVariableNameToken.ToString();
}
IMacroConfig realConfig = new CoalesceMacroConfig(deferredConfig.VariableName, deferredConfig.DataType, sourceVariableName, defaultValue, fallbackVariableName);
return(realConfig);
}
public IMacroConfig CreateConfig(IEngineEnvironmentSettings environmentSettings, IMacroConfig rawConfig)
{
GeneratedSymbolDeferredMacroConfig deferredConfig = rawConfig as GeneratedSymbolDeferredMacroConfig;
if (deferredConfig == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as a SwitchMacroConfig");
}
string evaluator = null;
if (deferredConfig.Parameters.TryGetValue("evaluator", out JToken evaluatorToken))
{
evaluator = evaluatorToken.ToString();
}
string dataType = null;
if (deferredConfig.Parameters.TryGetValue("datatype", out JToken dataTypeToken))
{
dataType = dataTypeToken.ToString();
}
List <KeyValuePair <string, string> > switchList = new List <KeyValuePair <string, string> >();
if (deferredConfig.Parameters.TryGetValue("cases", out JToken switchListToken))
{
JArray switchJArray = (JArray)switchListToken;
foreach (JToken switchInfo in switchJArray)
{
JObject map = (JObject)switchInfo;
string condition = map.ToString("condition");
string value = map.ToString("value");
switchList.Add(new KeyValuePair <string, string>(condition, value));
}
}
IMacroConfig realConfig = new SwitchMacroConfig(deferredConfig.VariableName, evaluator, dataType, switchList);
return(realConfig);
}
public IMacroConfig CreateConfig(IEngineEnvironmentSettings environmentSettings, IMacroConfig rawConfig)
{
GeneratedSymbolDeferredMacroConfig deferredConfig = rawConfig as GeneratedSymbolDeferredMacroConfig;
if (deferredConfig == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as a GeneratedSymbolDeferredMacroConfig");
}
if (!deferredConfig.Parameters.TryGetValue("value", out JToken valueToken))
{
throw new ArgumentNullException("value");
}
string value = valueToken.ToString();
IMacroConfig realConfig = new ConstantMacroConfig(deferredConfig.DataType, deferredConfig.VariableName, value);
return(realConfig);
}
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
EvaluateMacroConfig config = rawConfig as EvaluateMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as EvaluateMacroConfig");
}
ConditionEvaluator evaluator = EvaluatorSelector.Select(config.Evaluator, Cpp2StyleEvaluatorDefinition.Evaluate);
byte[] data = Encoding.UTF8.GetBytes(config.Value);
int len = data.Length;
int pos = 0;
IProcessorState state = new GlobalRunSpec.ProcessorState(environmentSettings, vars, data, Encoding.UTF8);
bool result = evaluator(state, ref len, ref pos, out bool faulted);
Parameter p;
if (parameters.TryGetParameterDefinition(config.VariableName, out ITemplateParameter existingParam))
{
// If there is an existing parameter with this name, it must be reused so it can be referenced by name
// for other processing, for example: if the parameter had value forms defined for creating variants.
// When the param already exists, use its definition, but set IsVariable = true for consistency.
p = (Parameter)existingParam;
p.IsVariable = true;
if (string.IsNullOrEmpty(p.DataType))
{
p.DataType = config.DataType;
}
}
else
{
p = new Parameter
{
IsVariable = true,
Name = config.VariableName,
DataType = config.DataType
};
}
vars[config.VariableName] = result.ToString();
setter(p, result.ToString());
}
public void EvaluateConfig(IEngineEnvironmentSettings environmentSettings, IVariableCollection vars, IMacroConfig rawConfig, IParameterSet parameters, ParameterSetter setter)
{
string value = null;
RegexMacroConfig config = rawConfig as RegexMacroConfig;
if (config == null)
{
throw new InvalidCastException("Couldn't cast the rawConfig as RegexMacroConfig");
}
if (!vars.TryGetValue(config.SourceVariable, out object working))
{
if (parameters.TryGetRuntimeValue(environmentSettings, config.SourceVariable, out object resolvedValue, true))
{
value = resolvedValue.ToString();
}
else
{
value = string.Empty;
}
}
