InMemorySemanticLine.cs

using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Runtime.Collections;
 
namespace Waher.Content.Semantic
{
    public class InMemorySemanticLine : ISemanticLine
    {
        private readonly ChunkedList<KeyValuePair<ISemanticElement, ISemanticTriple>> elements = new ChunkedList<KeyValuePair<ISemanticElement, ISemanticTriple>>();
        private readonly ISemanticElement reference1;
        private readonly ISemanticElement reference2;
        private SortedDictionary<ISemanticElement, ChunkedList<ISemanticTriple>> points = null;
 
        public InMemorySemanticLine(ISemanticElement Reference1, ISemanticElement Reference2)
        {
            this.reference1 = Reference1;
            this.reference2 = Reference2;
        }
 
        public ISemanticElement Reference1 => this.reference1;
 
        public ISemanticElement Reference2 => this.reference2;
 
        public void Add(ISemanticElement Point, ISemanticTriple Triple)
        {
            this.points = null;
            this.elements.Add(new KeyValuePair<ISemanticElement, ISemanticTriple>(Point, Triple));
        }
 
        public void Add(IEnumerable<ISemanticTriple> Triples, int ZIndex)
        {
            if (!(Triples is null))
            {
                foreach (ISemanticTriple Triple in Triples)
                    this.Add(Triple[ZIndex], Triple);
            }
        }
 
        public IEnumerator<ISemanticTriple> GetEnumerator()
        {
            return new TripleEnumerator(this.elements.GetEnumerator());
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return new TripleEnumerator(this.elements.GetEnumerator());
        }
 
        private class TripleEnumerator : IEnumerator<ISemanticTriple>
        {
            private readonly IEnumerator<KeyValuePair<ISemanticElement, ISemanticTriple>> e;
 
            public TripleEnumerator(IEnumerator<KeyValuePair<ISemanticElement, ISemanticTriple>> e)
            {
                this.e = e;
            }
 
            public ISemanticTriple Current => this.e.Current.Value;
            object IEnumerator.Current => this.e.Current.Value;
            public void Dispose() => this.e.Dispose();
            public bool MoveNext() => this.e.MoveNext();
            public void Reset() => this.e.Reset();
        }
 
        public Task<IEnumerable<ISemanticTriple>> GetTriples(ISemanticElement X)
        {
            this.CheckOrdered();
 
            if (!this.points.TryGetValue(X, out ChunkedList<ISemanticTriple> Points))
                Points = null;
 
            return Task.FromResult<IEnumerable<ISemanticTriple>>(Points);
        }
 
        public Task<IEnumerator<ISemanticElement>> GetValueEnumerator()
        {
            this.CheckOrdered();
 
            return Task.FromResult<IEnumerator<ISemanticElement>>(this.points.Keys.GetEnumerator());
        }
 
        private void CheckOrdered()
        {
            if (this.points is null)
            {
                SortedDictionary<ISemanticElement, ChunkedList<ISemanticTriple>> Ordered = 
                    new SortedDictionary<ISemanticElement, ChunkedList<ISemanticTriple>>();
                ISemanticElement LastPoint = null;
                ChunkedList<ISemanticTriple> Last = null;
 
                foreach (KeyValuePair<ISemanticElement, ISemanticTriple> P in this.elements)
                {
                    if ((LastPoint is null || !LastPoint.Equals(P.Key)) &&
                        !Ordered.TryGetValue(P.Key, out Last))
                    {
                        Last = new ChunkedList<ISemanticTriple>();
                        Ordered[P.Key] = Last;
                    }
 
                    Last.Add(P.Value);
                }
 
                this.points = Ordered;
            }
        }
    }
}