Variant.cs

 
 
using Datalayer.Internal;
using Google.FlatBuffers;
using System;
using System.Collections;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
 
namespace Datalayer
{
    [DebuggerDisplay("{Value}")]
    public class Variant : IVariant, INative
    {
        // Fields
        private readonly bool _skipDelete;
        private unsafe void* _nativePtr;
 
        #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(DateTime value)
           : this()
        {
            if (SetTimestamp(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, bool raw = false)
           : this()
        {
            if (raw)
            {
                if (SetArrayOfRawBytes(value).IsBad())
                {
                    throw new InvalidOperationException(Utils.Strings.ErrorObjectNotCreatable);
                }
            }
            else
            {
                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(DateTime[] value)
           : this()
        {
            if (SetArrayOfTimestamp(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 null)
            {
                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 (IsNull)
            {
                return string.Empty;
            }
 
            unsafe
            {
                var length = Convert.ToInt32(GetSize().ToUInt32()) - 1;
                if (length <= 0)
                {
                    return string.Empty;
                }
 
                var stringBuffer =
                    StringBuffer.FromNativePtr(NativeMethods.Datalayer.DLR_variantGetSTRING(_nativePtr), length);
                return stringBuffer.ToString();
            }
        }
 
        public static bool operator ==(Variant l, Variant r)
        {
            //x not null
            if (l is Variant)
            {
                return l.Equals(r);
            }
 
            //y not null
            if (r is Variant)
            {
                return r.Equals(l);
            }
 
            //Both null
            return true;
        }
 
        public static bool operator !=(Variant l, Variant r)
        {
            //x not null
            if (l is Variant)
            {
                return !l.Equals(r);
            }
 
            //y not null
            if (r is Variant)
            {
                return !r.Equals(l);
            }
 
            //Both null
            return false;
        }
 
        #endregion
 
        #region Public Statics
 
        public static readonly int DefaultFlatbuffersInitialSize = 1024;
 
        public static readonly Variant Null = new Variant();
 
        public static readonly Variant Zero = new Variant(0);
 
        public static readonly Variant One = new Variant(1);
 
        public static readonly Variant Empty = new Variant(string.Empty);
 
        public static readonly Variant True = new Variant(true);
 
        public static readonly Variant False = new Variant(false);
 
        #endregion
 
        #region Public Getters
 
        public object Value
        {
            get
            {
                switch (DataType)
                {
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_BOOL8:
                        return ToBool();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_INT8:
                        return ToSByte();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UINT8:
                        return ToByte();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_INT16:
                        return ToInt16();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UINT16:
                        return ToUInt16();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_INT32:
                        return ToInt32();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UINT32:
                        return ToUInt32();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_INT64:
                        return ToInt64();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UINT64:
                        return ToUInt64();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_FLOAT32:
                        return ToFloat();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_FLOAT64:
                        return ToDouble();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_STRING:
                        return ToString();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_TIMESTAMP:
                        return ToDateTime();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_BOOL8:
                        return ToBoolArray();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_INT8:
                        return ToSByteArray();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_UINT8:
                        return ToByteArray();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_INT16:
                        return ToInt16Array();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_UINT16:
                        return ToUInt16Array();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_INT32:
                        return ToInt32Array();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_UINT32:
                        return ToUInt32Array();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_INT64:
                        return ToInt64Array();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_UINT64:
                        return ToUInt64Array();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_FLOAT32:
                        return ToFloatArray();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_FLOAT64:
                        return ToDoubleArray();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_STRING:
                        return ToStringArray();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_ARRAY_OF_TIMESTAMP:
                        return ToDateTimeArray();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_RAW:
                        return ToRawByteArray();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_FLATBUFFERS:
                        return ToFlatbuffers();
                    case DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UNKNOWN:
                    default:
                        return null;
                }
            }
        }
 
        public bool IsNull => DataType == DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_UNKNOWN;
 
        public bool IsString => DataType == DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_STRING;
 
        public bool IsBool => DataType == DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_BOOL8;
 
        public bool IsFlatbuffers => DataType == DLR_VARIANT_TYPE.DLR_VARIANT_TYPE_FLATBUFFERS;
 
        public bool IsArray
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return Utils.IsArray(DataType);
            }
        }
 
        public bool IsNumber
        {
            get
            {
                if (IsDisposed)
                {
                    throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
                }
 
                return Utils.IsNumber(DataType);
            }
        }
 
        public bool ToBool()
        {
            if (IsNull)
            {
                return false;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetBOOL8(_nativePtr);
            }
        }
 
        public sbyte ToSByte()
        {
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetINT8(_nativePtr);
            }
        }
 
        public byte ToByte()
        {
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetUINT8(_nativePtr);
            }
        }
 
        public short ToInt16()
        {
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetINT16(_nativePtr);
            }
        }
 
        public ushort ToUInt16()
        {
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetUINT16(_nativePtr);
            }
        }
 
