InMemorySemanticCube.cs

using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Persistence;
 
namespace Waher.Content.Semantic
{
    public class InMemorySemanticCube : InMemorySemanticModel, ISemanticCube
    {
        private SortedDictionary<ISemanticElement, InMemorySemanticPlane> subjects = null;
        private SortedDictionary<ISemanticElement, InMemorySemanticPlane> predicates = null;
        private SortedDictionary<ISemanticElement, InMemorySemanticPlane> objects = null;
 
        public InMemorySemanticCube()
        {
        }
 
        public static async Task<InMemorySemanticCube> Create(ISemanticModel Model)
        {
            if (Model is InMemorySemanticCube Result)
                return Result;
 
            Result = new InMemorySemanticCube();
            await Result.Add(Model);
 
            return Result;
        }
 
        public override void Add(ISemanticTriple Triple)
        {
            base.Add(Triple);
 
            this.subjects = null;
            this.predicates = null;
            this.objects = null;
        }
 
        public virtual async Task Add(ISemanticModel Model)
        {
            using (IEnumerator<ISemanticTriple> e = Model.GetEnumerator())
            {
                if (e is IAsyncEnumerator eAsync)
                {
                    while (await eAsync.MoveNextAsync())
                        this.Add(e.Current);
                }
                else
                {
                    while (e.MoveNext())
                        this.Add(e.Current);
                }
            }
        }
 
        public Task<ISemanticPlane> GetTriplesBySubject(ISemanticElement Subject)
        {
            this.CheckSubjectsOrdered();
 
            if (!this.subjects.TryGetValue(Subject, out InMemorySemanticPlane Plane))
                Plane = null;
 
            return Task.FromResult<ISemanticPlane>(Plane);
        }
 
        public Task<ISemanticPlane> GetTriplesByPredicate(ISemanticElement Predicate)
        {
            this.CheckPredicatesOrdered();
 
            if (!this.predicates.TryGetValue(Predicate, out InMemorySemanticPlane Plane))
                Plane = null;
 
            return Task.FromResult<ISemanticPlane>(Plane);
        }
 
        public Task<ISemanticPlane> GetTriplesByObject(ISemanticElement Object)
        {
            this.CheckObjectsOrdered();
 
            if (!this.objects.TryGetValue(Object, out InMemorySemanticPlane Plane))
                Plane = null;
 
            return Task.FromResult<ISemanticPlane>(Plane);
        }
 
        public Task<ISemanticLine> GetTriplesBySubjectAndPredicate(ISemanticElement Subject, ISemanticElement Predicate)
        {
            this.CheckSubjectsOrdered();
 
            if (!this.subjects.TryGetValue(Subject, out InMemorySemanticPlane Plane))
                return Task.FromResult<ISemanticLine>(null);
 
            return Plane.GetTriplesByX(Predicate);
        }
 
        public Task<ISemanticLine> GetTriplesBySubjectAndObject(ISemanticElement Subject, ISemanticElement Object)
        {
            this.CheckSubjectsOrdered();
 
            if (!this.subjects.TryGetValue(Subject, out InMemorySemanticPlane Plane))
                return Task.FromResult<ISemanticLine>(null);
 
            return Plane.GetTriplesByY(Object);
        }
 
        public Task<ISemanticLine> GetTriplesByPredicateAndSubject(ISemanticElement Predicate, ISemanticElement Subject)
        {
            this.CheckPredicatesOrdered();
 
            if (!this.predicates.TryGetValue(Predicate, out InMemorySemanticPlane Plane))
                return Task.FromResult<ISemanticLine>(null);
 
            return Plane.GetTriplesByX(Subject);
        }
 
        public Task<ISemanticLine> GetTriplesByPredicateAndObject(ISemanticElement Predicate, ISemanticElement Object)
        {
            this.CheckPredicatesOrdered();
 
            if (!this.predicates.TryGetValue(Predicate, out InMemorySemanticPlane Plane))
                return Task.FromResult<ISemanticLine>(null);
 
            return Plane.GetTriplesByY(Object);
        }
 
        public Task<ISemanticLine> GetTriplesByObjectAndSubject(ISemanticElement Object, ISemanticElement Subject)
        {
            this.CheckObjectsOrdered();
 
            if (!this.objects.TryGetValue(Object, out InMemorySemanticPlane Plane))
                return Task.FromResult<ISemanticLine>(null);
 
            return Plane.GetTriplesByX(Subject);
        }
 
        public Task<ISemanticLine> GetTriplesByObjectAndPredicate(ISemanticElement Object, ISemanticElement Predicate)
        {
            this.CheckObjectsOrdered();
 
            if (!this.objects.TryGetValue(Object, out InMemorySemanticPlane Plane))
                return Task.FromResult<ISemanticLine>(null);
 
            return Plane.GetTriplesByY(Predicate);
        }
 
        public Task<IEnumerable<ISemanticTriple>> GetTriplesBySubjectAndPredicateAndObject(ISemanticElement Subject, ISemanticElement Predicate, ISemanticElement Object)
        {
            this.CheckSubjectsOrdered();
 
            if (!this.subjects.TryGetValue(Subject, out InMemorySemanticPlane Plane))
                return Task.FromResult<IEnumerable<ISemanticTriple>>(null);
 
            return Plane.GetTriplesByXAndY(Predicate, Object);
        }
 
