Variant.cs

using Datalayer.Internal;
using FlatBuffers;
using System;
using System.Collections;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;
 
namespace Datalayer
{
    [DebuggerDisplay("{Value}")]
    public class Variant : IVariant, INative
    {
        // Fields
        private readonly bool _skipDelete;
        private unsafe void* _nativePtr;
        private readonly DateTime _timestamp = DateTime.Now;
 
        #region Internal Constructors
 
        internal unsafe Variant(void* nativePtr)
        {
            _nativePtr = nativePtr;
            _skipDelete = true;
        }
 
        #endregion
 
        #region Internal Properties
 
        internal unsafe bool IsNullPtr => _nativePtr == null;
 
        unsafe void* INative.NativePtr => _nativePtr;
 
        #endregion
 
        #region Disposing
 
        public bool IsDisposed { get; private set; }
 
        protected virtual void Dispose(bool disposing)
        {
            if (!IsDisposed)
            {
                if (disposing)
                {
                    // dispose managed state (managed objects)
                }
 
                // free unmanaged resources (unmanaged objects) and override finalizer
                Delete();
                //  set large fields to null
                IsDisposed = true;
            }
        }
 
        private void Delete()
        {
            unsafe
            {
                if (_skipDelete)
                {
                    _nativePtr = null;
                    return;
                }
 
                NativeMethods.Datalayer.DLR_variantDelete(_nativePtr);
                _nativePtr = null;
            }
        }
 
        ~Variant()
        {
            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
            Dispose(disposing: false);
        }
 
