public TomlSettingsBuilder(TomlSettings settings)
{
Assert(settings != null);
this.settings = settings;
this.AllowImplicitConversions(ConversionSets.Default);
}
public TypeSettingsBuilder(TomlSettings settings, List <ITomlConverter> converters)
{
Assert(settings != null);
Assert(converters != null);
this.settings = settings;
this.converters = converters;
}
public static TomlTable ReadStream(Stream stream, TomlSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
return(StreamTomlSerializer.Deserialize(stream, settings));
}
/// <summary>
/// Creates a empty TOML table.
/// </summary>
/// <param name="settings">The config to use, to create the table.</param>
/// <returns>A new empty table created with the given config.</returns>
/// <exception cref="ArgumentNullException">*config* is **null**.</exception>
/// <remarks>[!include[_](../specs/toml-create-remarks.md)]</remarks>
public static TomlTable Create(TomlSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
return(new TomlTable.RootTable(settings));
}
public static TomlSettings Create(Action <ITomlSettingsBuilder> cfg)
{
var config = new TomlSettings();
var builder = new TomlSettingsBuilder(config);
cfg(builder);
builder.SetupConverters();
return(config);
}
/// <summary>
/// Reads the TOML contents from some file and converts it to a CLR object.
/// </summary>
/// <typeparam name="T">The type of the CLR object.</typeparam>
/// <param name="filePath">The absolute or relative path to the file.</param>
/// <param name="settings">The settings used to process the TOML content.</param>
/// <returns>A CLR object representing the TOML contents of the file.</returns>
/// <exception cref="ArgumentNullException">If *filePath* is **null**.</exception>
/// <exception cref="ArgumentNullException">If *settings* is **null**</exception>
public static T ReadFile <T>(string filePath, TomlSettings settings)
{
filePath.CheckNotNull(nameof(filePath));
settings.CheckNotNull(nameof(settings));
var tt = ReadFile(filePath, settings);
return(tt.Get <T>());
}
/// <summary>
/// Reads the TOML contents from some file and maps it into a TomlTable structure.
/// </summary>
/// <param name="filePath">The absolute or relative path to the file.</param>
/// <param name="settings">The settings used to process the TOML content.</param>
/// <returns>A <see cref="TomlTable"/>corresponding to the file content.</returns>
public static TomlTable ReadFile(string filePath, TomlSettings settings)
{
filePath.CheckNotNull(nameof(filePath));
settings.CheckNotNull(nameof(settings));
using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
{
return(StreamTomlSerializer.Deserialize(fs, settings));
}
}
public RootTable(TomlSettings settings)
: base(null)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
this.settings = settings;
}
internal static RootTable From <T>(TomlSettings settings, T obj)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
if ((object)obj is RootTable rt)
{
return(rt);
}
var tt = new RootTable(settings);
if ((object)obj is IDictionary dict)
{
CreateFromDictionary();
}
else
{
CreateFromCustomClrObject();
}
return(tt);
void CreateFromDictionary()
{
foreach (DictionaryEntry r in dict)
{
tt.AddRow(new TomlKey((string)r.Key), TomlObject.CreateFrom(tt, r.Value));
}
}
void CreateFromCustomClrObject()
{
var t = obj.GetType();
var members = settings.GetSerializationMembers(t);
foreach (var m in members)
{
object val = m.GetValue(obj);
if (val != null)
{
TomlObject to = TomlObject.CreateFrom(tt, val);
to.AddComments(settings.GetComments(t, m.Member));
tt.AddRow(m.Key, to);
}
}
}
}
public static T ReadStream <T>(Stream stream, TomlSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
var tt = StreamTomlSerializer.Deserialize(stream, settings);
return(tt.Get <T>());
}
public static T ReadString <T>(string toRead, TomlSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
TomlTable tt = ReadString(toRead, settings);
T result = tt.Get <T>();
return(result);
}
public static TomlTable ReadString(string toRead, TomlSettings settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(toRead)))
{
return(StreamTomlSerializer.Deserialize(ms, settings));
}
}
public static TomlTable Deserialize(Stream s, TomlSettings settings)
{
var reader = new StreamReader(s);
var content = reader.ReadToEnd();
var lexer = new Lexer(content);
var tokens = lexer.Lex();
var parser = new Parser.Parser(new ParseInput(tokens), settings);
var ast = parser.Parse();
#if DEBUG
var tree = ast.SyntaxNodeOrDefault()?.PrintTree();
#endif
var table = TableBuilder.Build(ast.SyntaxNodeOrDefault(), settings);
return(table);
}
public static void WriteFile <T>(T obj, string filePath, TomlSettings settings)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
var table = TomlTable.RootTable.From(settings, obj);
WriteFileInternal(table, filePath, settings);
}
internal static RootTable From <T>(TomlSettings settings, T obj)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
var rt = obj as RootTable;
if (rt != null)
{
return(rt);
}
var tt = new RootTable(settings);
var t = obj.GetType();
var props = settings.GetSerializationProperties(t);
var allObjects = new List <Tuple <string, TomlObject> >();
foreach (var p in props)
{
object val = p.GetValue(obj, null);
if (val != null)
{
TomlObject to = TomlObject.CreateFrom(tt, val, p);
AddComments(to, p);
allObjects.Add(Tuple.Create(p.Name, to));
}
}
tt.AddScopeTypesLast(allObjects);
return(tt);
}
private static void WriteFileInternal(TomlTable table, string filePath, TomlSettings settings)
{
if (table == null)
{
throw new ArgumentNullException(nameof(table));
}
if (filePath == null)
{
throw new ArgumentNullException(nameof(filePath));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
filePath.EnsureDirectoryExists();
using (var fs = new FileStream(filePath, FileMode.Create))
using (var sw = new FormattingStreamWriter(fs, CultureInfo.InvariantCulture))
{
var writer = new TomlTableWriter(sw, settings);
writer.WriteToml(table);
}
}
public static TomlTable Deserialize(Stream s, TomlSettings settings)
{
var parser = new Parser.Parser(s, settings);
return(parser.Parse());
}
public static void WriteFile(TomlTable table, string filePath, TomlSettings settings) => WriteFileInternal(table, filePath, settings);
public PropertyMappingBuilder(TomlSettings settings)
{
this.settings = settings;
}
public TableKeyMappingBuilder(TomlSettings settings, ITomlSettingsBuilder configBuilder, string key)
{
this.settings = settings;
this.configBuilder = configBuilder;
this.key = key;
}
public static void WriteStream <T>(T obj, Stream outStream, TomlSettings settings) => WriteStreamInternal(TomlTable.RootTable.From(settings, obj), outStream);
public static string WriteString <T>(T obj, TomlSettings settings) => WriteStringInternal(TomlTable.RootTable.From(settings, obj));
public IEnumerable <T> To <T>(TomlSettings settings) => this.Value.Select((to) => to.Get <T>());
/// <summary> /// Creates a TOML table from a given CLR object. /// </summary> /// <typeparam name="T">The type of the CLR object.</typeparam> /// <param name="obj">The CLR object instance for that the TOML table will be created.</param> /// <param name="settings">The config to use for the creation.</param> /// <returns>A new table representing the CLR object. The table is associated with the given config.</returns> /// <remarks>[!include[_](../specs/toml-create-remarks.md)]</remarks> public static TomlTable Create <T>(T obj, TomlSettings settings) => TomlTable.RootTable.From(settings, obj);
