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; } }