SemanticDataSet.cs

using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Runtime.Collections;
 
namespace Waher.Content.Semantic
{
    public class SemanticDataSet : ISemanticCube
    {
        private readonly ChunkedList<ISemanticCube> sources = new ChunkedList<ISemanticCube>();
        private ISemanticCube first = null;
        private int count = 0;
 
        public SemanticDataSet(params ISemanticCube[] Sources)
            : this((IEnumerable<ISemanticCube>)Sources)
        {
        }
 
        public SemanticDataSet(IEnumerable<ISemanticCube> Sources)
        {
            foreach (ISemanticCube Source in Sources)
            {
                if (!(Source is null))
                {
                    if (this.first is null)
                        this.first = Source;
 
                    this.sources.Add(Source);
                    this.count++;
                }
            }
        }
 
        public void Add(ISemanticCube Source)
        {
            if (!(Source is null))
            {
                if (this.first is null)
                    this.first = Source;
 
                this.sources.Add(Source);
                this.count++;
            }
        }
 
        public IEnumerator<ISemanticTriple> GetEnumerator()
        {
            return this.CreateJoinedEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.CreateJoinedEnumerator();
        }
 
        private IEnumerator<ISemanticTriple> CreateJoinedEnumerator()
        {
            ChunkedList<IEnumerator<ISemanticTriple>> Enumerators = new ChunkedList<IEnumerator<ISemanticTriple>>();
 
            foreach (ISemanticCube Source in this.sources)
                Enumerators.Add(Source.GetEnumerator());
 
            return new JoinedTripleEnumerator(Enumerators, true);
        }
 
        public async Task<ISemanticPlane> GetTriplesBySubject(ISemanticElement Subject)
        {
            if (this.first is null)
                return null;
 
            if (this.count <= 1)
                return await this.first.GetTriplesBySubject(Subject);
            else
            {
                InMemorySemanticPlane Result = new InMemorySemanticPlane(Subject);
 
                foreach (ISemanticCube Source in this.sources)
                    Result.Add(await Source.GetTriplesBySubject(Subject), 1, 2);
 
                return Result;
            }
        }
 
        public async Task<ISemanticPlane> GetTriplesByPredicate(ISemanticElement Predicate)
        {
            if (this.first is null)
                return null;
 
            if (this.count <= 1)
                return await this.first.GetTriplesByPredicate(Predicate);
            else
            {
                InMemorySemanticPlane Result = new InMemorySemanticPlane(Predicate);
 
                foreach (ISemanticCube Source in this.sources)
                    Result.Add(await Source.GetTriplesByPredicate(Predicate), 0, 2);
 
                return Result;
            }
        }
 
        public async Task<ISemanticPlane> GetTriplesByObject(ISemanticElement Object)
        {
            if (this.first is null)
                return null;
 
            if (this.count <= 1)
                return await this.first.GetTriplesByObject(Object);
            else
            {
                InMemorySemanticPlane Result = new InMemorySemanticPlane(Object);
 
                foreach (ISemanticCube Source in this.sources)
                    Result.Add(await Source.GetTriplesByObject(Object), 0, 1);
 
                return Result;
            }
        }
 
        public async Task<ISemanticLine> GetTriplesBySubjectAndPredicate(ISemanticElement Subject, ISemanticElement Predicate)
        {
            if (this.first is null)
                return null;
 
            if (this.count <= 1)
                return await this.first.GetTriplesBySubjectAndPredicate(Subject, Predicate);
            else
            {
                InMemorySemanticLine Result = new InMemorySemanticLine(Subject, Predicate);
 
                foreach (ISemanticCube Source in this.sources)
                    Result.Add(await Source.GetTriplesBySubjectAndPredicate(Subject, Predicate), 2);
 
                return Result;
            }
        }
 
        public async Task<ISemanticLine> GetTriplesBySubjectAndObject(ISemanticElement Subject, ISemanticElement Object)
        {
            if (this.first is null)
                return null;
 
            if (this.count <= 1)
                return await this.first.GetTriplesBySubjectAndObject(Subject, Object);
            else
            {
                InMemorySemanticLine Result = new InMemorySemanticLine(Subject, Object);
 
                foreach (ISemanticCube Source in this.sources)
                    Result.Add(await Source.GetTriplesBySubjectAndObject(Subject, Object), 1);
 
                return Result;
            }
        }
 