        public Task<IEnumerator<ISemanticElement>> GetSubjectEnumerator()
        {
            this.CheckSubjectsOrdered();
 
            return Task.FromResult<IEnumerator<ISemanticElement>>(this.subjects.Keys.GetEnumerator());
        }
 
        public Task<IEnumerator<ISemanticElement>> GetPredicateEnumerator()
        {
            this.CheckPredicatesOrdered();
 
            return Task.FromResult<IEnumerator<ISemanticElement>>(this.predicates.Keys.GetEnumerator());
        }
 
        public Task<IEnumerator<ISemanticElement>> GetObjectEnumerator()
        {
            this.CheckObjectsOrdered();
 
            return Task.FromResult<IEnumerator<ISemanticElement>>(this.objects.Keys.GetEnumerator());
        }
 
        private void CheckSubjectsOrdered()
        {
            if (this.subjects is null)
            {
                SortedDictionary<ISemanticElement, InMemorySemanticPlane> Ordered =
                    new SortedDictionary<ISemanticElement, InMemorySemanticPlane>();
                ISemanticElement LastPoint = null;
                InMemorySemanticPlane Last = null;
 
                foreach (ISemanticTriple T in this.triples)
                {
                    if ((LastPoint is null || !LastPoint.Equals(T.Subject)) &&
                        !Ordered.TryGetValue(T.Subject, out Last))
                    {
                        Last = new InMemorySemanticPlane(T.Subject);
                        Ordered[T.Subject] = Last;
                    }
 
                    Last.Add(T.Predicate, T.Object, T);
                }
 
                this.subjects = Ordered;
            }
        }
 
        private void CheckPredicatesOrdered()
        {
            if (this.predicates is null)
            {
                SortedDictionary<ISemanticElement, InMemorySemanticPlane> Ordered =
                    new SortedDictionary<ISemanticElement, InMemorySemanticPlane>();
                ISemanticElement LastPoint = null;
                InMemorySemanticPlane Last = null;
 
                foreach (ISemanticTriple T in this.triples)
                {
                    if ((LastPoint is null || !LastPoint.Equals(T.Predicate)) &&
                        !Ordered.TryGetValue(T.Predicate, out Last))
                    {
                        Last = new InMemorySemanticPlane(T.Predicate);
                        Ordered[T.Predicate] = Last;
                    }
 
                    Last.Add(T.Subject, T.Object, T);
                }
 
                this.predicates = Ordered;
            }
        }
 
        private void CheckObjectsOrdered()
        {
            if (this.objects is null)
            {
                SortedDictionary<ISemanticElement, InMemorySemanticPlane> Ordered =
                    new SortedDictionary<ISemanticElement, InMemorySemanticPlane>();
                ISemanticElement LastPoint = null;
                InMemorySemanticPlane Last = null;
 
                foreach (ISemanticTriple T in this.triples)
                {
                    if ((LastPoint is null || !LastPoint.Equals(T.Object)) &&
                        !Ordered.TryGetValue(T.Object, out Last))
                    {
                        Last = new InMemorySemanticPlane(T.Object);
                        Ordered[T.Object] = Last;
                    }
 
                    Last.Add(T.Subject, T.Predicate, T);
                }
 
                this.objects = Ordered;
            }
        }
 
        public async Task<IEnumerable<ISemanticTriple>> GetTriples(ISemanticElement Value, int AxisIndex)
        {
            switch (AxisIndex)
            {
                case 0: return await this.GetTriplesBySubject(Value);
                case 1: return await this.GetTriplesByPredicate(Value);
                case 2: return await this.GetTriplesByObject(Value);
                default: return null;
            }
        }
 
        public async Task<IEnumerable<ISemanticTriple>> GetTriples(ISemanticElement Value1, int Axis1Index,
            ISemanticElement Value2, int Axis2Index)
        {
            if (Axis1Index == Axis2Index)
            {
                if (Value1.Equals(Value2))
                    return await this.GetTriples(Value1, Axis1Index);
            }
            else
            {
                switch (Axis1Index)
                {
                    case 0:
                        switch (Axis2Index)
                        {
                            case 1: return await this.GetTriplesBySubjectAndPredicate(Value1, Value2);
                            case 2: return await this.GetTriplesBySubjectAndObject(Value1, Value2);
                        }
                        break;
 
                    case 1:
                        switch (Axis2Index)
                        {
                            case 0: return await this.GetTriplesByPredicateAndSubject(Value1, Value2);
                            case 2: return await this.GetTriplesByPredicateAndObject(Value1, Value2);
                        }
                        break;
 
                    case 2:
                        switch (Axis2Index)
                        {
                            case 0: return await this.GetTriplesByObjectAndSubject(Value1, Value2);
                            case 1: return await this.GetTriplesByObjectAndPredicate(Value1, Value2);
                        }
                        break;
                }
            }
 
            return null;
        }
 
    }
}