MarkdownElementChildren.cs

using System.Collections.Generic;
using Waher.Runtime.Collections;
 
namespace Waher.Content.Markdown.Model
{
    public abstract class MarkdownElementChildren : MarkdownElement
    {
        private ChunkedList<MarkdownElement> children;
 
        public MarkdownElementChildren(MarkdownDocument Document, ChunkedList<MarkdownElement> Children)
            : base(Document)
        {
            this.children = Children;
        }
 
        public MarkdownElementChildren(MarkdownDocument Document, params MarkdownElement[] Children)
            : base(Document)
        {
            this.children = new ChunkedList<MarkdownElement>(Children);
        }
 
        public virtual void AddChild(MarkdownElement NewChild)
        {
            this.children.Add(NewChild);
        }
 
        public virtual void AddChildren(ChunkedList<MarkdownElement> NewChildren)
        {
            this.children.AddRange(NewChildren);
        }
 
        public bool HasFirstChild => this.children.HasFirstItem;
 
        public MarkdownElement FirstChild => this.children.FirstItem;
 
        public bool HasLastChild => this.children.HasLastItem;
 
        public MarkdownElement LastChild => this.children.LastItem;
 
        public bool HasOneChild => this.children.Count == 1;
 
        public override ChunkedList<MarkdownElement> Children => this.children;
 
        protected void SetChildren(ChunkedList<MarkdownElement> Children)
        {
            this.children = Children;
        }
 
        public abstract MarkdownElementChildren Create(ChunkedList<MarkdownElement> Children, MarkdownDocument Document);
 
        internal virtual bool JoinOverParagraphs => false;
 
        public override bool ForEach(MarkdownElementHandler Callback, object State)
        {
            if (!Callback(this, State))
                return false;
 
            if (!(this.children is null))
            {
                ChunkNode<MarkdownElement> Loop = this.children.FirstChunk;
                int i, c;
 
                while (!(Loop is null))
                {
                    for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                    {
                        if (!Loop[i].ForEach(Callback, State))
                            return false;
                    }
 
                    Loop = Loop.Next;
                }
            }
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is MarkdownElementChildren x) || !base.Equals(obj))
                return false;
 
            IEnumerator<MarkdownElement> e1 = null;
            IEnumerator<MarkdownElement> e2 = null;
 
            try
            {
                e1 = this.children.GetEnumerator();
                e2 = x.children.GetEnumerator();
 
                bool b1, b2;
 
                while (true)
                {
                    b1 = e1.MoveNext();
                    b2 = e2.MoveNext();
 
                    if (b1 ^ b2)
                        return false;
 
                    if (!b1)
                        return true;
 
                    if (!e1.Current.Equals(e2.Current))
                        return false;
                }
            }
            finally
            {
                e1?.Dispose();
                e2?.Dispose();
            }
        }
 
        public override int GetHashCode()
        {
            ChunkNode<MarkdownElement> Loop = this.children.FirstChunk;
            int i, c;
            int h1 = base.GetHashCode();
            int h2;
 
            while (!(Loop is null))
            {
                for (i = Loop.Start, c = Loop.Pos; i < c; i++)
                {
                    h2 = Loop[i].GetHashCode();
                    h1 = ((h1 << 5) + h1) ^ h2;
                }
 
                Loop = Loop.Next;
            }
 
            return h1;
        }
 
    }
}