GenericObject.cs

using System;
using System.Collections;
using System.Collections.Generic;
using Waher.Persistence.Attributes;
using Waher.Runtime.Collections;
 
namespace Waher.Persistence.Serialization
{
    [ArchivingTime(nameof(ArchivingTime))]
    public sealed class GenericObject : ICollection<KeyValuePair<string, object>>
    {
        private IEnumerable<KeyValuePair<string, object>> properties = new ChunkedList<KeyValuePair<string, object>>();
        private Dictionary<string, object> propertiesByName = null;
        private string collectionName = null;
        private string typeName = null;
        private int archivingTime = 0;
        private bool propertiesUpdated = false;
        private Guid objectId = Guid.Empty;
 
        internal GenericObject()
        {
        }
 
        public GenericObject(string CollectionName, string TypeName, Guid ObjectId, params KeyValuePair<string, object>[] Properties)
        {
            this.collectionName = CollectionName;
            this.typeName = TypeName;
            this.objectId = ObjectId;
            this.properties = Properties;
        }
 
        public GenericObject(string CollectionName, string TypeName, Guid ObjectId, IEnumerable<KeyValuePair<string, object>> Properties)
        {
            this.collectionName = CollectionName;
            this.typeName = TypeName;
            this.objectId = ObjectId;
            this.properties = Properties;
        }
 
        public string CollectionName
        {
            get => this.collectionName;
            set => this.collectionName = value;
        }
 
        public string TypeName
        {
            get => this.typeName;
            set => this.typeName = value;
        }
 
        public Guid ObjectId
        {
            get => this.objectId;
            set => this.objectId = value;
        }
 
        [DefaultValue(0)]
        public int ArchivingTime
        {
            get => this.archivingTime;
            set => this.archivingTime = value;
        }
 
        public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
        {
            if (this.propertiesUpdated)
                this.BuildEnumerable();
 
            return this.properties.GetEnumerator();
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            if (this.propertiesUpdated)
                this.BuildEnumerable();
 
            return this.properties.GetEnumerator();
        }
 
        public Dictionary<string,object>.KeyCollection Keys
        {
            get
            {
                if (this.propertiesByName is null)
                    this.BuildDictionary();
 
                return this.propertiesByName.Keys;
            }
        }
 
        public Dictionary<string, object>.ValueCollection Values
        {
            get
            {
                if (this.propertiesByName is null)
                    this.BuildDictionary();
 
                return this.propertiesByName.Values;
            }
        }
 
        public object this[string PropertyName]
        {
            get
            {
                if (this.propertiesByName is null)
                    this.BuildDictionary();
 
                if (this.propertiesByName.TryGetValue(PropertyName, out object Result))
                    return Result;
                else
                    return null;
            }
 
            set
            {
                if (this.propertiesByName is null)
                    this.BuildDictionary();
 
                this.propertiesByName[PropertyName] = value;
                this.propertiesUpdated = true;
            }
        }
 
        public bool TryGetFieldValue(string PropertyName, out object Value)
        {
            if (this.propertiesByName is null)
                this.BuildDictionary();
 
            return this.propertiesByName.TryGetValue(PropertyName, out Value);
        }
 
        public bool Remove(string PropertyName)
        {
            if (this.propertiesByName is null)
                this.BuildDictionary();
 
            if (!this.propertiesByName.Remove(PropertyName))
                return false;
 
            this.propertiesUpdated = true;
 
            return true;
        }
 
        private void BuildDictionary()
        {
            this.propertiesByName = this.properties as Dictionary<string, object>;
            if (this.propertiesByName is null)
            {
                this.propertiesByName = new Dictionary<string, object>();
 
                foreach (KeyValuePair<string, object> P in this.properties)
                    this.propertiesByName[P.Key] = P.Value;
            }
        }
 
        private void BuildEnumerable()
        {
            ChunkedList<KeyValuePair<string, object>> List = new ChunkedList<KeyValuePair<string, object>>();
            Dictionary<string, bool> Added = new Dictionary<string, bool>();
 
            foreach (KeyValuePair<string, object> P in this.properties)
            {
                if (!this.propertiesByName.TryGetValue(P.Key, out object Value))
                    continue;
 
                List.Add(new KeyValuePair<string, object>(P.Key, Value));
                Added[P.Key] = true;
            }
 
            foreach (KeyValuePair<string, object> P in this.propertiesByName)
            {
                if (Added.ContainsKey(P.Key))
                    continue;
 
                List.Add(P);
            }
 
            this.properties = List;
        }
 
