/// <summary>
/// Create language string resolver that uses a dictionary as a source.
/// </summary>
/// <param name="comparer">(optional) comparer to use</param>
/// <param name="lineFactory">(optional) factory to use when converting line parts</param>
/// <param name="errorHandler">(optional) handler, if null or returns false, then exception is let to be thrown</param>
public StringAsset(IEqualityComparer <ILine> comparer, ILineFactory lineFactory, Func <Exception, bool> errorHandler) : base()
{
this.comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
this.errorHandler = errorHandler;
this.LineFactory = lineFactory;
Load();
}
/// <summary>
/// Try append new <see cref="ILine"/> to <paramref name="previous"/>.
/// </summary>
/// <param name="factory"></param>
/// <param name="previous">(optional) previous part</param>
/// <param name="a0"></param>
/// <param name="a1"></param>
/// <param name="a2"></param>
/// <param name="line">result</param>
/// <typeparam name="Intf"></typeparam>
/// <typeparam name="A0"></typeparam>
/// <typeparam name="A1"></typeparam>
/// <typeparam name="A2"></typeparam>
/// <returns>true if succeeded</returns>
public static bool TryCreate <Intf, A0, A1, A2>(this ILineFactory factory, ILine previous, A0 a0, A1 a1, A2 a2, out Intf line) where Intf : ILine
{
if (factory == null)
{
line = default; return(false);
}
Intf result = default;
if (factory is ILineFactory <Intf, A0, A1, A2> _casted && _casted.TryCreate(factory, previous, a0, a1, a2, out result))
{
line = result; return(true);
}
ILineFactory <Intf, A0, A1, A2> casted;
if (factory is ILineFactoryCastable castable && (casted = castable.Cast <Intf, A0, A1, A2>()) != null && casted.TryCreate(factory, previous, a0, a1, a2, out result))
{
line = result; return(true);
}
ILine result_ = null;
if (factory is ILineFactoryByArgument __casted && __casted.TryCreate(factory, previous, LineArgument.Create <Intf, A0, A1, A2>(a0, a1, a2), out result_) && result_ is Intf result__)
{
line = result__; return(true);
}
line = default;
return(false);
}
/// <summary>
/// Clone <paramref name="line"/>.
/// </summary>
/// <param name="factory"></param>
/// <param name="line"></param>
/// <returns></returns>
/// <exception cref="LineException">on append error</exception>
public static ILine Clone(this ILineFactory factory, ILine line)
{
ILine result = null;
StructList16 <ILine> args = new StructList16 <ILine>();
for (ILine l = line; l != null; l = l.GetPreviousPart())
{
if (l is ILineArgument || l is ILineArgumentEnumerable)
{
args.Add(l);
}
}
for (int i = args.Count - 1; i >= 0; i--)
{
ILine l = args[i];
if (l is ILineArgumentEnumerable enumr)
{
foreach (ILineArgument args_ in enumr)
{
result = factory.Create(result, args_);
}
}
if (l is ILineArgument arg)
{
result = factory.Create(result, arg);
}
}
return(result);
}
/// <summary>
/// Create new .json reader.
/// </summary>
/// <param name="ext"></param>
/// <param name="lineFactory"></param>
public JsonLinesReader(string ext, ILineFactory lineFactory)
{
this.Extension = ext ?? throw new ArgumentNullException(nameof(ext));
this.lineFormat = new LineFormat(" :\\", false, " :\\", false, lineFactory, null) ?? throw new ArgumentNullException(nameof(lineFactory));
this.LineFactory = lineFactory;
lineFactory.TryGetResolver(out resolver);
}
/// <summary>
/// Append
/// </summary>
/// <param name="appender"></param>
/// <param name="previous"></param>
/// <param name="a0"></param>
/// <param name="result"></param>
/// <returns></returns>
public bool TryCreate(ILineFactory appender, ILine previous, A0 a0, out Intf result)
{
var _result = Func(appender, previous, a0);
result = _result;
return(_result != default);
}
/// <summary>
/// Create localization asset with default properties.
/// </summary>
public StringAsset() : base()
{
this.comparer = LineComparer.Default;
this.errorHandler = null;
this.LineFactory = LineAppender.Default;
Load();
}
/// <summary>
/// Append <see cref="StringLocalizerParameter"/>.
/// </summary>
/// <param name="appender"></param>
/// <param name="previous"></param>
/// <param name="parameterName"></param>
/// <param name="parameterValue"></param>
/// <param name="result"></param>
/// <returns></returns>
public virtual bool TryCreate(ILineFactory appender, ILine previous, string parameterName, string parameterValue, out ILineParameter result)
{
// Try resolve
ILineArgument args;
ILine resolved;
if (Resolver.TryResolveParameter(previous, parameterName, parameterValue, out args) && this.TryCreate(previous, args, out resolved) && resolved is ILineParameter castedResolved)
{
// Return as parameter and as resolved instance
result = castedResolved;
return(true);
}
IParameterInfo pi;
if (ParameterInfos.TryGetValue(parameterName, out pi))
{
if (pi.InterfaceType == typeof(ILineHint))
{
result = new StringLocalizerHint(appender, previous, parameterName, parameterValue); return(true);
}
if (pi.InterfaceType == typeof(ILineCanonicalKey))
{
result = new StringLocalizerCanonicalKey(appender, previous, parameterName, parameterValue); return(true);
}
if (pi.InterfaceType == typeof(ILineNonCanonicalKey))
{
result = new StringLocalizerNonCanonicalKey(appender, previous, parameterName, parameterValue); return(true);
}
}
// Return as parameter
result = new StringLocalizerParameter(appender, previous, parameterName, parameterValue);
return(true);
}
/// <summary>
/// Append new <see cref="ILine"/> to <paramref name="previous"/>.
/// </summary>
/// <param name="factory"></param>
/// <param name="a0"></param>
/// <param name="a1"></param>
/// <param name="a2"></param>
/// <param name="previous">(optional) previous part</param>
/// <typeparam name="Intf"></typeparam>
/// <typeparam name="A0"></typeparam>
/// <typeparam name="A1"></typeparam>
/// <typeparam name="A2"></typeparam>
/// <returns>Line</returns>
/// <exception cref="LineException">If part could not append <typeparamref name="Intf"/></exception>
public static Intf Create <Intf, A0, A1, A2>(this ILineFactory factory, ILine previous, A0 a0, A1 a1, A2 a2) where Intf : ILine
{
if (factory == null)
{
throw new LineException(previous, "Appender is not found.");
}
Intf result = default;
if (factory is ILineFactory <Intf, A0, A1, A2> _casted && _casted.TryCreate(factory, previous, a0, a1, a2, out result))
{
return(result);
}
ILineFactory <Intf, A0, A1, A2> casted;
if (factory is ILineFactoryCastable castable && (casted = castable.Cast <Intf, A0, A1, A2>()) != null && casted.TryCreate(factory, previous, a0, a1, a2, out result))
{
return(result);
}
ILine result_ = null;
if (factory is ILineFactoryByArgument __casted && __casted.TryCreate(factory, previous, LineArgument.Create <Intf, A0, A1, A2>(a0, a1, a2), out result_) && result_ is Intf result__)
{
return(result__);
}
throw new LineException(previous, $"Appender doesn't have capability to append {nameof(Intf)}.");
}
/// <summary>
/// Convenience constructor that adds one lines source <paramref name="reader"/>.
///
/// <paramref name="reader"/> must implement one of:
/// <list type="bullet">
/// <item>IEnumerable>KeyValuePair>ILine, IString<<</item>
/// <item>IEnumerable>KeyValuePair>string, IString<<</item>
/// <item>IEnumerable>KeyValuePair>ILine, string<<</item>
/// <item>IEnumerable>KeyValuePair>string, string<<</item>
/// <item>IEnumerable>ILineTree<</item>
/// </list>
/// </summary>
/// <param name="reader">initial reader</param>
/// <param name="lineFormat"></param>
/// <param name="comparer">(optional) comparer to use</param>
/// <param name="errorHandler">(optional) handler, if null or returns false, then exception is let to be thrown</param>
public StringAsset(IEnumerable reader, ILineFormat lineFormat = default, IEqualityComparer <ILine> comparer = default, Func <Exception, bool> errorHandler = null) : base()
{
this.comparer = comparer ?? LineComparer.Default;
this.errorHandler = errorHandler;
this.LineFactory = LineAppender.Default;
Add(reader ?? throw new ArgumentNullException(nameof(reader)), lineFormat);
Load();
}
/// <summary>
/// Create new xml reader
/// </summary>
/// <param name="extension"></param>
/// <param name="lineFactory">Line factory that converts parameters into <see cref="ILine"/>s.</param>
/// <param name="xmlReaderSettings"></param>
public XmlLinesReader(string extension, ILineFactory lineFactory, XmlReaderSettings xmlReaderSettings = default)
{
this.Extension = extension;
this.xmlReaderSettings = xmlReaderSettings ?? CreateXmlReaderSettings();
this.LineFactory = lineFactory ?? throw new ArgumentNullException(nameof(lineFactory));
// Extract resolver from line factory
lineFactory.TryGetResolver(out resolver);
}
/// <summary>
/// Get parameter infos
/// </summary>
/// <param name="lineFactory"></param>
/// <param name="parameterInfos"></param>
/// <returns></returns>
public static bool TryGetParameterInfos(this ILineFactory lineFactory, out IParameterInfos parameterInfos)
{
if (lineFactory is ILineFactoryParameterInfos lineFactory1 && lineFactory1.ParameterInfos != null)
{
parameterInfos = lineFactory1.ParameterInfos; return(true);
}
parameterInfos = default;
return(false);
}
/// <summary>
/// Get associated resolver.
/// </summary>
/// <param name="lineFactory"></param>
/// <param name="resolver"></param>
/// <returns></returns>
public static bool TryGetResolver(this ILineFactory lineFactory, out IResolver resolver)
{
if (lineFactory is ILineFactoryResolver lineFactory1 && lineFactory1.Resolver != null)
{
resolver = lineFactory1.Resolver; return(true);
}
resolver = default;
return(false);
}
/// <summary>
/// Create new ini file reader.
/// </summary>
/// <param name="ext"></param>
/// <param name="lineFactory"></param>
public IniLinesReader(string ext, ILineFactory lineFactory)
{
this.Extension = ext ?? throw new ArgumentNullException(nameof(ext));
this.LineFactory = lineFactory ?? throw new ArgumentNullException(nameof(LineFactory));
this.escaper_section = new LineFormat("\\:[]", true, "\\:[]", true, lineFactory, null);
this.escaper_key = new LineFormat("\\:= ", true, "\\:= ", true, lineFactory, null);
this.LineFactory = lineFactory;
lineFactory.TryGetResolver(out resolver);
}
public bool TryCreate(
ILineFactory factory,
ILine previous,
string parameterName,
string parameterValue,
out ILineCanonicalKey line)
{
line = new LineCanonicalKey(factory, previous, parameterName, parameterValue);
return(true);
}
/// <summary>
/// Clone <see cref="ILineKey"/> parts.
/// </summary>
/// <param name="line"></param>
/// <param name="appender">(optional) appender to use for clone. If null uses the appender of <paramref name="line"/></param>
/// <param name="parameterInfos">(optional) for checking which parameters are keys</param>
/// <returns>clone of key parts</returns>
/// <exception cref="LineException">If cloning failed.</exception>
public static ILine CloneKey(this ILine line, ILineFactory appender = default, IParameterInfos parameterInfos = null)
{
if (appender == null)
{
appender = line.GetAppender();
}
ILine result = null;
if (parameterInfos == null)
{
appender.TryGetParameterInfos(out parameterInfos);
}
StructList16 <ILine> args = new StructList16 <ILine>();
for (ILine l = line; l != null; l = l.GetPreviousPart())
{
if (l is ILineArgument || l is ILineArgumentEnumerable)
{
args.Add(l);
}
}
for (int i = args.Count - 1; i >= 0; i--)
{
ILine l = args[i];
if (l is ILineParameterEnumerable lineParameters)
{
foreach (ILineParameter lineParameter in lineParameters)
{
if (lineParameter.IsCanonicalKey(parameterInfos))
{
result = appender.Create <ILineCanonicalKey, string, string>(result, lineParameter.ParameterName, lineParameter.ParameterValue);
}
else if (lineParameter.IsNonCanonicalKey(parameterInfos))
{
result = appender.Create <ILineNonCanonicalKey, string, string>(result, lineParameter.ParameterName, lineParameter.ParameterValue);
}
}
}
if (l is ILineParameter parameter)
{
if (parameter.IsCanonicalKey(parameterInfos))
{
result = appender.Create <ILineCanonicalKey, string, string>(result, parameter.ParameterName, parameter.ParameterValue);
}
else if (parameter.IsNonCanonicalKey(parameterInfos))
{
result = appender.Create <ILineNonCanonicalKey, string, string>(result, parameter.ParameterName, parameter.ParameterValue);
}
}
}
return(result ?? appender.Create <ILinePart>(null));
}
public SessionDrawer(ISessionCircleFactory sessionCircleFactory, ISessionCircleList sessionCircles, ILineFactory lineFactory,
ICanvasWrapper canvas, ISessionDetail sessionDetail)
{
this.sessionCircleFactory = sessionCircleFactory;
this.sessionCircles = sessionCircles;
this.lineFactory = lineFactory;
this.canvas = canvas;
this.sessionDetail = sessionDetail;
this.canvas.OnMouseMove(MouseMove);
this.canvas.OnMouseUp(EndMove);
}
/// <summary>
/// Get appender from <paramref name="part"/>.
/// If its null, follows to previous part.
/// </summary>
/// <param name="part"></param>
/// <param name="appender"></param>
/// <returns>true if appender was found</returns>
public static bool TryGetAppender(this ILine part, out ILineFactory appender)
{
for (ILine p = part; p != null; p = p.GetPreviousPart())
{
if (p is ILineAppendable appendable && appendable.Appender != null)
{
appender = appendable.Appender; return(true);
}
}
appender = default;
return(false);
}
public bool TryCreate(ILineFactory factory, ILine previous, ILineArgument arguments, out ILine line)
{
ILine result = previous;
foreach (var f in factories)
{
if (!f.TryCreate(factory, result, arguments, out result))
{
line = default; return(false);
}
}
line = result;
return(true);
}
/// <summary>
/// Append enumeration of parameters and keys.
/// </summary>
/// <param name="part"></param>
/// <param name="parameters">enumeration of parameters to append</param>
/// <param name="parameterInfos">(optional) instructions on whether to instantiate as parameter or key. See ParameterInfos.Default for default configuration</param>
/// <returns>new key that is appended to this key</returns>
/// <exception cref="LineException">If key doesn't implement ILineParameterAssignable, or append failed</exception>
public static ILine Parameters(this ILine part, IEnumerable <KeyValuePair <string, string> > parameters, IParameterInfos parameterInfos)
{
ILineFactory appender = part.GetAppender();
foreach (var parameter in parameters)
{
if (parameter.Key == null)
{
continue;
}
part = part.Parameter(parameter.Key, parameter.Value, parameterInfos);
}
return(part);
}
/// <summary>
/// Append enumeration of parameters.
/// </summary>
/// <param name="part"></param>
/// <param name="parameters">enumeration of parameters to append</param>
/// <returns>new key that is appended to this key</returns>
/// <exception cref="LineException">If key doesn't implement ILineParameterAssignable, or append failed</exception>
public static ILine Parameters(this ILine part, IEnumerable <KeyValuePair <string, string> > parameters)
{
ILineFactory appender = part.GetAppender();
if (appender == null)
{
throw new LineException(part, "Appender is not found.");
}
foreach (var parameter in parameters)
{
part = appender.Create <ILineParameter, string, string>(part, parameter.Key, parameter.Value);
}
return(part);
}
/// <summary>
/// Create inlined <paramref name="subkey"/> resource.
/// </summary>
/// <param name="lineFactory"></param>
/// <param name="subkey">subkey in parametrized format, e.g. "Culture:en"</param>
/// <param name="value">(optional) value to append, if null removes previously existing the inline</param>
/// <returns>new line with inlines or <paramref name="lineFactory"/></returns>
/// <exception cref="LineException">If key can't be inlined.</exception>
public static ILine Inline(this ILineFactory lineFactory, ILine subkey, byte[] value)
{
ILineInlines inlines = lineFactory.Create <ILineInlines>(null);
if (value != null)
{
subkey = subkey.Resource(value);
}
if (subkey != null)
{
inlines[subkey] = subkey;
}
return(inlines);
}
/// <summary>
/// Create a clone of <paramref name="previous"/>'s appender, and add new components to it.
/// </summary>
/// <param name="previous">previous part</param>
/// <param name="appender">appender to add</param>
/// <param name="policy">add policy</param>
/// <returns>part with another appender</returns>
public static ILine AddAppender(this ILine previous, ILineFactory appender, LineFactoryAddPolicy policy = LineFactoryAddPolicy.OverwriteIfExists)
{
ILineFactory previousAppender;
if (previous.TryGetAppender(out previousAppender))
{
ILineFactory newAppender = previousAppender == null ? appender : (ILineFactory) new LineFactoryComposition().Add(previousAppender, policy).Add(appender, policy);
return(newAppender.Create <ILinePart>(previous));
}
else
{
return(appender.Create <ILinePart>(previous));
}
}
/// <summary>
/// Read key from <paramref name="element"/>.
/// </summary>
/// <param name="element"></param>
/// <param name="parent"></param>
/// <param name="_lineFactory"></param>
/// <returns>key or null</returns>
public ILine ReadKey(XElement element, ILineTree parent, ILineFactory _lineFactory)
{
ILine result = null;
// <line type="MyClass" type="something" key="something">
if (element.Name == NameLine || element.Name == NameRoot)
{
result = null;
}
// <type:MyClass>
else if (element.Name.NamespaceName != null && element.Name.NamespaceName.StartsWith(URN_))
{
string parameterName = element.Name.NamespaceName.Substring(URN_.Length);
string parameterValue = element.Name.LocalName;
result = Append(parent, _lineFactory, result, parameterName, parameterValue);
}
else
{
return(null);
}
// Read attributes
if (element.HasAttributes)
{
foreach (XAttribute attribute in element.Attributes())
{
if (string.IsNullOrEmpty(attribute.Name.NamespaceName))
{
string parameterName = attribute.Name.LocalName;
string parameterValue = attribute.Value;
if (parameterName.StartsWith("xml"))
{
continue;
}
Match m = occuranceIndexParser.Match(parameterName);
Group g_name = m.Groups["name"];
if (m.Success && g_name.Success)
{
parameterName = g_name.Value;
}
// Append parameter
result = Append(parent, _lineFactory, result, parameterName, parameterValue);
}
}
}
return(result);
}
/// <summary>
/// Inline <paramref name="value"/> to <paramref name="culture"/>.
/// </summary>
/// <param name="lineFactory"></param>
/// <param name="culture">subkey in parametrized format, e.g. "Culture:en", or "Culture:en:N:One"</param>
/// <param name="value">(optional) value to append, if null removes previously existing the inline</param>
/// <returns>new line with inlines or <paramref name="lineFactory"/></returns>
/// <exception cref="LineException">If key can't be inlined.</exception>
public static ILine InlineCulture(this ILineFactory lineFactory, string culture, IString value)
{
ILineInlines inlines = lineFactory.Create <ILineInlines>(null);
ILine subkey = lineFactory.Create <ILineNonCanonicalKey, string, string>(null, "Culture", culture);
if (value != null)
{
subkey = subkey.String(value);
}
if (subkey != null)
{
inlines[subkey] = subkey;
}
return(inlines);
}
/// <summary>
/// Append <see cref="StringLocalizerHint"/>.
/// </summary>
/// <param name="appender"></param>
/// <param name="previous"></param>
/// <param name="parameterName"></param>
/// <param name="parameterValue"></param>
/// <param name="result"></param>
/// <returns></returns>
public virtual bool TryCreate(ILineFactory appender, ILine previous, string parameterName, string parameterValue, out ILineHint result)
{
// Try resolve
ILineArgument args;
ILine resolved;
if (Resolver.TryResolveParameter(previous, parameterName, parameterValue, out args) && this.TryCreate(previous, args, out resolved) && resolved is ILineHint castedResolved)
{
// Return as parameter and as resolved instance
result = castedResolved;
return(true);
}
result = new StringLocalizerHint(appender, previous, parameterName, parameterValue);
return(true);
}
/// <summary>
/// Create line (part) with <paramref name="arguments"/>.
/// </summary>
/// <param name="factory"></param>
/// <param name="previous"></param>
/// <param name="arguments"></param>
/// <returns>appended part</returns>
/// <exception cref="LineException">If append failed due to unexpected reason</exception>
public static ILine Create(this ILineFactory factory, ILine previous, ILineArgument arguments)
{
ILine result = null;
if (factory.TryCreate(previous, arguments, out result))
{
return(result);
}
ILineFactoryByArgument argumentAdapter;
if (LineFactoryByArgumentAdapter.Default.TryGet(arguments.GetType(), out argumentAdapter) && argumentAdapter.TryCreate(factory, previous, arguments, out result))
{
return(result);
}
throw new LineException(arguments, "Could not be appended");
}
public bool TryCreate(ILineFactory factory, ILine previous, ILineArgument arguments, out ILine line)
{
if (arguments is ILineArgument <Intf> )
{
Intf result;
if (factory is ILineFactory <Intf> casted && casted.TryCreate(factory, previous, out result))
{
line = result; return(true);
}
ILineFactory <Intf> _casted;
if (factory is ILineFactoryCastable castable && ((_casted = castable.Cast <Intf>()) != null) && _casted.TryCreate(factory, previous, out result))
{
line = result; return(true);
}
}
line = default;
return(false);
}
/// <summary>
/// Create line (part) with <paramref name="arguments"/>.
/// </summary>
/// <param name="factory"></param>
/// <param name="previous"></param>
/// <param name="arguments"></param>
/// <param name="line"></param>
/// <returns>try if create succeeded</returns>
/// <exception cref="LineException">If append failed due to unexpected reason</exception>
public static bool TryCreate(this ILineFactory factory, ILine previous, ILineArgument arguments, out ILine line)
{
if (factory == null)
{
line = previous; return(false);
}
if (factory is ILineFactoryByArgument argFactory && argFactory.TryCreate(factory, previous, arguments, out line))
{
return(true);
}
ILineFactoryByArgument argumentAdapter;
if (LineFactoryByArgumentAdapter.Default.TryGet(arguments.GetType(), out argumentAdapter) && argumentAdapter.TryCreate(factory, previous, arguments, out line))
{
return(true);
}
line = default;
return(false);
}
/// <summary>
/// Append <paramref name="right"/> to <paramref name="left"/>.
/// </summary>
/// <param name="factory"></param>
/// <param name="left">part to append to</param>
/// <param name="right"></param>
/// <param name="result"></param>
/// <returns></returns>
/// <exception cref="LineException">on append error</exception>
public static bool TryConcat(this ILineFactory factory, ILine left, ILine right, out ILine result)
{
if (factory == null)
{
result = left; return(false);
}
ILine _result = left;
StructList16 <ILine> _args = new StructList16 <ILine>();
for (ILine l = right; l != null; l = l.GetPreviousPart())
{
if (l is ILineArgument || l is ILineArgumentEnumerable)
{
_args.Add(l);
}
}
for (int i = _args.Count - 1; i >= 0; i--)
{
ILine l = _args[i];
if (l is ILineArgumentEnumerable enumr)
{
foreach (ILineArgument args_ in enumr)
{
if (!factory.TryCreate(args_, out _result))
{
result = null; return(false);
}
}
}
if (l is ILineArgument args)
{
if (!factory.TryCreate(args, out _result))
{
result = null; return(false);
}
}
}
result = _result;
return(false);
}
/// <summary>
/// Append value to <paramref name="prev"/>>
/// </summary>
/// <param name="parent"></param>
/// <param name="_lineFactory"></param>
/// <param name="prev">(optional)</param>
/// <param name="parameterName"></param>
/// <param name="parameterValue"></param>
/// <returns></returns>
ILine Append(ILineTree parent, ILineFactory _lineFactory, ILine prev, string parameterName, string parameterValue)
{
if (parameterName == "String")
{
IStringFormat stringFormat;
if (parent.TryGetStringFormat(resolver, out stringFormat))
{
IString valueString = stringFormat.Parse(parameterValue);
return(LineFactory.Create <ILineString, IString>(prev, valueString));
}
else
{
return(LineFactory.Create <ILineHint, string, string>(prev, "String", parameterValue));
}
}
else
{
return(LineFactory.Create <ILineParameter, string, string>(prev, parameterName, parameterValue));
}
}
