public object Parse(string stringValue, Type valueType, IFormatProvider formatProvider = null) { if (valueType != _keyValueType) { throw new ArgumentException( "Value type must be a " + _keyValueType.Name + " type.", nameof(valueType)); } int separatorIndex = stringValue.IndexOfAny(Separators); if (separatorIndex < 0) { throw new FormatException("Key-value separator was not found."); } string keyString = stringValue.Substring(0, separatorIndex); string valueString = stringValue.Substring(separatorIndex + 1); object key = _keyParser.Parse(keyString, _keyType, formatProvider); object value = _valueParser.Parse(valueString, _valueType, formatProvider); var keyValue = Activator.CreateInstance(_keyValueType, key, value); return(keyValue); }
public IModel Import(string filePath) { try { return (_modelWriter.Write( _valueParser.Parse( _valueReader.Read( _fileStreamer.GetStream(filePath))))); } catch (Exception e) { string addedContext = default; foreach (var f in this.GetType().GetFields(BindingFlags.Instance | BindingFlags.NonPublic)) { if (f.GetValue(this) is IStateInfoProvider i) { addedContext += i.StateInfo; } } if (addedContext != default) { throw new Exception($"{e.Message} {addedContext}", e); } else { throw; } } }
void IInternalCommandParamOfT.Parse(CultureInfo culture) { _parsedValues.Clear(); for (int i = 0; i < Values.Count; i++) { _parsedValues.Add(_valueParser.Parse(Name, Values[i], culture)); } }
void IInternalCommandParamOfT.Parse(CultureInfo culture) { _parsedValues.Clear(); foreach (var t in Values) { _parsedValues.Add(_valueParser.Parse(Name, t, culture)); } }
public object Parse(string? argName, IReadOnlyList<string?> values) { var list = (IList)Activator.CreateInstance(_listType, new object[] { values.Count }); foreach (var t in values) { list.Add(_elementParser.Parse(argName, t, _parserCulture)); } return list; }
public object?Parse(string?argName, string?value, CultureInfo culture) { if (string.IsNullOrWhiteSpace(value)) { return(null); } return(_wrapped.Parse(argName, value, culture)); }
public Tuple <bool, T> Parse(string argName, string value, CultureInfo culture) { if (value == null) { return(Tuple.Create <bool, T>(false, default)); } return(Tuple.Create(true, _typeParser.Parse(argName, value, culture))); }
public object Parse(string argName, string value) { if (string.IsNullOrWhiteSpace(value)) { return(null); } return(_wrapped.Parse(argName, value)); }
public object Parse(string?argName, IReadOnlyList <string?> values) { var list = (IList)Activator.CreateInstance(_listType, new object[] { values.Count }); for (var i = 0; i < values.Count; i++) { list.Add(_elementParser.Parse(argName, values[i], _parserCulture)); } return(list); }
public object Parse(string argName, IReadOnlyList <string> values) { var set = Activator.CreateInstance(_listType, Constants.EmptyArray); for (var i = 0; i < values.Count; i++) { _addMethod.Invoke(set, new object[] { _elementParser.Parse(argName, values[i]) }); } return(set); }
public object Parse(string?argName, IReadOnlyList <string?> values) { var set = Activator.CreateInstance(_listType, Util.EmptyArray <object>()); for (var i = 0; i < values.Count; i++) { _addMethod.Invoke(set, new object?[] { _elementParser.Parse(argName, values[i], _parserCulture) }); } return(set); }
public object Parse(string?argName, IReadOnlyList <string?> values) { var set = Activator.CreateInstance(_listType, Util.EmptyArray <object>()); foreach (var t in values) { _addMethod.Invoke(set, new[] { _elementParser.Parse(argName, t, _parserCulture) }); } return(set); }
public object Parse(string argName, IReadOnlyList <string> values) { var array = Array.CreateInstance(_elementType, values.Count); for (var i = 0; i < values.Count; i++) { array.SetValue(_elementParser.Parse(argName, values[i]), i); } return(array); }
private Object callParser(Object value, IContainer container) { IValueParser parser = container.GetParser(Parser); if (parser == null) { return(value); } return(parser.Parse(value.ToString())); }
public IRoute <INode <T> > Parse(string text) { var nodes = text.Split(';') .Select(s => _valueParser.Parse(s)) .Select(c => _nodeLookup[c]) .Reverse(); return(nodes.Aggregate( (IRoute <INode <T> >)null, (current, node) => new Route <INode <T> >(node, current))); }
public virtual T Get <T>(string key, bool required) { if (string.IsNullOrWhiteSpace(key)) { throw new ArgumentNullException(nameof(key)); } if (!TryGetBaseValue(key, out string value)) { if (required) { throw new AppSettingNotFoundException(key); } else { return(default(T)); } } return(_parser.Parse <T>(value)); }
public static IValueParser <Tuple <bool, T> > Create <T>(IValueParser <T> typeParser) { if (typeParser == null) { throw new ArgumentNullException(nameof(typeParser)); } return (ValueParser.Create((argName, value, culture) => value == null ? Tuple.Create <bool, T>(false, default !) : Tuple.Create(true, typeParser.Parse(argName, value, culture)))); }
public object Parse(bool hasValue, string argName, string value) { if (!hasValue) { return(Tuple.Create <bool, T>(false, default)); } if (value == null) { return(Tuple.Create <bool, T>(true, default)); } return(Tuple.Create(true, (T)_typeParser.Parse(argName, value))); }
public object Parse(bool hasValue, string argName, string value) { if (!hasValue) { return(false, default(T)); } if (value == null) { return(true, default(T)); } return(true, (T)_typeParser.Parse(argName, value)); }
public static string ApplyParsers(this string ext) { IValueParser interpreter = ValueParsers.GetParsers().FirstOrDefault(p => p.CheckSyntax(ext)); ext = Regex.Replace(ext, "^\\[(.*)\\]", "$1"); if (interpreter == null) { return(ext); } else { return(interpreter.Parse(ext).ApplyParsers()); } }
public bool Load(ref object fieldValue, ConfigNode node, OperationContext context) { node.ThrowIfNullArgument(nameof(node)); string value = node.GetValue(name); if (value.IsNull()) { return(false); } fieldValue = parser.Parse(value); return(true); }
public DirectoryScanResult ScanDirectory(string directoryPath) { var filesToScan = _getFilesToProcess(directoryPath); Console.WriteLine($"Found {filesToScan.Count} files to process."); var result = new DirectoryScanResult(); foreach (var file in filesToScan) { try { var directories = ImageMetadataReader.ReadMetadata(file); var subIfdDirectory = directories.OfType <ExifSubIfdDirectory>().FirstOrDefault(); var dateTakenText = subIfdDirectory?.Tags?.FirstOrDefault(x => string.Equals(x.Name, ExifDateTimeTagName, StringComparison.OrdinalIgnoreCase))?.Description; DateTime?parsedDateTime = ExifDateTimeParser.Parse(dateTakenText); if (parsedDateTime.HasValue) { if (!result.StartingDate.HasValue || result.StartingDate > parsedDateTime.Value) { result.StartingDate = parsedDateTime.Value; } if (!result.EndingDate.HasValue || result.EndingDate < parsedDateTime.Value) { result.EndingDate = parsedDateTime.Value; } } } catch (ImageProcessingException ex) { Console.WriteLine($"Error while processing the file '{file}': {ex.Message}"); } } return(result); }
public Task <object?> Invoke(ParserState args, IValueParser valueParser) { object?Get(ParameterInfo parameter) { if (!args.HasCurrent) { if (parameter.HasDefaultValue) { return(parameter.DefaultValue); } else { throw new CommandLineException(args, $"missing parameter {parameter.Name} for command {this.Name}."); } } return(valueParser.Parse(args, parameter.ParameterType)); } var parameters = Method.GetParameters().Select(Get).ToArray(); return(AsTask(Method.Invoke(instance, parameters))); }
public bool Load(ref object fieldValue, ConfigNode node, OperationContext context) { node.ThrowIfNullArgument(nameof(node)); fieldValue.EnsureArgumentType(listType, nameof(fieldValue)); string[] values = node.GetValues(name); if (values.IsNullOrEmpty()) { return(false); } if (fieldValue.IsNull()) { fieldValue = Activator.CreateInstance(listType); } IList list = (IList)fieldValue; if (context.Operation == Operation.Deserialize) { list.Clear(); } foreach (string value in values) { if (value.IsNull()) { continue; } object parsedValue = parser.Parse(value); if (parsedValue.IsNotNull()) { list.Add(parsedValue); } } return(true); }
public T?Parse(string input) { return(valueParser.Parse(input)); }
public T Parse(string argName, string value, CultureInfo culture) => (T)_inner.Parse(argName, value, culture);
private static Keyframe <T> ParseStaticValue <T>(JsonReader reader, float scale, IValueParser <T> valueParser) { var value = valueParser.Parse(reader, scale); return(new Keyframe <T>(value)); }
/// <summary> /// Parses a range of values. /// </summary> /// <param name="str">The range string.</param> /// <param name="parser">The parser used to parse the values.</param> /// <returns>A list of ints representing the allowed values.</returns> /// <exception cref="System.Exception">If the supplied pattern part is not valid.</exception> private List <int> ParseRange(string str, IValueParser parser) { if (str == "*") { int min = parser.MinValue; int max = parser.MaxValue; List <int> values = new List <int>(max - min + 1); for (int i = min; i <= max; i++) { values.Add(i); } return(values); } var st = str.Split('-'); int size = st.Length; if (size < 1 || size > 2) { throw new Exception("syntax error"); } string v1Str = st[0]; int v1; try { v1 = parser.Parse(v1Str); } catch (Exception e) { throw new Exception("invalid value \"" + v1Str + "\", " + e.Message); } if (size == 1) { List <int> values = new List <int>(1); values.Add(v1); return(values); } else { string v2Str = st[1]; int v2; try { v2 = parser.Parse(v2Str); } catch (Exception e) { throw new Exception("invalid value \"" + v2Str + "\", " + e.Message); } List <int> values = new List <int>(); if (v1 < v2) { for (int i = v1; i <= v2; i++) { values.Add(i); } } else if (v1 > v2) { int min = parser.MinValue; int max = parser.MaxValue; for (int i = v1; i <= max; i++) { values.Add(i); } for (int i = min; i <= v2; i++) { values.Add(i); } } else { // v1 == v2 values.Add(v1); } return(values); } }
void Set(ParserState args, IValueParser valueParser) { var value = valueParser.Parse(args, Property.PropertyType); Property.SetValue(this.instance, value); }
/// <summary> /// beginObject will already be called on the keyframe so it can be differentiated with /// a non animated value. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="composition"></param> /// <param name="reader"></param> /// <param name="scale"></param> /// <param name="valueParser"></param> /// <returns></returns> private static Keyframe <T> ParseKeyframe <T>(LottieComposition composition, JsonReader reader, float scale, IValueParser <T> valueParser) { Vector2? cp1 = null; Vector2? cp2 = null; float startFrame = 0; T startValue = default; var endValue = default(T); var hold = false; IInterpolator interpolator; // Only used by PathKeyframe Vector2?pathCp1 = null; Vector2?pathCp2 = null; reader.BeginObject(); while (reader.HasNext()) { switch (reader.NextName()) { case "t": startFrame = reader.NextDouble(); break; case "s": startValue = valueParser.Parse(reader, scale); break; case "e": endValue = valueParser.Parse(reader, scale); break; case "o": cp1 = JsonUtils.JsonToPoint(reader, scale); break; case "i": cp2 = JsonUtils.JsonToPoint(reader, scale); break; case "h": hold = reader.NextInt() == 1; break; case "to": pathCp1 = JsonUtils.JsonToPoint(reader, scale); break; case "ti": pathCp2 = JsonUtils.JsonToPoint(reader, scale); break; default: reader.SkipValue(); break; } } reader.EndObject(); if (hold) { endValue = startValue; // TODO: create a HoldInterpolator so progress changes don't invalidate. interpolator = LinearInterpolator; } else if (cp1 != null && cp2 != null) { cp1 = new Vector2(MiscUtils.Clamp(cp1.Value.X, -scale, scale), MiscUtils.Clamp(cp1.Value.Y, -MaxCpValue, MaxCpValue)); cp2 = new Vector2(MiscUtils.Clamp(cp2.Value.X, -scale, scale), MiscUtils.Clamp(cp2.Value.Y, -MaxCpValue, MaxCpValue)); var hash = Utils.Utils.HashFor(cp1.Value.X, cp1.Value.Y, cp2.Value.X, cp2.Value.Y); if (GetInterpolator(hash, out var interpolatorRef) == false || interpolatorRef.TryGetTarget(out interpolator) == false) { interpolator = new PathInterpolator(cp1.Value.X / scale, cp1.Value.Y / scale, cp2.Value.X / scale, cp2.Value.Y / scale); try { PutInterpolator(hash, new WeakReference <IInterpolator>(interpolator)); } catch { // It is not clear why but SparseArrayCompat sometimes fails with this: // https://github.com/airbnb/lottie-android/issues/452 // Because this is not a critical operation, we can safely just ignore it. // I was unable to repro this to attempt a proper fix. } } } else { interpolator = LinearInterpolator; } var keyframe = new Keyframe <T>(composition, startValue, endValue, interpolator, startFrame, null) { PathCp1 = pathCp1, PathCp2 = pathCp2 }; return(keyframe); }
/// <summary> /// Parses a range of values. /// </summary> /// <param name="str">The range string.</param> /// <param name="parser">The parser used to parse the values.</param> /// <returns>A list of ints representing the allowed values.</returns> /// <exception cref="System.Exception">If the supplied pattern part is not valid.</exception> private List<int> ParseRange(string str, IValueParser parser) { if (str == "*") { int min = parser.MinValue; int max = parser.MaxValue; List<int> values = new List<int>(max - min + 1); for (int i = min; i <= max; i++) { values.Add(i); } return values; } var st = str.Split('-'); int size = st.Length; if (size < 1 || size > 2) { throw new Exception("syntax error"); } string v1Str = st[0]; int v1; try { v1 = parser.Parse(v1Str); } catch (Exception e) { throw new Exception("invalid value \"" + v1Str + "\", " + e.Message); } if (size == 1) { List<int> values = new List<int>(1); values.Add(v1); return values; } else { string v2Str = st[1]; int v2; try { v2 = parser.Parse(v2Str); } catch (Exception e) { throw new Exception("invalid value \"" + v2Str + "\", " + e.Message); } List<int> values = new List<int>(); if (v1 < v2) { for (int i = v1; i <= v2; i++) { values.Add(i); } } else if (v1 > v2) { int min = parser.MinValue; int max = parser.MaxValue; for (int i = v1; i <= max; i++) { values.Add(i); } for (int i = min; i <= v2; i++) { values.Add(i); } } else { // v1 == v2 values.Add(v1); } return values; } }