// Serializable nodes
public static ObjectNodeBase CreateSerializableRoot(object @object, CachedType type, Options options, string format)
{
var context = new Context(options, Mode.Serialize, format);
return CreateSerializable(
context.Options.TypeNameConventions.GetName(type, context, true),
ValueFactory.Create(@object, type, true, context.Options), null, context).As<ObjectNodeBase>();
}
public static ObjectNodeBase CreateDeserializable(string name, IValue @object, INode parent,
Context context, CachedMember member = null)
{
var type = @object.SpecifiedType;
var kind = GetTypeKind(type, context.Options);
if (kind == TypeKind.Simple)
{
if (parent == null) throw new TypeNotSupportedException("simple type",
@object.SpecifiedType, Mode.Deserialize, "complex types");
return new ValueNode(context, name, @object, member, parent);
}
Func<object> factory = () => ObjectFactory.CreateInstance(type,
context.Options.Deserialization.ObjectFactory, parent.MapOrDefault(x => x.Value));
if (member == null || parent == null) @object.Instance = factory();
else @object = ValueFactory.Create(@object, factory);
switch (kind)
{
case TypeKind.Dictionary: return new DictionaryNode(context, name, @object, member, parent);
case TypeKind.Enumerable: return new EnumerableNode(context, name, @object, member, parent);
default: return new ObjectNode(context, name, @object, member, parent);
}
}
public MemberContext(CachedMember member, Context context)
{
Member = member;
Format = context.Format;
Mode = context.Mode;
Type = member.Type.Type;
}
public override void Encode(Stream stream, Encoding encoding = null)
{
var context = new Context(_options, Mode.Deserialize, NodeFormat);
var header = new SimpleValue(_type.GenericEnumerableType);
var columns = new ObjectNode(context, null, header, null, null)
.Select(x => x.Name).ToArray();
if (!columns.Any()) return;
var writer = new StreamWriter(stream, encoding ?? UTF8Encoding.NoBOM);
var qualifier = _options.CsvQualifier;
Action<string[]> writeLine = x => writer
.Write(x.Select(y =>
$"{qualifier}{y?.Replace(qualifier, qualifier + qualifier)}{qualifier}")
.Aggregate((a, i) => $"{a}{_options.CsvDelimiter}{i}") + _options.CsvNewLine);
writeLine(columns);
foreach (var row in _rows)
{
var fields = new string[columns.Length];
row.Where(x => columns.Contains(x.Name))
.ForEach(x => fields[columns.IndexOf(x.Name)] = x.Value?.ToString());
writeLine(fields);
}
writer.Flush();
}
public TypeContext(CachedType type, Context context, bool isRoot = false)
{
Type = type;
IsRoot = isRoot;
Format = context.Format;
Options = context.Options;
Mode = context.Mode;
}
public ArrayItemContext(CachedType type, CachedMember member, Context context)
{
Type = type;
Member = member;
Format = context.Format;
Options = context.Options;
Mode = context.Mode;
}
public EnumContext(object value, Type type, CachedMember member, Context context)
{
Value = value;
Type = type;
Member = member;
Format = context.Format;
Options = context.Options;
Mode = context.Mode;
}
public ValueNode(
Context context,
string name,
IValue source,
CachedMember member,
INode parent)
: base(name, source, member, parent, context)
{
_friendlyParseMessages = Context.Options.Deserialization.FriendlyParseErrorMessages;
}
public static ObjectNodeBase CreateDeserializableRoot(string name, CachedType type, string format, Options options)
{
var context = new Context(options, Mode.Deserialize, format);
var @object = ValueFactory.Create(type);
if (!context.Options.Deserialization.IgnoreRootName)
{
var expectedName = context.Options.TypeNameConventions.GetName(@object.SpecifiedType, context, true);
if (!name.Equals(expectedName, options.Deserialization.NameComparison))
throw new InvalidRootNameDeserializationException(type, format, name, expectedName);
}
return CreateDeserializable(name, @object, null, context);
}
public ObjectNode(
Context context,
string name,
IValue @object,
CachedMember member,
INode parent) :
base(name, @object, member, parent, context)
{
_members = new Lazy<IEnumerable<MemberDefinition>>(EnumerateMembers);
_nodes = new Lazy<IEnumerable<INode>>(EnumerateNodes);
_addedNodes = new Lazy<IList<INode>>(() => new List<INode>());
}
public DictionaryNode(
Context context,
string name,
IValue dictionary,
CachedMember member,
INode parent)
: base(name, dictionary, member, parent, context)
{
_dictionary = new Lazy<IDictionary>(() =>
dictionary.Instance.MapOrDefault(GenericDictionaryAdapter.Create));
if (SpecifiedType.IsGenericDictionary) _itemType = SpecifiedType.GenericDictionaryTypes.Value;
_nodes = new Lazy<IEnumerable<INode>>(EnumerateNodes);
}
public static ObjectNodeBase CreateSerializable(string name, IValue @object, INode parent,
Context context, CachedMember member = null)
{
switch (GetTypeKind(@object.SpecifiedType, context.Options))
{
case TypeKind.Simple:
if (parent == null) throw new TypeNotSupportedException("simple type", @object.SpecifiedType, Mode.Serialize, "complex types");
return new ValueNode(context, name, @object, member, parent);
case TypeKind.Dictionary: return new DictionaryNode(context, name, @object, member, parent);
case TypeKind.Enumerable: return new EnumerableNode(context, name, @object, member, parent);
default: return new ObjectNode(context, name, @object, member, parent);
}
}
public EnumerableNode(
Context context,
string name,
IValue enumerable,
CachedMember member,
INode parent)
: base(name, enumerable, member, parent, context)
{
_list = new Lazy<IList>(() =>
enumerable.Instance.MapOrDefault(x => enumerable.ActualType.IsArray ?
ArrayAdapter.Create(enumerable) : GenericListAdapter.Create(x)));
if (SpecifiedType.IsGenericEnumerable) _itemType = enumerable.SpecifiedType.GenericEnumerableType;
_nodes = new Lazy<IEnumerable<INode>>(EnumerateNodes);
}
protected ObjectNodeBase(
string name,
IValue source,
CachedMember member,
INode parent,
Context context) : base(parent)
{
_name = name;
Source = source;
Context = context;
Member = member;
HasMember = member != null;
if (HasMember) Metadata.Add(member.Attributes);
else if (Source?.ActualType != null) Metadata.Add(ActualType.Attributes);
}
public Encoder(Stream output, Encoding encoding,
Options options, string format, CachedType type)
{
if (type.IsGenericEnumerable && options.Serialization
.SerializationType == SerializationType.SpecifiedType)
{
var header = new SimpleValue(type.GenericEnumerableType);
var context = new Context(options, Mode.Deserialize, format);
_columns = new ObjectNode(context, null, header, null, null)
.Select(x => x.Name).ToArray();
}
_header = options.CsvHeader;
_qualifier = options.CsvQualifier;
_delimiter = options.CsvDelimiter;
_newLine = options.CsvNewLine;
_writer = new Lazy<StreamWriter>(() => new StreamWriter(output, encoding));
}
public static string GetName(this NamingConventions<MemberContext> conventions,
CachedMember member, Context context)
{
return conventions.GetName(new MemberContext(member, context));
}
public static string GetName(this NamingConventions<EnumContext> conventions,
object value, Type type, CachedMember member, Context context)
{
return conventions.GetName(new EnumContext(value, type, member, context));
}
public static string GetName(this NamingConventions<ArrayItemContext> conventions,
CachedType type, CachedMember member, Context context)
{
return conventions.GetName(new ArrayItemContext(type, member, context));
}
public static string GetName(this NamingConventions<TypeContext> conventions,
CachedType type, Context context, bool isRoot = false)
{
return conventions.GetName(new TypeContext(type, context, isRoot));
}