        public IEnumerable<KeyValuePair<string, object>> Properties
        {
            get
            {
                if (this.propertiesUpdated)
                    this.BuildEnumerable();
 
                return this.properties;
            }
        }
 
        public int Count
        {
            get
            {
                if (this.propertiesByName is null)
                    this.BuildDictionary();
 
                return this.propertiesByName.Count;
            }
        }
 
        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }
 
        public void Add(KeyValuePair<string, object> item)
        {
            this[item.Key] = item.Value;
        }
 
        public void Clear()
        {
            if (this.propertiesByName is null)
                this.propertiesByName = new Dictionary<string, object>();
            else
                this.propertiesByName.Clear();
 
            this.propertiesUpdated = true;
        }
 
        public bool Contains(KeyValuePair<string, object> item)
        {
            if (this.propertiesByName is null)
                this.BuildDictionary();
 
            if (!this.propertiesByName.TryGetValue(item.Key, out object Value))
                return false;
 
            if (Value is null)
                return item.Value is null;
 
            return Value.Equals(item.Value);
        }
 
        public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
        {
            foreach (KeyValuePair<string, object> P in this)
                array[arrayIndex++] = P;
        }
 
        public bool Remove(KeyValuePair<string, object> item)
        {
            if (this.propertiesByName is null)
                this.BuildDictionary();
 
            if (!this.propertiesByName.TryGetValue(item.Key, out object Value))
                return false;
 
            if (Value is null)
            {
                if (!(item.Value is null))
                    return false;
            }
            else if (!Value.Equals(item.Value))
                return false;
 
            this.propertiesByName.Remove(item.Key);
            this.propertiesUpdated = true;
 
            return true;
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is GenericObject GenObj) ||
                this.collectionName != GenObj.collectionName ||
                this.typeName != GenObj.typeName ||
                this.objectId != GenObj.objectId)
            {
                return false;
            }
 
            if (this.propertiesByName is null)
                this.BuildDictionary();
 
            if (GenObj.propertiesByName is null)
                GenObj.BuildDictionary();
 
            if (this.propertiesByName.Count != GenObj.propertiesByName.Count)
                return false;
 
            foreach (KeyValuePair<string, object> P in this.propertiesByName)
            {
                if (!GenObj.propertiesByName.TryGetValue(P.Key, out object Value))
                    return false;
 
                if (!PropertyEquals(Value, P.Value))
                    return false;
            }
 
            return true;
        }
 
        private static bool PropertyEquals(object Value1, object Value2)
        {
            if (Value1 is null ^ Value2 is null)
                return false;
 
            if (Value1 is null || Value1.Equals(Value2))
                return true;
 
            if (Value1 is Array A && Value2 is Array B)
            {
                int i, c = A.Length;
 
                if (c != B.Length)
                    return false;
 
                for (i = 0; i < c; i++)
                {
                    if (!PropertyEquals(A.GetValue(i), B.GetValue(i)))
                        return false;
                }
 
                return true;
            }
            else
                return false;
        }
 
        public override int GetHashCode()
        {
            if (this.propertiesByName is null)
                this.BuildDictionary();
 
            int Result = this.objectId.GetHashCode();
            Result ^= Result << 5 ^ this.typeName.GetHashCode();
            Result ^= Result << 5 ^ this.collectionName.GetHashCode();
 
            foreach (KeyValuePair<string, object> P in this.propertiesByName)
            {
                Result ^= Result << 5 ^ P.Key.GetHashCode();
                Result ^= Result << 5 ^ P.Value.GetHashCode();
            }
 
            return Result;
        }
 
        public bool HasProperty(string PropertyName)
        {
            if (this.propertiesByName is null)
                this.BuildDictionary();
 
            return this.propertiesByName.ContainsKey(PropertyName);
        }
 
        public object GetProperty(string PropertyName)
        {
            return this[PropertyName];
        }
 
    }
}