        public int ToInt32()
        {
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetINT32(_nativePtr);
            }
        }
 
        public uint ToUInt32()
        {
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetUINT32(_nativePtr);
            }
        }
 
        public long ToInt64()
        {
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetINT64(_nativePtr);
            }
        }
 
        public ulong ToUInt64()
        {
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetUINT64(_nativePtr);
            }
        }
 
        public DateTime ToDateTime()
        {
            //uint64 (FILETIME) 64 bit 100ns since 1.1.1601 (UTC) -> long -> DateTime
            return DateTime.FromFileTimeUtc(Convert.ToInt64(ToUInt64()));
        }
 
        public float ToFloat()
        {
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetFLOAT32(_nativePtr);
            }
        }
 
        public double ToDouble()
        {
            if (IsNull)
            {
                return 0;
            }
 
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantGetFLOAT64(_nativePtr);
            }
        }
 
        public bool[] ToBoolArray()
        {
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                bool* p = NativeMethods.Datalayer.DLR_variantGetArrayOfBOOL8(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<bool>();
                }
 
                // memcopy not available: we have to iterate
 
                //var array = new bool[GetCount().ToUInt32()];
                //Marshal.Copy((IntPtr)p, array, 0, array.Length);
 
                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 (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                sbyte* p = NativeMethods.Datalayer.DLR_variantGetArrayOfINT8(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<sbyte>();
                }
 
                // memcopy not available: we have to iterate
 
                //var array = new sbyte[GetCount().ToUInt32()];
                //Marshal.Copy((IntPtr)p, array, 0, array.Length);
 
                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 (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                byte* p = NativeMethods.Datalayer.DLR_variantGetArrayOfUINT8(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<byte>();
                }
 
                var array = new byte[GetCount().ToUInt32()];
                Marshal.Copy((IntPtr)p, array, 0, array.Length);
                return array;
            }
        }
 
        public short[] ToInt16Array()
        {
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                short* p = NativeMethods.Datalayer.DLR_variantGetArrayOfINT16(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<short>();
                }
 
                var array = new short[GetCount().ToUInt32()];
                Marshal.Copy((IntPtr)p, array, 0, array.Length);
                return array;
            }
        }
 
        public ushort[] ToUInt16Array()
        {
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                ushort* p = NativeMethods.Datalayer.DLR_variantGetArrayOfUINT16(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<ushort>();
                }
                // memcopy not available: we have to iterate
 
                //var array = new ushort[GetCount().ToUInt32()];
                //Marshal.Copy((IntPtr)p, array, 0, array.Length);
 
                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 (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                int* p = NativeMethods.Datalayer.DLR_variantGetArrayOfINT32(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<int>();
                }
 
                var array = new int[GetCount().ToUInt32()];
                Marshal.Copy((IntPtr)p, array, 0, array.Length);
                return array;
            }
        }
 
        public uint[] ToUInt32Array()
        {
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                uint* p = NativeMethods.Datalayer.DLR_variantGetArrayOfUINT32(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<uint>();
                }
 
                // memcopy not available: we have to iterate
 
                //var array = new uint[GetCount().ToUInt32()];
                //Marshal.Copy((IntPtr)p, array, 0, array.Length);
 
                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 (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                long* p = NativeMethods.Datalayer.DLR_variantGetArrayOfINT64(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<long>();
                }
 
                var array = new long[GetCount().ToUInt32()];
                Marshal.Copy((IntPtr)p, array, 0, array.Length);
                return array;
            }
        }
 
        public ulong[] ToUInt64Array()
        {
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                ulong* p = NativeMethods.Datalayer.DLR_variantGetArrayOfUINT64(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<ulong>();
                }
 
                // memcopy not available: we have to iterate
 
                //var array = new ulong[GetCount().ToUInt32()];
                //Marshal.Copy((IntPtr)p, array, 0, array.Length);
 
                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 (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                float* p = NativeMethods.Datalayer.DLR_variantGetArrayOfFLOAT32(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<float>();
                }
 
                var array = new float[GetCount().ToUInt32()];
                Marshal.Copy((IntPtr)p, array, 0, array.Length);
                return array;
            }
        }
 
        public double[] ToDoubleArray()
        {
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                double* p = NativeMethods.Datalayer.DLR_variantGetArrayOfFLOAT64(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<double>();
                }
 
                var array = new double[GetCount().ToUInt32()];
                Marshal.Copy((IntPtr)p, array, 0, array.Length);
                return array;
            }
        }
 
        public string[] ToStringArray()
        {
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                sbyte** p = NativeMethods.Datalayer.DLR_variantGetArrayOfSTRING(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<string>();
                }
 
                var count = GetCount().ToUInt32();
                var stringBufferArray = StringBufferArray.FromNativePtr(p, count);
                return stringBufferArray.ToStringArray();
            }
        }
 
        public DateTime[] ToDateTimeArray()
        {
            //uint64 (FILETIME) 64 bit 100ns since 1.1.1601 (UTC) -> long -> DateTime
            return ToUInt64Array()?.Select(v => DateTime.FromFileTimeUtc(Convert.ToInt64(v))).ToArray();
        }
 
        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 (IsNull)
            {
                return null;
            }
 
            if (!IsFlatbuffers)
            {
                return null;
            }
 
            unsafe
            {
                byte* p = NativeMethods.Datalayer.DLR_variantGetData(_nativePtr);
                if (p == null)
                {
                    return null;
                }
 
                var array = new byte[GetCount().ToUInt32()];
                Marshal.Copy((IntPtr)p, array, 0, array.Length);
                return new ByteBuffer(array);
            }
        }
 
        public byte[] ToRawByteArray()
        {
            if (IsNull)
            {
                return null;
            }
 
            unsafe
            {
                byte* p = NativeMethods.Datalayer.DLR_variantGetData(_nativePtr);
                if (p == null)
                {
                    return Array.Empty<byte>();
                }
 
                var array = new byte[GetCount().ToUInt32()];
                Marshal.Copy((IntPtr)p, array, 0, array.Length);
                return array;
            }
        }
 
        #endregion
 
        #region Public Methods
 
        public (DLR_RESULT result, IVariant value) GetDataFromFlatbuffers(IVariant typeFlatbuffers, string query)
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(Utils.Strings.ErrorObjectDisposed);
            }
 
            if (typeFlatbuffers == null)
            {
                throw new ArgumentNullException(nameof(typeFlatbuffers));
            }
 
            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }
 
            if (IsNull)
            {
                return (DLR_RESULT.DL_INVALID_VALUE, Null);
            }
 
            var dataValue = new Variant();
            var queryBuffer = StringBuffer.FromString(query);
 
            unsafe
            {
                return (NativeMethods.Datalayer.DLR_getDataFromFlatbuffers(
                    this.ToNativePtr(),
                    typeFlatbuffers.ToNativePtr(),
                    queryBuffer.ToNativePtr(),
                    dataValue.ToNativePtr()), dataValue);
            }
        }
 
        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 (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(DateTime source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(DateTime[] source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(FlatBufferBuilder source)
        {
            return new Variant(source);
        }
 
        public static implicit operator Variant(ByteBuffer source)
        {
            return new Variant(source);
        }
 
        #endregion
 
        #region Private Setter
 
        private DLR_RESULT SetBool(bool value)
        {
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetBOOL8(_nativePtr, Convert.ToByte(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));
            }
 
            var valueBuffer = StringBuffer.FromString(value);
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetSTRING(_nativePtr, valueBuffer.ToNativePtr());
            }
        }
 
        private DLR_RESULT SetTimestamp(DateTime value)
        {
            unsafe
            {
                try
                {
                    //DateTime -> FileTimeUtc -> ulong -> uint64 (FILETIME) 64 bit 100ns since 1.1.1601 (UTC)
                    return NativeMethods.Datalayer.DLR_variantSetTimestamp(_nativePtr, Convert.ToUInt64(value.ToFileTimeUtc()));
                }
                catch (ArgumentOutOfRangeException)
                {
                    // The resulting file time would represent a date and time before 12:00 midnight January 1, 1601 C.E. UTC.
                    return DLR_RESULT.DL_FAILED;
                }
            }
        }
 
        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 SetArrayOfTimestamp(DateTime[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                try
                {
                    //DateTime -> FileTimeUtc -> ulong -> uint64 (FILETIME) 64 bit 100ns since 1.1.1601 (UTC)
                    var timeStamps = value.Select(v => Convert.ToUInt64(v.ToFileTimeUtc())).ToArray();
 
                    fixed (ulong* p = timeStamps)
                    {
                        return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_TIMESTAMP(_nativePtr, p, new UIntPtr(Convert.ToUInt32(timeStamps.Length)));
                    }
                }
                catch (ArgumentOutOfRangeException)
                {
                    // The resulting file time would represent a date and time before 12:00 midnight January 1, 1601 C.E. UTC.
                    return DLR_RESULT.DL_FAILED;
                }
            }
        }
 
        private DLR_RESULT SetArrayOfString(string[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
 
            var stringBufferArray = StringBufferArray.FromStringArray(value);
            unsafe
            {
                return NativeMethods.Datalayer.DLR_variantSetARRAY_OF_STRING(_nativePtr, stringBufferArray.ToNativePtr(), new UIntPtr(Convert.ToUInt32(value.Length)));
            }
        }
 
        private DLR_RESULT SetFlatbuffers(ByteBuffer value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            // Note: We have to convert Flatbuffers original byte[] to a sbyte[], because of bad Datalayer ANSI-C API design (which would be a incompabible change to byte[]).
 
            //OPTION A: SLOW: Convert byte[] to sbyte[] bytewise
            //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)));
            //    }
            //}
 
            //OPTION B: FASTER: Use BlockCopy to convert byte[] to sbyte[]
            //var buffer = value.ToSizedArray();
            //sbyte[] sbyteArray = new sbyte[buffer.Length];
            //Buffer.BlockCopy(buffer, 0, sbyteArray, 0, buffer.Length);
            //unsafe
            //{
            //    fixed (sbyte* p = sbyteArray)
            //    {
            //        return NativeMethods.Datalayer.DLR_variantSetFlatbuffers(_nativePtr, p, new UIntPtr(Convert.ToUInt32(sbyteArray.Length)));
            //    }
            //}
 
            //OPTION C: FASTEST: Convert byte* to sbyte*, pointing to original memory (no copy)
            var byteArray = value.ToSizedArray();
            unsafe
            {
                fixed (byte* p = byteArray)
                {
                    sbyte* psByte = (sbyte*)p;
                    return NativeMethods.Datalayer.DLR_variantSetFlatbuffers(_nativePtr, psByte, new UIntPtr(Convert.ToUInt32(byteArray.Length)));
                }
            }
        }
 
        private DLR_RESULT SetArrayOfRawBytes(byte[] value)
        {
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
 
            unsafe
            {
                fixed (byte* p = value)
                {
                    sbyte* psByte = (sbyte*)p;
                    return NativeMethods.Datalayer.DLR_variantSetRaw(_nativePtr, psByte, new UIntPtr(Convert.ToUInt32(value.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
    }
}