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