        public void Dispose()
        {
            // Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }
 
        #endregion
 
        #region Public Constructors
 
        public Variant()
        {
            unsafe
            {
                _nativePtr = NativeMethods.Datalayer.DLR_variantCreate();
            }
        }
 
        public Variant(IVariant other)
            : this()
        {
            if (other == null)
            {
                throw new ArgumentNullException(nameof(other));
            }
 
            unsafe
            {
                if (NativeMethods.Datalayer.DLR_variantCopy(_nativePtr, other.ToNativePtr()).IsBad())
                {
                    throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
                }
            }
        }
 
        public Variant(bool value)
            : this()
        {
            if (SetBool(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(string value)
            : this()
        {
            if (SetString(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(sbyte value)
           : this()
        {
            if (SetInt8(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(short value)
           : this()
        {
            if (SetInt16(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(int value)
           : this()
        {
            if (SetInt32(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(long value)
           : this()
        {
            if (SetInt64(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(byte value)
           : this()
        {
            if (SetUInt8(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            };
        }
 
        public Variant(ushort value)
           : this()
        {
            if (SetUInt16(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(uint value)
           : this()
        {
            if (SetUInt32(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(ulong value)
           : this()
        {
            if (SetUInt64(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(float value)
         : this()
        {
            if (SetFloat32(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(double value)
          : this()
        {
            if (SetFloat64(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(bool[] value)
           : this()
        {
            if (SetArrayOfBool(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(string[] value)
           : this()
        {
            if (SetArrayOfString(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(sbyte[] value)
           : this()
        {
            if (SetArrayOfInt8(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(short[] value)
           : this()
        {
            if (SetArrayOfInt16(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(int[] value)
           : this()
        {
            if (SetArrayOfInt32(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(long[] value)
           : this()
        {
            if (SetArrayOfInt64(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(byte[] value)
           : this()
        {
            if (SetArrayOfUInt8(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(ushort[] value)
           : this()
        {
            if (SetArrayOfUInt16(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(uint[] value)
           : this()
        {
            if (SetArrayOfUInt32(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(ulong[] value)
           : this()
        {
            if (SetArrayOfUInt64(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(float[] value)
           : this()
        {
            if (SetArrayOfFloat32(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(double[] value)
          : this()
        {
            if (SetArrayOfFloat64(value).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(ByteBuffer flatBuffers)
            : this()
        {
            if (SetFlatbuffers(flatBuffers).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        public Variant(FlatBufferBuilder builder)
          : this()
        {
            if (builder == null)
            {
                throw new ArgumentNullException(nameof(builder));
            }
 
            if (SetFlatbuffers(builder.DataBuffer).IsBad())
            {
                throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
            }
        }
 
        #endregion
 
        #region Public Overrides
 
        public override bool Equals(object obj)
        {
            return Equals(obj as Variant);
        }
 
        public bool Equals(Variant other)
        {
            if (!(other is Variant))
            {
                return false;
            }
 
            if (ReferenceEquals(this, other))
            {
                return true;
            }
 
            var dataType = DataType;
            if (dataType != other.DataType)
            {
                return false;
            }
 
            //Arrays 
            if (Utils.IsArray(dataType))
            {
                return StructuralComparisons.StructuralEqualityComparer.Equals(Value, other.Value);
            }
 
            //Flatbuffers
            if (dataType == DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_FLATBUFFERS)
            {
                return StructuralComparisons.StructuralEqualityComparer.Equals(ToFlatbuffers().ToSizedArray(), other.ToFlatbuffers().ToSizedArray());
            }
 
            //Scalars
            return Equals(Value, other.Value);
        }
 
        public override int GetHashCode()
        {
            var v = Value;
            return v != null ? base.GetHashCode() ^ v.GetHashCode() : base.GetHashCode();
        }
 
        public override string ToString()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return string.Empty;
            }
 
            unsafe
            {
                var length = Convert.ToInt32(GetSize().ToUInt32()) - 1;
                if (length <= 0)
                {
                    return string.Empty;
                }
                return Utils.ToString(NativeMethods.Datalayer.DLR_variantGetSTRING(_nativePtr), length);
            }
        }
 
        public static bool operator ==(Variant x, Variant y)
        {
            //x not null
            if (x is Variant)
            {
                return x.Equals(y);
            }
 
            //y not null
            if (y is Variant)
            {
                return y.Equals(x);
            }
 
            //Both null
            return true;
        }
 
        public static bool operator !=(Variant x, Variant y)
        {
            //x not null
            if (x is Variant)
            {
                return !x.Equals(y);
            }
 
            //y not null
            if (y is Variant)
            {
                return !y.Equals(x);
            }
 
            //Both null
            return false;
        }
 
        #endregion
 
        #region Public Statics
 
        public static readonly int DefaultFlatbuffersInitialSize = 1024;
 
        public static readonly Variant Null = new();
 
        public static readonly Variant Zero = new(0);
 
        public static readonly Variant One = new(1);
 
        public static readonly Variant Empty = new(string.Empty);
 
        public static readonly Variant True = new(true);
 
        public static readonly Variant False = new(false);
 
        #endregion
 
        #region Public Getters
 
        public DateTime Timestamp
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return _timestamp;
            }
        }
 
        public object Value
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return DataType switch
                {
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_BOOL8 => ToBool(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_INT8 => ToSByte(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UINT8 => ToByte(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_INT16 => ToInt16(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UINT16 => ToUInt16(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_INT32 => ToInt32(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UINT32 => ToUInt32(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_INT64 => ToInt64(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UINT64 => ToUInt64(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_FLOAT32 => ToFloat(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_FLOAT64 => ToDouble(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_STRING => ToString(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_BOOL8 => ToBoolArray(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_INT8 => ToSByteArray(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_UINT8 => ToByteArray(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_INT16 => ToInt16Array(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_UINT16 => ToUInt16Array(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_INT32 => ToInt32Array(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_UINT32 => ToUInt32Array(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_INT64 => ToInt64Array(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_UINT64 => ToUInt64Array(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_FLOAT32 => ToFloatArray(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_FLOAT64 => ToDoubleArray(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_STRING => ToStringArray(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_RAW => ToRawByteArray(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_FLATBUFFERS => ToFlatbuffers(),
                    DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UNKNOWN => null,
                    _ => null,
                };
            }
        }
 
        public bool IsNull
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return IsNullPtr || DataType == DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UNKNOWN;
            }
        }
 
        public bool IsArray
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return Utils.IsArray(DataType);
            }
        }
 
        public bool IsString
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return DataType == DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_STRING;
            }
        }
 
        public bool IsBool
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return DataType == DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_BOOL8;
            }
        }
 
        public bool IsNumber
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return Utils.IsNumber(DataType);
            }
        }
 
        public bool IsFlatbuffers
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return DataType == DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_FLATBUFFERS;
            }
        }
 
        public bool ToBool()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return false;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetBOOL8(_nativePtr);
            }
        }
 
        public sbyte ToSByte()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetINT8(_nativePtr);
            }
        }
 
        public byte ToByte()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetUINT8(_nativePtr);
            }
        }
 
        public short ToInt16()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetINT16(_nativePtr);
            }
        }
 
        public ushort ToUInt16()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetUINT16(_nativePtr);
            }
        }
 
        public int ToInt32()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetINT32(_nativePtr);
            }
        }
 
        public uint ToUInt32()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetUINT32(_nativePtr);
            }
        }
 
        public long ToInt64()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetINT64(_nativePtr);
            }
        }
 
        public ulong ToUInt64()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetUINT64(_nativePtr);
            }
        }
 
        public float ToFloat()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetFLOAT32(_nativePtr);
            }
        }
 
        public double ToDouble()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetFLOAT64(_nativePtr);
            }
        }
 
        public bool[] ToBoolArray()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                bool* p = NativeMethods.Datalayer.DLR_variantGetArrayOfBOOL8(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new bool[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = p[i];
                }
                return array;
            }
        }
 
        public sbyte[] ToSByteArray()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                sbyte* p = NativeMethods.Datalayer.DLR_variantGetArrayOfINT8(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new sbyte[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = p[i];
                }
                return array;
            }
        }
 
        public byte[] ToByteArray()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                byte* p = NativeMethods.Datalayer.DLR_variantGetArrayOfUINT8(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new byte[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = p[i];
                }
                return array;
            }
        }
 
        public short[] ToInt16Array()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                short* p = NativeMethods.Datalayer.DLR_variantGetArrayOfINT16(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new short[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = p[i];
                }
                return array;
            }
        }
 
        public ushort[] ToUInt16Array()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                ushort* p = NativeMethods.Datalayer.DLR_variantGetArrayOfUINT16(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new ushort[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = p[i];
                }
                return array;
            }
        }
 
        public int[] ToInt32Array()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                int* p = NativeMethods.Datalayer.DLR_variantGetArrayOfINT32(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new int[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = p[i];
                }
                return array;
            }
        }
 
        public uint[] ToUInt32Array()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                uint* p = NativeMethods.Datalayer.DLR_variantGetArrayOfUINT32(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new uint[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = p[i];
                }
                return array;
            }
        }
 
        public long[] ToInt64Array()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                long* p = NativeMethods.Datalayer.DLR_variantGetArrayOfINT64(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new long[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = p[i];
                }
                return array;
            }
        }
 
        public ulong[] ToUInt64Array()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                ulong* p = NativeMethods.Datalayer.DLR_variantGetArrayOfUINT64(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new ulong[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = p[i];
                }
                return array;
            }
        }
 
        public float[] ToFloatArray()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                float* p = NativeMethods.Datalayer.DLR_variantGetArrayOfFLOAT32(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new float[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = p[i];
                }
                return array;
            }
        }
 
        public double[] ToDoubleArray()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                double* p = NativeMethods.Datalayer.DLR_variantGetArrayOfFLOAT64(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new double[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = p[i];
                }
                return array;
            }
        }
 
        public string[] ToStringArray()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                sbyte** p = NativeMethods.Datalayer.DLR_variantGetArrayOfSTRING(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new string[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = Utils.ToString(p[i]);
                }
                return array;
            }
        }
 
        public DLR_VARIANT_TYPE DataType
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                if (IsNullPtr)
                {
                    return DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UNKNOWN;
                }
 
                unsafe
                {
                    return NativeMethods.Datalayer.DLR_variantGetType(_nativePtr);
                }
            }
        }
 
        public string JsonDataType
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return Utils.ToJsonDataType(DataType);
            }
        }
 
        public ByteBuffer ToFlatbuffers()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            if (!IsFlatbuffers)
            {
                return null;
            }
 
            unsafe
            {
                byte* p = NativeMethods.Datalayer.DLR_variantGetData(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var count = GetCount().ToUInt32();
                var array = new byte[count];
                for (var i = 0; i < count; i++)
                {
                    array[i] = p[i];
                }
                return new ByteBuffer(array);
            }
        }
 
 
        public byte[] ToRawByteArray()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                byte* p = NativeMethods.Datalayer.DLR_variantGetData(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var value = Marshal.PtrToStringUTF8((IntPtr)p, Convert.ToInt32(GetSize().ToUInt32()));
                return Encoding.UTF8.GetBytes(value);
            }
        }
 
        #endregion
 
        #region Public Methods
 
        public Variant Clone()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNullPtr)
            {
                return new Variant();
            }
 
            unsafe
            {
                var clone = new Variant();
                if (NativeMethods.Datalayer.DLR_variantCopy(clone.ToNativePtr(), this.ToNativePtr()).IsBad())
                {
                    throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCloneable);
                }
 
                return clone;
            }
        }
 
        public DLR_RESULT CheckConvert(DLR_VARIANT_TYPE type)
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (IsNull)
            {
                return DLR_RESULT.DL_TYPE_MISMATCH;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantCheckConvert(_nativePtr, type);
            }
        }
 
        #endregion
 
        #region Public Implicit Operators
 
        public static implicit operator Variant(bool source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(bool[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(sbyte source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(sbyte[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(byte source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(byte[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(short source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(short[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(ushort source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(ushort[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(int source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(int[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(uint source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(uint[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(long source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(long[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(ulong source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(ulong[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(float source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(float[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(double source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(double[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(string source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(string[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(FlatBufferBuilder builder)
        {
            return new Variant(builder);
        }
 
        public static implicit operator Variant(ByteBuffer flatBuffers)
        {
            return new Variant(flatBuffers);
        }
 
        #endregion
 
        #region Private Setter
 
        private DLR_RESULT SetBool(bool value)
        {
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetBOOL8(_nativePtr, value);
            }
        }
 
        private DLR_RESULT SetInt8(sbyte value)
        {
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetINT8(_nativePtr, value);
            }
        }
 
        private DLR_RESULT SetUInt8(byte value)
        {
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetUINT8(_nativePtr, value);
            }
        }
 
        private DLR_RESULT SetInt16(short value)
        {
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetINT16(_nativePtr, value);
            }
        }
 
        private DLR_RESULT SetUInt16(ushort value)
        {
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetUINT16(_nativePtr, value);
            }
        }
 
        private DLR_RESULT SetInt32(int value)
        {
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetINT32(_nativePtr, value);
            }
        }
 
        private DLR_RESULT SetUInt32(uint value)
        {
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetUINT32(_nativePtr, value);
            }
        }
 
        private DLR_RESULT SetInt64(long value)
        {
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetINT64(_nativePtr, value);
            }
        }
 
        private DLR_RESULT SetUInt64(ulong value)
        {
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetUINT64(_nativePtr, value);
            }
        }
 
        private DLR_RESULT SetFloat32(float value)
        {
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetFLOAT32(_nativePtr, value);
            }
        }
 
        private DLR_RESULT SetFloat64(double value)
        {
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetFLOAT64(_nativePtr, value);
            }
        }
 
        private DLR_RESULT SetString(string value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetSTRING(_nativePtr, value.ToSBytePtr());
            }
        }
 
        private DLR_RESULT SetArrayOfBool(bool[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                fixed (bool* p = value)
                {
                    return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_BOOL8(_nativePtr, p, new UIntPtr(Convert.ToUInt32(value.Length)));
                }
            }
        }
 
        private DLR_RESULT SetArrayOfInt8(sbyte[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                fixed (sbyte* p = value)
                {
                    return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_INT8(_nativePtr, p, new UIntPtr(Convert.ToUInt32(value.Length)));
                }
            }
        }
 
        private DLR_RESULT SetArrayOfUInt8(byte[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                fixed (byte* p = value)
                {
                    return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_UINT8(_nativePtr, p, new UIntPtr(Convert.ToUInt32(value.Length)));
                }
            }
        }
 
        private DLR_RESULT SetArrayOfInt16(short[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                fixed (short* p = value)
                {
                    return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_INT16(_nativePtr, p, new UIntPtr(Convert.ToUInt32(value.Length)));
                }
            }
        }
 
        private DLR_RESULT SetArrayOfUInt16(ushort[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                fixed (ushort* p = value)
                {
                    return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_UINT16(_nativePtr, p, new UIntPtr(Convert.ToUInt32(value.Length)));
                }
            }
        }
 
        private DLR_RESULT SetArrayOfInt32(int[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                fixed (int* p = value)
                {
                    return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_INT32(_nativePtr, p, new UIntPtr(Convert.ToUInt32(value.Length)));
                }
            }
        }
 
        private DLR_RESULT SetArrayOfUInt32(uint[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                fixed (uint* p = value)
                {
                    return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_UINT32(_nativePtr, p, new UIntPtr(Convert.ToUInt32(value.Length)));
                }
            }
        }
 
        private DLR_RESULT SetArrayOfInt64(long[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                fixed (long* p = value)
                {
                    return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_INT64(_nativePtr, p, new UIntPtr(Convert.ToUInt32(value.Length)));
                }
            }
        }
 
        private DLR_RESULT SetArrayOfUInt64(ulong[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                fixed (ulong* p = value)
                {
                    return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_UINT64(_nativePtr, p, new UIntPtr(Convert.ToUInt32(value.Length)));
                }
            }
        }
 
        private DLR_RESULT SetArrayOfFloat32(float[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                fixed (float* p = value)
                {
                    return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_FLOAT32(_nativePtr, p, new UIntPtr(Convert.ToUInt32(value.Length)));
                }
            }
        }
 
        private DLR_RESULT SetArrayOfFloat64(double[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                fixed (double* p = value)
                {
                    return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_FLOAT64(_nativePtr, p, new UIntPtr(Convert.ToUInt32(value.Length)));
                }
            }
        }
 
        private DLR_RESULT SetArrayOfString(string[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                var array = new sbyte*[value.Length];
                for (var i = 0; i < value.Length; i++)
                {
                    array[i] = value[i].ToSBytePtr();
                }
 
                fixed (sbyte** p = array)
                {
                    return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_STRING(_nativePtr, p, new UIntPtr(Convert.ToUInt32(value.Length)));
                }
            }
        }
 
        private DLR_RESULT SetFlatbuffers(ByteBuffer value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            var sbyteArray = Array.ConvertAll(value.ToSizedArray(), b => unchecked((sbyte)b));
 
            unsafe
            {
                fixed (sbyte* p = sbyteArray)
                {
                    return NativeMethods.Datalayer.DLR_variantSetFlatbuffers(_nativePtr, p, new UIntPtr(Convert.ToUInt32(sbyteArray.Length)));
                }
            }
        }
 
        #endregion
 
        #region Private Methods
 
        internal UIntPtr GetSize()
        {
            if (IsNull)
            {
                return UIntPtr.Zero;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetSize(_nativePtr);
            }
        }
 
        internal UIntPtr GetCount()
        {
            if (IsNull)
            {
                return UIntPtr.Zero;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetCount(_nativePtr);
            }
        }
 
        #endregion
    }
}