        public async Task<ISemanticLine> GetTriplesByPredicateAndSubject(ISemanticElement Predicate, ISemanticElement Subject)
        {
            if (this.first is null)
                return null;
 
            if (this.count <= 1)
                return await this.first.GetTriplesByPredicateAndSubject(Predicate, Subject);
            else
            {
                InMemorySemanticLine Result = new InMemorySemanticLine(Predicate, Subject);
 
                foreach (ISemanticCube Source in this.sources)
                    Result.Add(await Source.GetTriplesByPredicateAndSubject(Predicate, Subject), 2);
 
                return Result;
            }
        }
 
        public async Task<ISemanticLine> GetTriplesByPredicateAndObject(ISemanticElement Predicate, ISemanticElement Object)
        {
            if (this.first is null)
                return null;
 
            if (this.count <= 1)
                return await this.first.GetTriplesByPredicateAndObject(Predicate, Object);
            else
            {
                InMemorySemanticLine Result = new InMemorySemanticLine(Predicate, Object);
 
                foreach (ISemanticCube Source in this.sources)
                    Result.Add(await Source.GetTriplesByPredicateAndObject(Predicate, Object), 0);
 
                return Result;
            }
        }
 
        public async Task<ISemanticLine> GetTriplesByObjectAndSubject(ISemanticElement Object, ISemanticElement Subject)
        {
            if (this.first is null)
                return null;
 
            if (this.count <= 1)
                return await this.first.GetTriplesByObjectAndSubject(Object, Subject);
            else
            {
                InMemorySemanticLine Result = new InMemorySemanticLine(Object, Subject);
 
                foreach (ISemanticCube Source in this.sources)
                    Result.Add(await Source.GetTriplesByObjectAndSubject(Object, Subject), 1);
 
                return Result;
            }
        }
 
        public async Task<ISemanticLine> GetTriplesByObjectAndPredicate(ISemanticElement Object, ISemanticElement Predicate)
        {
            if (this.first is null)
                return null;
 
            if (this.count <= 1)
                return await this.first.GetTriplesByObjectAndPredicate(Object, Predicate);
            else
            {
                InMemorySemanticLine Result = new InMemorySemanticLine(Object, Predicate);
 
                foreach (ISemanticCube Source in this.sources)
                    Result.Add(await Source.GetTriplesByObjectAndPredicate(Object, Predicate), 0);
 
                return Result;
            }
        }
 
        public async Task<IEnumerable<ISemanticTriple>> GetTriplesBySubjectAndPredicateAndObject(ISemanticElement Subject, ISemanticElement Predicate, ISemanticElement Object)
        {
            if (this.first is null)
                return null;
 
            if (this.count <= 1)
                return await this.first.GetTriplesBySubjectAndPredicateAndObject(Subject, Predicate, Object);
            else
            {
                ChunkedList<ISemanticTriple> Result = new ChunkedList<ISemanticTriple>();
 
                foreach (ISemanticCube Source in this.sources)
                {
                    IEnumerable<ISemanticTriple> Part = await this.first.GetTriplesBySubjectAndPredicateAndObject(Subject, Predicate, Object);
                    if (Part is null)
                        continue;
 
                    foreach (ISemanticTriple Triple in Part)
                        Result.Add(Triple);
                }
 
                return Result;
            }
        }
 
        public async Task<IEnumerator<ISemanticElement>> GetSubjectEnumerator()
        {
            ChunkedList<IEnumerator<ISemanticElement>> Enumerators = new ChunkedList<IEnumerator<ISemanticElement>>();
 
            foreach (ISemanticCube Source in this.sources)
                Enumerators.Add(await Source.GetSubjectEnumerator());
 
            return new JoinedElementEnumerator(Enumerators, true);
        }
 
        public async Task<IEnumerator<ISemanticElement>> GetPredicateEnumerator()
        {
            ChunkedList<IEnumerator<ISemanticElement>> Enumerators = new ChunkedList<IEnumerator<ISemanticElement>>();
 
            foreach (ISemanticCube Source in this.sources)
                Enumerators.Add(await Source.GetPredicateEnumerator());
 
            return new JoinedElementEnumerator(Enumerators, true);
        }
 
        public async Task<IEnumerator<ISemanticElement>> GetObjectEnumerator()
        {
            ChunkedList<IEnumerator<ISemanticElement>> Enumerators = new ChunkedList<IEnumerator<ISemanticElement>>();
 
            foreach (ISemanticCube Source in this.sources)
                Enumerators.Add(await Source.GetObjectEnumerator());
 
            return new JoinedElementEnumerator(Enumerators, true);
        }
 
        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;
        }
    }
}