DateTimeVector.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using Waher.Runtime.Collections;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Abstraction.Sets;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Operators.Vectors;
 
namespace Waher.Script.Objects.VectorSpaces
{
    public sealed class DateTimeVector : VectorSpaceElement
    {
        private DateTime[] values;
        private ICollection<IElement> elements;
        private readonly int dimension;
 
        public DateTimeVector(params DateTime[] Values)
        {
            this.values = Values;
            this.elements = null;
            this.dimension = Values.Length;
        }
 
        public DateTimeVector(ICollection<IElement> Elements)
        {
            this.values = null;
            this.elements = Elements;
            this.dimension = Elements.Count;
        }
 
        public DateTime[] Values
        {
            get
            {
                if (this.values is null)
                {
                    DateTime[] v = new DateTime[this.dimension];
                    int i = 0;
 
                    if (this.elements is ChunkedList<IElement> Values)
                    {
                        ChunkNode<IElement> Loop = Values.FirstChunk;
                        int j, c;
 
                        while (!(Loop is null))
                        {
                            for (j = Loop.Start, c = Loop.Pos; j < c; j++)
                            {
                                if (!(Loop[j].AssociatedObjectValue is DateTime TP))
                                    TP = DateTime.MinValue;
 
                                v[i++] = TP;
                            }
 
                            Loop = Loop.Next;
                        }
                    }
                    else
                    {
                        foreach (IElement Element in this.elements)
                        {
                            if (!(Element.AssociatedObjectValue is DateTime TP))
                                TP = DateTime.MinValue;
 
                            v[i++] = TP;
                        }
                    }
 
                    this.values = v;
                }
 
                return this.values;
            }
        }
 
        public ICollection<IElement> Elements
        {
            get
            {
                if (this.elements is null)
                {
                    int i;
                    IElement[] v = new IElement[this.dimension];
 
                    for (i = 0; i < this.dimension; i++)
                        v[i] = new DateTimeValue(this.values[i]);
 
                    this.elements = v;
                }
 
                return this.elements;
            }
        }
 
        public override int Dimension => this.dimension;
 
        public override string ToString()
        {
            StringBuilder sb = null;
 
            foreach (DateTime d in this.Values)
            {
                if (sb is null)
                    sb = new StringBuilder("[");
                else
                    sb.Append(", ");
 
                sb.Append(Expression.ToString(d));
            }
 
            if (sb is null)
                return "[]";
            else
            {
                sb.Append(']');
                return sb.ToString();
            }
        }
 
        public override IVectorSpace AssociatedVectorSpace
        {
            get
            {
                if (this.associatedVectorSpace is null)
                    this.associatedVectorSpace = new DateTimeVectors(this.dimension);
 
                return this.associatedVectorSpace;
            }
        }
 
        private DateTimeVectors associatedVectorSpace = null;
 
        public override object AssociatedObjectValue => this.Values;
 
        public override IVectorSpaceElement MultiplyScalar(IFieldElement Scalar)
        {
            return null;
        }
 
        public override IAbelianGroupElement Add(IAbelianGroupElement Element)
        {
            return null;
        }
 
        public override IGroupElement Negate()
        {
            return null;
        }
 
        public override bool Equals(object obj)
        {
            DateTimeVector DateTimeVector = obj as DateTimeVector;
            if (DateTimeVector is null)
                return false;
 
            int i;
            if (DateTimeVector.dimension != this.dimension)
                return false;
 
            DateTime[] Values = this.Values;
            DateTime[] Values2 = DateTimeVector.Values;
            for (i = 0; i < this.dimension; i++)
            {
                if (Values[i] != Values2[i])
                    return false;
            }
 
            return true;
        }
 
        public override int GetHashCode()
        {
            DateTime[] Values = this.Values;
            int Result = 0;
            int i;
 
            for (i = 0; i < this.dimension; i++)
                Result ^= Values[i].GetHashCode();
 
            return Result;
        }
 
        public override bool IsScalar
        {
            get { return false; }
        }
 
        public override ICollection<IElement> ChildElements => this.Elements;
 
        public override IElement Encapsulate(ChunkedList<IElement> Elements, ScriptNode Node)
        {
            return VectorDefinition.Encapsulate(Elements, true, Node);
        }
 
        public override IElement Encapsulate(ICollection<IElement> Elements, ScriptNode Node)
        {
            return VectorDefinition.Encapsulate(Elements, true, Node);
        }
 
        public override IAbelianGroupElement Zero
        {
            get
            {
                if (this.zero is null)
                    this.zero = new DateTimeVector(new DateTime[this.dimension]);
 
                return this.zero;
            }
        }
 
        private DateTimeVector zero = null;
 
        public override IElement GetElement(int Index)
        {
            if (Index < 0 || Index >= this.dimension)
                throw new ScriptException("Index out of bounds.");
 
            DateTime[] V = this.Values;
 
            return new DateTimeValue(V[Index]);
        }
 
        public override void SetElement(int Index, IElement Value)
        {
            if (Index < 0 || Index >= this.dimension)
                throw new ScriptException("Index out of bounds.");
 
            if (!(Value.AssociatedObjectValue is DateTime V))
                throw new ScriptException("Elements in a boolean vector are required to be boolean values.");
 
            DateTime[] Values = this.Values;
            this.elements = null;
 
            Values[Index] = V;
        }
 
        public override bool TryConvertTo(Type DesiredType, out object Value)
        {
            if (DesiredType == typeof(DateTime[]))
            {
                Value = this.Values;
                return true;
            }
            else if (DesiredType.IsAssignableFrom(typeof(DateTimeVector).GetTypeInfo()))
            {
                Value = this;
                return true;
            }
            else
                return Expression.TryConvert(this.Values, DesiredType, true, out Value);
        }
 
    }
}