/// <summary>
/// Converts the string representation of a char to its Char equivalent.
/// </summary>
/// <param name="text">A string that represents the char to convert.</param>
public static Char ToChar(IDeserializer context, ICfgNode node)
{
if (node.Text.Length != 1)
{
throw new ArgumentOutOfRangeException("text", "must contain only one char");
}
return(node.Text[0]);
}
T IDeserializer <T> .Deserialize(IDeserializer context, ICfgNode cfgNode)
{
return(new T()
{
F1 = context.Deserialize <string>(cfgNode.NestedByName("F1").FirstOrDefault()) + "attr",
F2 = context.Deserialize <int>(cfgNode.NestedByName("F2").FirstOrDefault()) + 10
});
}
/// <summary>
/// Converts the specified string representation of a date and time to its System.DateTime equivalent.
/// </summary>
public static DateTime ToDateTime(IDeserializer context, ICfgNode node)
{
return(DateTime.Parse(node.Text, _ci,
DateTimeStyles.AdjustToUniversal |
DateTimeStyles.AllowWhiteSpaces |
DateTimeStyles.AssumeUniversal |
DateTimeStyles.NoCurrentDateDefault));
}
/// <summary>
/// Convert text to Nullable[Int32]
/// </summary>
public static Int32?ToNInt32(IDeserializer context, ICfgNode node)
{
if (string.IsNullOrWhiteSpace(node.Text))
{
return(null);
}
return(ToInt32(context, node));
}
/// <summary>
/// Convert text to Nullable[UInt64]
/// </summary>
public static UInt64?ToNUInt64(IDeserializer context, ICfgNode node)
{
if (string.IsNullOrWhiteSpace(node.Text))
{
return(null);
}
return(ToUInt64(context, node));
}
/// <summary>
/// Convert text to Nullable[TimeSpan]
/// </summary>
public static TimeSpan?ToNTimeSpan(IDeserializer context, ICfgNode node)
{
if (string.IsNullOrWhiteSpace(node.Text))
{
return(null);
}
return(ToTimeSpan(context, node));
}
/// <summary>
/// Convert text to Nullable[DateTime]
/// </summary>
public static DateTime?ToNDateTime(IDeserializer context, ICfgNode node)
{
if (string.IsNullOrWhiteSpace(node.Text))
{
return(null);
}
return(ToDateTime(context, node));
}
public ICfgNode CfgNodeConverter(string name, ICfgNode candidate)
{
if (!NameComparer.Equals(name, "variable"))
return new CfgNodeWrapper(candidate, this);
var varConfig = DefaultDeserializer.Instance.Deserialize<VariableConfig>(candidate);
this[varConfig.Name] = varConfig.Value;
return null;
}
public static T?ToNullableEnum <T>(IDeserializer context, ICfgNode node) where T : struct
{
if (string.IsNullOrWhiteSpace(node.Text))
{
return(null);
}
return(EnumHelper <T> .Parse(node.Text));
}
/// <summary>
/// Convert text to Nullable[Guid]
/// </summary>
public static Guid?ToNGuid(IDeserializer context, ICfgNode node)
{
if (string.IsNullOrWhiteSpace(node.Text))
{
return(null);
}
return(ToGuid(context, node));
}
private static NameValueCollection getNameValueCollection(ICfgNode node)
{
var result = new NameValueCollection();
foreach (var pair in node.Nested)
{
result.Add(pair.Key, pair.Value.Text);
}
return(result);
}
/// <summary>
/// Converts the specified string representation of a logical value to its System.Boolean equivalent.
/// Support formats: true/false, t/f, yes/no, y/n, 1/0, +/- in case insensitivity.
/// </summary>
public static bool ToBoolean(IDeserializer context, ICfgNode node)
{
bool result;
if (_booleanMap.TryGetValue(node.Text, out result))
{
return(result);
}
throw new FormatException(string.Format("can not convert '{0}' to a boolean type", node.Text));
}
public T Deserialize <T>(IDeserializer context, ICfgNode node)
{
object deserialize;
if (_funcMap.TryGetValue(typeof(T), out deserialize))
{
return(((ChildDeserializeDefinition <T>)deserialize)(new Context(_parent, context), node));
}
return(_parent.Deserialize <T>(context, node));
}
public ICfgNode CfgNodeConverter(string name, ICfgNode candidate)
{
if (!NameComparer.Equals(name, "variable"))
{
return(new CfgNodeWrapper(candidate, this));
}
var varConfig = DefaultDeserializer.Instance.Deserialize <VariableConfig>(candidate);
this[varConfig.Name] = varConfig.Value;
return(null);
}
static void TestRoundTrip <T>(
string source,
ICfgNode expected,
TokenListParser <ScriptToken, T> parser,
bool pretty = false) where T : ICfgNode
{
var parsed = TestParse(source, expected, parser);
var visitor = new FormatScriptVisitor {
PrettyPrint = pretty, WrapStatements = false
};
parsed.Accept(visitor);
Assert.Equal(source, visitor.Code);
}
public Sequence(IEnumerable <ICfgNode> nodes, ICfgNode newNode)
{
if (nodes == null)
{
throw new ArgumentNullException(nameof(nodes));
}
if (newNode == null)
{
throw new ArgumentNullException(nameof(newNode));
}
var builder = ImmutableArray.CreateBuilder <ICfgNode>();
builder.AddRange(nodes);
builder.Add(newNode);
Nodes = builder.ToImmutable();
}
internal static List <T> ToList <T>(IDeserializer context, string name, ICfgNode node)
{
int i = 0;
try
{
List <T> result = new List <T>();
foreach (var chItem in node.NestedByName(name))
{
result.Add(context.Deserialize <T>(context, chItem));
i++;
}
return(result);
}
catch (Exception ex)
{
throw new DeserializeChildException(string.Format("{0}[{1}]", name, i), ex);
}
}
static T TestParse <T>(string source, ICfgNode expected, TokenListParser <ScriptToken, T> parser) where T : ICfgNode
{
var tokens = ScriptTokenizer.Tokenize(source);
if (!tokens.HasValue)
{
throw new InvalidOperationException(
$"Tokenization failure: {tokens.ErrorMessage} at {tokens.ErrorPosition}");
}
var filtered = ScriptParser.FilterTokens(tokens.Value);
var parsed = parser.TryParse(filtered);
if (!parsed.HasValue)
{
throw new InvalidOperationException($"Parse failure: {parsed}");
}
Assert.Equal(expected, parsed.Value);
return(parsed.Value);
}
/// <summary>
/// creates a collection of includes configuration
/// </summary>
/// <param name="source">parent settings</param>
/// <param name="config">include configuration node</param>
/// <returns>collection of includes configuration</returns>
public IEnumerable<IIdentifiedSource> CreateSettings(IAppSettings source, ICfgNode config)
{
var rpo = source as IFilePathOwner;
var cfg = Deserializer.Deserialize<IncludeFileConfig>(config);
OnFindingSettings(source, cfg);
if (Path.IsPathRooted(cfg.Path))
{
if (!File.Exists(cfg.Path) && !cfg.Required)
yield break;
yield return CreateFileSetting(cfg.Path);
yield break;
}
// relative path
if (rpo == null)
throw new InvalidOperationException("can not be searched for a relative path because the settings do not provide an absolute path");
var found = SearchSettings(rpo.Path, cfg.Path, cfg.Search);
if (found.Count == 0)
{
if (cfg.Required)
throw new ApplicationException(string.Format("configuration file '{0}' not found in '{1}'", cfg.Path, rpo.Path));
yield break;
}
if (cfg.Include == IncludeMode.First)
yield return found.First();
else if (cfg.Include == IncludeMode.Last)
yield return found.Last();
else
foreach (var item in found)
yield return item;
}
internal static T ReadField <T>(IDeserializer context, string name, ICfgNode node, bool required)
{
try
{
var field = node.NestedByName(name).FirstOrDefault();
if (field == null)
{
if (required)
{
throw new FormatException("field not found");
}
else
{
return(default(T));
}
}
return(context.Deserialize <T>(context, field));
}
catch (Exception ex)
{
throw new DeserializeChildException(name, ex);
}
}
protected virtual ICfgNode Build(Statement statement)
{
statement.Head.Accept(this);
var head = Result;
ICfgNode[] parts = null;
for (var index = 0; index < statement.Parameters.Length; index++)
{
statement.Parameters[index].Accept(this);
if (parts == null)
{
if (Result == null)
{
continue;
}
parts = new ICfgNode[statement.Parameters.Length];
for (int i = 0; i < index; i++)
{
parts[i] = statement.Parameters[i];
}
}
parts[index] = Result ?? statement.Parameters[index];
}
if (head == null && parts == null)
{
return(null);
}
head ??= statement.Head;
parts ??= statement.Parameters;
return(Emit.Statement(head, parts));
}
public static T ToEnum <T>(IDeserializer context, ICfgNode node) where T : struct
{
return(EnumHelper <T> .Parse(node.Text));
}
private static string NativeConverter(IDeserializer context, ICfgNode node)
{
return(node.Text);
}
private static NameValueCollection GetNameValueCollection(ICfgNode node)
{
var result = new NameValueCollection();
foreach (var pair in node.GetNodes())
result.Add(pair.Key, pair.Value.As<string>());
return result;
}
/// <summary>
/// returns the origin string
/// </summary>
public static string ToString(IDeserializer context, ICfgNode node)
{
return(node.Text);
}
/// <summary>
/// Converts the string representation of a GUID to the equivalent System.Guid structure.
/// </summary>
public static Guid ToGuid(IDeserializer context, ICfgNode node)
{
return(Guid.Parse(node.Text));
}
/// <summary>
/// Converts the string representation of a number to its System.Byte equivalent.
/// </summary>
public static Byte ToByte(IDeserializer context, ICfgNode node)
{
return(Byte.Parse(node.Text, _ci));
}
/// <summary>
/// Converts the string representation of a number to its double-precision floating-point number equivalent.
/// </summary>
public static Double ToDouble(IDeserializer context, ICfgNode node)
{
return(Double.Parse(node.Text, _ci));
}
/// <summary>
/// Converts the string representation of a number to its System.Decimal number equivalent.
/// </summary>
public static Decimal ToDecimal(IDeserializer context, ICfgNode node)
{
return(Decimal.Parse(node.Text, _ci));
}
/// <summary>
/// Converts the string representation of a number to its single-precision floating-point number equivalent.
/// </summary>
public static Single ToSingle(IDeserializer context, ICfgNode node)
{
return(Single.Parse(node.Text, _ci));
}
/// <summary>
/// Converts the string representation of a number to its 64-bit signed integer equivalent.
/// </summary>
public static Int64 ToInt64(IDeserializer context, ICfgNode node)
{
return(Int64.Parse(node.Text, _ci));
}
/// <summary>
/// Converts the string representation of a number to its 32-bit unsigned integer equivalent.
/// </summary>
public static UInt32 ToUInt32(IDeserializer context, ICfgNode node)
{
return(UInt32.Parse(node.Text, _ci));
}
private static NameValueCollection getNameValueCollection(ICfgNode node)
{
var result = new NameValueCollection();
foreach (var pair in node.Nested)
result.Add(pair.Key, pair.Value.Text);
return result;
}
/// <summary>
/// Converts the string representation of a time interval to its System.TimeSpan equivalent.
/// </summary>
public static TimeSpan ToTimeSpan(IDeserializer context, ICfgNode node)
{
return(TimeSpan.Parse(node.Text, _ci));
}
public CfgNodeWrapper(ICfgNode wrapped, VariableStorage variableStorage)
{
_wrapped = wrapped;
_variableStorage = variableStorage;
}
public IEnumerable<IIdentifiedSource> CreateSettings(IAppSettings source, ICfgNode config)
{
Configs.Add(Global.GenericDeserializer.Deserialize<IncludeFileConfig>(config));
yield break;
}
