private void ParseValues(IErrorCache errorCache) { if (!SupportedType.HasValue) { return; } switch (SupportedType.Value) { case SupportedTypes.Integer: Value = ParseInteger(Variable.Value, errorCache); Default = ParseInteger(Variable.Default, errorCache); Max = ParseInteger(Variable.Max, errorCache); Min = ParseInteger(Variable.Min, errorCache); break; case SupportedTypes.String: Value = Variable.Value; Default = Variable.Default; break; default: errorCache.AddError($"Unable to parse unhandled type: {SupportedType.Value}"); break; } }
public Bootstrap(IRepository repository, IScriptLoader scriptLoader, IErrorCache errorCache) { Repository = repository; ScriptLoader = scriptLoader; ErrorCache = errorCache; globalLoader = new GlobalLoader(errorCache); cache = new PackageCache(errorCache); }
private TEnum?Parse <TEnum>(string value, string fieldName, IErrorCache errorCache) where TEnum : struct, IConvertible { if (!string.IsNullOrWhiteSpace(value) && value.TryParseStringValueToEnum(out TEnum result)) { return(result); } errorCache.AddError($"Error parsing {fieldName} for variable"); return(null); }
public static VariableInfo Extract(Variable variable, string packageId, IErrorCache errorCache) { var result = new VariableInfo(variable, packageId); int preCount = errorCache.Count; result.SupportedType = result.Parse <SupportedTypes>(variable.Type, nameof(variable.Type), errorCache); result.Units = result.Parse <Units>(variable.Units, nameof(variable.Units), errorCache); result.ParseValues(errorCache); result.HasErrors = errorCache.Count != preCount; return(result); }
public T GetValueOrDefault <T>(IErrorCache errorCache = null) { var result = Value ?? Default; if (result == null || result.GetType() != typeof(T)) { var message = $"Could not convert '{result}' to {typeof(T).Name} for variable: {Variable.Name}"; errorCache?.AddError(message); throw new InvalidOperationException(message); } return((T)result); }
private int?ParseInteger(string value, IErrorCache errorCache) { if (string.IsNullOrEmpty(value)) { return(null); } if (int.TryParse(value, out var result)) { return(result); } errorCache.AddError($"Could not parse '{value}' as an integer"); return(null); }
public virtual VariableInfo FirstVarOfName(string variableName, IErrorCache errorCache) { if (byLocalName.TryGetValue(variableName, out var result)) { return(VariableInfo.Extract(result, result.PackageId, errorCache)); } if (Scope?.Parent != null) { return(Scope.Parent.FirstVarOfName(variableName, errorCache)); } errorCache.AddError($"Could not FirstVarOfName for variable called {variableName}"); return(null); }
public static IDictionary <string, NestedScope> BuildHeirarchy(IEnumerable <string> packageNames, IErrorCache errorCache, IDictionary <string, NestedScope> existing = null) { var orderedPairs = packageNames .Distinct(StringComparer.OrdinalIgnoreCase) .Where(name => existing == null || !existing.ContainsKey(name)) .Select(Parse) .OrderBy(t => t.Item1.Length); var dict = existing ?? new Dictionary <string, NestedScope>(StringComparer.OrdinalIgnoreCase); foreach (var pair in orderedPairs) { NestedScope parent = null; if (pair.Item1 != "" && !dict.TryGetValue(pair.Item1, out parent)) { errorCache.AddError($"Could not locate parent '{pair.Item1}' when building heirarchy."); } var scope = new NestedScope(parent) { Name = pair.Item2 }; dict.Add(pair.Item2, scope); } return(dict); }
private static Tuple <string, object> ProvideSetting <T>(this VariableInfo varInfo, string settingName, IErrorCache errorCache) { var value = varInfo.GetValueOrDefault <T>(errorCache); return(Tuple.Create(settingName, (object)value)); }
private static Tuple <string, object> ProvideSetting <T>(this NestedScope scope, string settingName, IErrorCache errorCache) { var variable = scope.FirstVarOfName(settingName, errorCache); return(variable.ProvideSetting <T>(settingName, errorCache)); }
public const string Stable = "stable"; // data that isn't changing public static IEnumerable <Tuple <string, object> > SettingForLifestage(NestedScope scope, IErrorCache errorCache, bool active) { yield return(Tuple.Create( $"{Constants.IndexRoutingAllocationInclude}{RoleTag}", active ? (object)Active : Stable)); if (active) { yield return(scope.ProvideSetting <int>(Constants.GlobalSettings.NoOfShards, errorCache)); } // MAYBE want to be able to support different values for active and stable ??? yield return(scope.ProvideSetting <int>(Constants.GlobalSettings.NoOfReplicas, errorCache)); yield return(scope.ProvideSetting <string>(Constants.GlobalSettings.RefreshInterval, errorCache)); }
public PackageCache(IErrorCache errorCache) { ErrorCache = errorCache; }
public static VariableInfo FirstVarOfName(this NestedScope scope, string variableName, IErrorCache errorCache) { return(scope.GetAspect <VariableSet>().FirstVarOfName(variableName, errorCache)); }
public GlobalLoader(IErrorCache errorCache) { ErrorCache = errorCache; }