public static DateTimeOffset?AsDateTimeOffset(this TomlValue value) { if (value is TomlDateTimeOffset dateTimeOffset) { return(dateTimeOffset.Value); } if (value is TomlLocalDateTime dateTime) { return(dateTime.Value); } if (value is TomlLocalDate localDate) { return(new DateTime(localDate.Year, localDate.Month, localDate.Day)); } if (value is TomlLocalTime localTime) { return(new DateTime(1, 1, 1, localTime.Hours, localTime.Minutes, localTime.Seconds, localTime.Milliseconds)); } return(null); }
private static void TomlValueToXml(TomlValue value, XmlElement node, XmlDocument document) { if (value is TomlTable table) { XmlElement tableNode = document.CreateElement(table.Name ?? "table"); node.AppendChild(tableNode); foreach (System.Collections.Generic.KeyValuePair <String, TomlValue> i in table.pairs) { TomlValueToXml(i.Key, i.Value, tableNode, document); } } else if (value is TomlArray array) { XmlElement arrayNode = document.CreateElement("items"); node.AppendChild(arrayNode); foreach (TomlValue i in array.Value) { TomlValueToXml("item", i, arrayNode, document); } } else { XmlAttribute attr = document.CreateAttribute("value"); attr.Value = ExtractString(value); node.Attributes.Append(attr); } }
private static String ExtractString(TomlValue value) { if (value is TomlString tomlString) { return(tomlString.Value); } return(value.ToString()); }
public static String AsString(this TomlValue value) { if (value is TomlString tomlString) { return(tomlString.Value); } return(null); }
public static Double?AsDouble(this TomlValue value) { if (value is TomlDouble tomlDouble) { return(tomlDouble.Value); } return(null); }
public static Int64?AsInt(this TomlValue value) { if (value is TomlInt tomlInt) { return(tomlInt.Value); } return(null); }
public static Boolean?AsBoolean(this TomlValue value) { if (value is TomlBool tomlInt) { return(tomlInt.Value); } return(null); }
public static void ToXml(TomlValue value, String resultFile) { XmlDocument document = new XmlDocument(); document.LoadXml($"<?xml version=\"1.0\" encoding=\"UTF-8\"?><root></root>"); TomlValueToXml(value, document.DocumentElement, document); document.Save(resultFile); }
private TomlValue ParsePlus() { TomlValue value = this.ParseValue(); if (value is TomlInt || value is TomlDouble) { return(value); } throw new TomlSemanticException("expected numeric value", this.currentFile, this.currentLine); }
public TomlValue Eval(TomlValue table) { var tomlValue = result?.Eval(table) ?? table; if (tomlValue is TomlTable tomlTable) { return(tomlTable.pairs.ElementAt(index).Value); } else if (tomlValue is TomlArray tomlArray) { return(tomlArray.Value[index]); } throw new TPathException("indexation only support arrays and tables"); }
public TomlValue Eval(TomlValue value) { if (value is TomlTable table) { return(new TomlArray(table.pairs.Values.ToList())); } else { List <TomlValue> result = new List <TomlValue>(); foreach (var item in value.AsList()) { result.AddRange(this.Eval(item).AsList()); } return(new TomlArray(result)); } }
private TomlValue ParseMinus() { TomlValue value = this.ParseValue(); if (value is TomlInt ti) { return(new TomlInt(-ti.Value)); } if (value is TomlDouble td) { return(new TomlDouble(-td.Value)); } throw new TomlSemanticException("expected numeric value", this.currentFile, this.currentLine); }
private static IEnumerable <object> ConvertContent(TomlValue value) { switch (value.Type) { case TomlItemType.Array: foreach (var a in (IEnumerable <ArrayItem>)value.Value) { foreach (var c in a.Before) { yield return(new XComment(c.Text)); } if (a.Value != null) { yield return(new XElement("item", new XAttribute("type", XUtils.GetJsonTypeString(a.Value.Type)), new XAttribute("toml", a.Value.Type.ToString()), ConvertContent(a.Value) )); } foreach (var c in a.After) { yield return(new XComment(c.Text)); } } break; case TomlItemType.InlineTable: foreach (var n in ToXNodes((IEnumerable <KeyValue>)value.Value)) { yield return(n); } break; default: yield return(value.Value); break; } }
private void ParseDottedKeyValuePair(TomlTable parentTable) { String key; TomlTable table = parentTable; while (this.LookMatch(1, TokenType.DOT)) { key = this.Consume(TokenType.BAREKEY).Text; table = this.GetTableOrCreateDottedIfAbsent(key, table); this.Match(TokenType.DOT); } key = this.Consume(TokenType.BAREKEY).Text; this.Consume(TokenType.ASSIGNMENT); // There is no value if (this.Match(TokenType.NL) || this.Match(TokenType.EOF)) { throw new TomlSyntaxException("unspecified value", this.currentFile, this.currentLine); } TomlValue value = this.ParseValue(); if (!this.Match(TokenType.NL) && !this.LookMatch(0, TokenType.EOF)) { throw new TomlSyntaxException("there must be a newline or end of file after a key/value pair", this.currentFile, this.currentLine); } if (parentTable.Contains(key)) { throw new TomlSemanticException($"key '{key}' is already defined in this table", this.currentFile, this.currentLine); } if (table.IsClosed) { throw new TomlSemanticException($"table '{table.Name}' is closed ", this.currentFile, this.currentLine); } table[key] = value; }
public TomlValue Eval(TomlValue value) { if (value is TomlTable table) { if (table.Contains(key)) { return(table[key]); } else { throw new TPathException($"table does not contains key '{this.key}'"); } } if (value is TomlArray array) { return(new TomlArray(array.Value.Select(i => this.Eval(i)).ToList())); } throw new TPathException($"operation . does not supported with type {value.GetType()}"); }
private static void TomlValueToXml(String name, TomlValue value, XmlElement node, XmlDocument document) { XmlElement newNode; if (Lexer.IsValidId(name)) { newNode = document.CreateElement(name); } else { newNode = document.CreateElement("pair"); XmlAttribute attr = document.CreateAttribute("name"); attr.Value = name; newNode.Attributes.Append(attr); } if (value is TomlTable table) { foreach (System.Collections.Generic.KeyValuePair <String, TomlValue> i in table.pairs) { TomlValueToXml(i.Key, i.Value, newNode, document); } } else if (value is TomlArray array) { foreach (TomlValue i in array.Value) { TomlValueToXml("item", i, newNode, document); } } else { XmlAttribute attr = document.CreateAttribute("value"); attr.Value = ExtractString(value); newNode.Attributes.Append(attr); } node.AppendChild(newNode); }
private void ReadKeyValuePair(StringReader reader, out string key, out TomlValue value) { //Read the key key = ReadKey(reader); //Consume the equals sign, potentially with whitespace either side. reader.SkipWhitespace(); if (!reader.ExpectAndConsume('=')) { if (reader.TryPeek(out var shouldHaveBeenEquals)) { throw new TomlMissingEqualsException(_lineNumber, (char)shouldHaveBeenEquals); } throw new TomlEOFException(_lineNumber); } reader.SkipWhitespace(); //Read the value value = ReadValue(reader); }
public ArrayItem(TomlValue value, IEnumerable <Comment> before, IEnumerable <Comment> after) { this.Value = value; this.Before = before ?? Enumerable.Empty <Comment>(); this.After = after ?? Enumerable.Empty <Comment>(); }
public KeyValue(IEnumerable <char> key, TomlValue value, Comment comment) { this.Key = string.Concat(key); this.Value = value; this.Comment = comment; }
private static Color ReadColor(TomlValue value) { float[] floats = MelonPreferences.Mapper.ReadArray <float>(value); if (floats == null || floats.Length != 4) { return(default);
public static List <TomlValue> AsList(this TomlValue value) { return((value as TomlArray).Value); }
public T FromToml <T>(TomlValue value) => TomletMain.To <T>(value);
private static LemonTuple <int, int> ReadLemonTupleInt(TomlValue value) { int[] ints = MelonPreferences.Mapper.ReadArray <int>(value); if (ints == null || ints.Length != 2) { return(default);
public T[] ReadArray <T>(TomlValue value) => TomletMain.To <T[]>(value);
public List <T> ReadList <T>(TomlValue value) => TomletMain.To <List <T> >(value);
public abstract void Load(TomlValue obj);
public static object To(Type what, TomlValue value) { var deserializer = TomlSerializationMethods.GetDeserializer(what) ?? TomlSerializationMethods.GetCompositeDeserializer(what); return(deserializer.Invoke(value)); }
public static T To <T>(TomlValue value) { var deserializer = TomlSerializationMethods.GetDeserializer <T>() ?? TomlSerializationMethods.GetCompositeDeserializer <T>(); return(deserializer.Invoke(value)); }
public static Boolean IsBool(this TomlValue value) { return(value is TomlBool); }
public static string GetUnit(this TomlValue value, string def = "") => value.Unit ?? def;