/// <summary>
/// Initializes a new instance of the <see cref="YamlSequenceNode"/> class.
/// </summary>
/// <param name="events">The events.</param>
/// <param name="state">The state.</param>
internal YamlSequenceNode(EventReader events, DocumentLoadingState state)
{
SequenceStart sequence = events.Expect <SequenceStart>();
Load(sequence, state);
Style = sequence.Style;
bool hasUnresolvedAliases = false;
while (!events.Accept <SequenceEnd>())
{
YamlNode child = ParseNode(events, state);
children.Add(child);
hasUnresolvedAliases |= child is YamlAliasNode;
}
if (hasUnresolvedAliases)
{
state.AddNodeWithUnresolvedAliases(this);
}
#if DEBUG
else
{
foreach (var child in children)
{
if (child is YamlAliasNode)
{
throw new InvalidOperationException("Error in alias resolution.");
}
}
}
#endif
events.Expect <SequenceEnd>();
}
YamlSequence(SequenceStart sequenceStart, SequenceEnd sequenceEnd, List <YamlElement> contents, YamlNodeTracker tracker)
{
Tracker = tracker;
this._sequenceStart = sequenceStart;
if (Tracker != null)
{
Tracker.OnSequenceStartChanged(this, null, sequenceStart);
}
this._sequenceEnd = sequenceEnd;
if (Tracker == null)
{
_contents = contents;
}
else
{
_contents = new List <YamlElement>();
foreach (var item in contents)
{
Add(item);
}
}
}
private object DeserializeList(EventReader reader, Type type, DeserializationContext context)
{
SequenceStart sequence = reader.Expect <SequenceStart>();
type = GetType(sequence.Tag, type, context.Options.Mappings);
// Choose a default list type in case there was no specific type specified.
if (type == typeof(object))
{
type = typeof(ArrayList);
}
object result;
Type iCollection = ReflectionUtility.GetImplementedGenericInterface(type, typeof(ICollection <>));
if (iCollection != null) // Generic list
{
Type[] iCollectionArguments = iCollection.GetGenericArguments();
Debug.Assert(iCollectionArguments.Length == 1, "ICollection<> must have one generic argument.");
var itemType = iCollectionArguments[0];
//result = type.IsArray ? typeof(List<>).MakeGenericType(iCollectionArguments) : Activator.CreateInstance(type);
//MethodInfo addAdapter = addAdapterGeneric.MakeGenericMethod(iCollectionArguments);
//Action<object, object> addAdapterDelegate = (Action<object, object>)Delegate.CreateDelegate(typeof(Action<object, object>), addAdapter);
if (type.IsArray)
{
var tempListType = typeof(List <>).MakeGenericType(iCollectionArguments);
var tempList = Activator.CreateInstance(tempListType);
DeserializeGenericListInternal(reader, tempList, itemType, context);
result = tempListType.GetMethod("ToArray", Type.EmptyTypes).Invoke(tempList, null);
}
else
{
result = Activator.CreateInstance(type);
DeserializeGenericListInternal(reader, result, itemType, context);
}
}
else // Non-generic list
{
result = Activator.CreateInstance(type);
var list = result as IList;
if (list != null)
{
while (!reader.Accept <SequenceEnd>())
{
list.Add(DeserializeValue(reader, typeof(object), context));
}
}
reader.Expect <SequenceEnd>();
}
AddAnchoredObject(sequence, result, context.Anchors);
return(result);
}
private object DeserializeList(EventReader reader, Type type, DeserializationContext context)
{
SequenceStart sequence = reader.Expect <SequenceStart>();
type = GetType(sequence.Tag, type, context.Options.Mappings);
// Choose a default list type in case there was no specific type specified.
if (type == typeof(object))
{
type = typeof(ArrayList);
}
object result = Activator.CreateInstance(type);
Type iCollection = GetImplementedGenericInterface(type, typeof(ICollection <>));
if (iCollection != null)
{
Type[] iCollectionArguments = iCollection.GetGenericArguments();
Debug.Assert(iCollectionArguments.Length == 1, "ICollection<> must have one generic argument.");
MethodInfo addAdapter = addAdapterGeneric.MakeGenericMethod(iCollectionArguments);
Action <object, object> addAdapterDelegate = (Action <object, object>)Delegate.CreateDelegate(typeof(Action <object, object>), addAdapter);
DeserializeGenericListInternal(reader, iCollectionArguments[0], result, addAdapterDelegate, context);
}
else
{
IList list = result as IList;
if (list != null)
{
while (!reader.Accept <SequenceEnd>())
{
list.Add(DeserializeValue(reader, typeof(object), context));
}
}
reader.Expect <SequenceEnd>();
}
AddAnchoredObject(sequence, result, context.Anchors);
return(result);
}
internal YamlSequenceNode(EventReader events, DocumentLoadingState state)
{
this.children = new List <YamlNode>();
SequenceStart yamlEvent = events.Expect <SequenceStart>();
base.Load(yamlEvent, state);
bool flag = false;
while (!events.Accept <SequenceEnd>())
{
YamlNode item = ParseNode(events, state);
this.children.Add(item);
flag |= item is YamlAliasNode;
}
if (flag)
{
state.AddNodeWithUnresolvedAliases(this);
}
events.Expect <SequenceEnd>();
}
private void Load(IParser parser, DocumentLoadingState state)
{
SequenceStart sequenceStart = parser.Expect <SequenceStart>();
Load(sequenceStart, state);
Style = sequenceStart.Style;
bool flag = false;
while (!parser.Accept <SequenceEnd>())
{
YamlNode yamlNode = YamlNode.ParseNode(parser, state);
children.Add(yamlNode);
flag |= (yamlNode is YamlAliasNode);
}
if (flag)
{
state.AddNodeWithUnresolvedAliases(this);
}
parser.Expect <SequenceEnd>();
}
YamlSequence(SequenceStart sequenceStart, SequenceEnd sequenceEnd, List <YamlElement> contents, YamlNodeTracker tracker)
{
if (tracker == null)
{
_contents = contents;
}
else
{
_contents = new List <YamlElement>();
Tracker = tracker;
foreach (var item in contents)
{
Add(item);
}
}
SequenceStart = sequenceStart;
this._sequenceEnd = sequenceEnd;
}
void IParsingEventVisitor.Visit(SequenceStart e)
{
clonedEvent = new SequenceStart(null, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
}
void IParsingEventVisitor.Visit(SequenceStart e)
{
clonedEvent = new SequenceStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
}
public void Visit(SequenceStart e)
{
AddBranch(new Sequence());
}
public void Visit(SequenceStart e)
{
_emitter.Emit(e);
AddBranch(new Sequence());
}
/// <summary> /// Gets the default tag for a <see cref="SequenceStart"/> event. /// </summary> /// <param name="nodeEvent">The node event.</param> /// <returns>The default tag for a seq.</returns> protected abstract string GetDefaultTag(SequenceStart nodeEvent);
protected override string GetDefaultTag(SequenceStart nodeEvent)
{
return(SeqShortTag);
}
protected virtual void OnSequenceStart(ICommand cmd)
{
SequenceStart?.Invoke(cmd);
}
public YamlSequence()
{
_sequenceStart = new SequenceStart();
_sequenceEnd = new SequenceEnd();
_contents = new List <YamlElement>();
}
void IParsingEventVisitor.Visit(SequenceStart e)
{
clonedEvent = new SequenceStart(null, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
}
