vStationURM/Common/Vinno.IUS.Common.Network.Standard/Transfer/MessageElements.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Vinno.IUS.Common.IO;
using Vinno.IUS.Common.Utilities;

namespace Vinno.IUS.Common.Network.Transfer
{
    public interface IElement
    {
        TransferType TransferType { get; }

        IBuffer GetBuffer();
    }

    public abstract class Element<T>:IElement
    {
        public T Value { get; set; }

        protected Element(TransferType transferType, T value)
        {
            TransferType = transferType;
            Value = value;
        }

        /// <summary>
        /// ValueBuffer = ValueData
        /// </summary>
        /// <returns></returns>
        protected abstract IBuffer GetValueBuffer();

        public TransferType TransferType { get; }

        /// <summary>
        /// Buffer = Type|ValueBuffer
        /// </summary>
        /// <returns></returns>
        public IBuffer GetBuffer()
        {
            var buffer = new CompositBuffer();
            buffer.Add(new ByteBuffer(BitConverter.GetBytes((int)TransferType)));
            buffer.Add(GetValueBuffer());
            return buffer;
        }

        public override string ToString()
        {
            return $"<Element type=\"{TransferType}\" value=\"{Value}\"/>";
        }
    }

    public class EmptyElement:Element<object>
    {
        public EmptyElement() : base(TransferType.Empty, null)
        {
        }

        protected override IBuffer GetValueBuffer()
        {
            return new ByteBuffer(new byte[0]);
        }
    }

    public class IntegerElement : Element<int>
    {
        public IntegerElement(int value)
            : base(TransferType.Integer, value)
        {
        }

        protected override IBuffer GetValueBuffer()
        {
            return new ByteBuffer(BitConverter.GetBytes(Value));
        }
    }

    public class LongElement : Element<long>
    {
        public LongElement(long value)
            : base(TransferType.Long, value)
        {
        }

        protected override IBuffer GetValueBuffer()
        {
            return new ByteBuffer(BitConverter.GetBytes(Value));
        }
    }

    public class FloatElement:Element<float>
    {
        public FloatElement(float value) : base(TransferType.Float, value)
        {
        }

        protected override IBuffer GetValueBuffer()
        {
            return new ByteBuffer(BitConverter.GetBytes(Value));
        }
    }

    public class DoubleElement : Element<double>
    {
        public DoubleElement(double value) : base(TransferType.Double, value)
        {
        }

        protected override IBuffer GetValueBuffer()
        {
            return new ByteBuffer(BitConverter.GetBytes(Value));
        }
    }

    public class BoolElement:Element<bool>
    {
        public BoolElement(bool value)
            : base(TransferType.Bool, value)
        {
        }

        protected override IBuffer GetValueBuffer()
        {
            return new ByteBuffer(BitConverter.GetBytes(Value));
        }
    }

    public class StringElement:Element<string>
    {
        public StringElement(string value) : base(TransferType.String, value)
        {
        }

        protected override IBuffer GetValueBuffer()
        {
            if (Value == null)
            {
                Value = string.Empty;
            }
            var data = Encoding.UTF8.GetBytes(Value);
            return new ByteBuffer(data);
        }
    }

    public class DateTimeElement : Element<DateTime>
    {
        public DateTimeElement(DateTime value) : 
            base(TransferType.DateTime, value)
        {
        }

        protected override IBuffer GetValueBuffer()
        {
            return new ByteBuffer(BitConverter.GetBytes(Value.Ticks));
        }
    }

     public class BufferElement:Element<IBuffer>
    {
        public BufferElement(IBuffer value)
            : base(TransferType.Binary, value)
        {

        }

        protected override IBuffer GetValueBuffer()
        {
            return Value;
        }
    }


    public class ListElement : Element<List<Message>>
    {
        public ListElement()
            : base(TransferType.List, new List<Message>())
        {
            
        }

        public void AddMessage(Message message)
        {
            Value.Add(message);
        }

        public void AddMessage(MessageTag tag, IElement element)
        {
            var message = new Message(tag, element);
            AddMessage(message);
        }


        public void RemoveMessage(Message message)
        {
            var exist = Value.FirstOrDefault(x=> x== message);
            if (exist != null)
            {
                Value.Remove(message);
            }
        }

        protected override IBuffer GetValueBuffer()
        {
            var buffer = new CompositBuffer();
            foreach (var message in Value)
            {
                buffer.Add(message.GetBuffer());
            }           
            return buffer;
        }

        public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append($"<Element type=\"{TransferType}\" count=\"{Value.Count}\">");
            foreach (var message in Value)
            {
                sb.Append($"{message}");
            }
            sb.Append("</Element>");
            return sb.ToString();
        }
    }

    public class IdElement : Element<FasterUId>
    {
        public IdElement(FasterUId value) : base(TransferType.Id, value)
        {
        }

        protected override IBuffer GetValueBuffer()
        {
            return new ByteBuffer(Value);
        }
    }

    public class DictionaryElement : Element<Dictionary<MessageTag,Message>>
    {
        public DictionaryElement()
            : base(TransferType.Dictionary, new Dictionary<MessageTag,Message>())
        {

        }

        public void AddMessage(Message message)
        {
            if (Value.ContainsKey(message.Tag))
            {
                throw new ArgumentException($"Tag Id:{message.Tag},Key already exists.");
            }
            Value.Add(message.Tag,message);
        }

        public void AddMessage(MessageTag tag, IElement element)
        {
            var message = new Message(tag, element);
            AddMessage(message);
        }


        public void RemoveMessage(MessageTag tag)
        {
            if (Value.ContainsKey(tag))
            {
                Value.Remove(tag);
            }
        }

        protected override IBuffer GetValueBuffer()
        {
            var buffer = new CompositBuffer();
            foreach (var message in Value.Values)
            {
                buffer.Add(message.GetBuffer());
            }
            return buffer;
        }

        public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append($"<Element type=\"{TransferType}\" count=\"{Value.Count}\">");
            foreach (var message in Value)
            {
                sb.Append($"{message.Value}");
            }
            sb.Append("</Element>");
            return sb.ToString();
        }
    }
}