Island.StandardLib/Storage/StorableMultArray.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace Island.StandardLib.Storage
{
    /// <summary>
    /// 表示一个每项长度不固定的可序列化变长数组（不定项长可变数组）
    /// </summary>
    public class StorableMultArray : IStorable
    {
        List<MultData> array;

        /// <summary>
        /// 初始化不定项长可变数组
        /// </summary>
        public StorableMultArray()
        {
            array = new List<MultData>();
        }

        public StorableMultArray DeepCopy()
        {
            StorableMultArray newArray = new StorableMultArray();
            for (int i = 0; i < Length; i++)
                newArray.Add(this[i].DeepCopy());
            return newArray;
        }

        public void ReadFromData(DataStorage data)
        {
            data.ReadUncheck(out int size);
            for (int i = 0; i < size; i++)
                array.Add(new MultData(data.Read()));
        }

        public void WriteToData(DataStorage data)
        {
            data.WriteUncheck(array.Count);
            for (int i = 0; i < array.Count; i++)
                data.Write(array[i].Data);
        }

        public override bool Equals(object obj)
        {
            StorableMultArray other = obj as StorableMultArray;
            if (other == null) return false;
            if (other.Length != Length) return false;
            for (int i = 0; i < Length; i++)
                if (!other[i].Equals(this[i])) return false;
            return true;
        }

        public void Add(IStorable data) => array.Add(new MultData(data));

        public void Add(MultData data) => array.Add(data);
        public void Add(byte[] data) => array.Add(new MultData(data));
        public void RemoveAt(int index) => array.RemoveAt(index);
        public void Clear() => array.Clear();

        public int Count => array.Count;
        public int Size => array.Count;
        public int Length => array.Count;
        public MultData this[int index] => array[index];
    }

    /// <summary>
    /// 表示一个不定项长可变数组的项
    /// </summary>
    public class MultData
    {
        public byte[] Data;

        public MultData DeepCopy()
        {
            byte[] b = new byte[Data.Length];
            Array.Copy(Data, b, b.Length);
            return new MultData(b);
        }

        public MultData(byte[] data) => Data = data;
        public MultData(int data) => Data = BitConverter.GetBytes(data);
        public MultData(char data) => Data = BitConverter.GetBytes(data);
        public MultData(bool data) => Data = BitConverter.GetBytes(data);
        public MultData(float data) => Data = BitConverter.GetBytes(data);
        public MultData(string data) => Data = Encoding.UTF8.GetBytes(data);
        public MultData(long data) => Data = BitConverter.GetBytes(data);
        public MultData(uint data) => Data = BitConverter.GetBytes(data);
        public MultData(ulong data) => Data = BitConverter.GetBytes(data);
        public MultData(double data) => Data = BitConverter.GetBytes(data);
        public MultData(IStorable data)
        {
            DataStorage ds = new DataStorage();
            data.WriteToData(ds);
            Data = ds.Bytes;
        }

        public override bool Equals(object obj)
        {
            MultData other = obj as MultData;
            if (other == null) return false;
            return other.Data.ByteEquals(Data);
        }

        public int AsInt() => BitConverter.ToInt32(Data, 0);
        public char AsChar() => BitConverter.ToChar(Data, 0);
        public bool AsBool() => BitConverter.ToBoolean(Data, 0);
        public float AsFloat() => BitConverter.ToSingle(Data, 0);
        public string AsString() => Encoding.UTF8.GetString(Data);
        public long AsLong() => BitConverter.ToInt64(Data, 0);
        public uint AsUInt() => BitConverter.ToUInt32(Data, 0);
        public ulong AsULong() => BitConverter.ToUInt64(Data, 0);
        public double AsDouble() => BitConverter.ToDouble(Data, 0);
        public T As<T>() where T : IStorable, new() => Data.ReadData<T>();

        public override int GetHashCode()
        {
            return BitConverter.ToInt32(Data.Hash16(), 0);
        }
    }
}