Archive.cs

Go to the documentation of this file.

using System.Runtime.InteropServices;
using IDSImaging.Peak.Common.Serialization;
using IDSImaging.Peak.ICV.Backend;
using Microsoft.Win32.SafeHandles;
 
namespace IDSImaging.Peak.ICV.Serialization;
 
public class Archive : ArchiveBase, IDisposable, IHasSafeHandle
{
    private static readonly Dictionary<Backend.Types.peak_icv_archive_value_type, ArchiveValueKind> _sValueKindMap =
        new()
        {
            { Backend.Types.peak_icv_archive_value_type.PEAK_ICV_ARCHIVE_VALUE_TYPE_BOOL, ArchiveValueKind.Bool },
            {
                Backend.Types.peak_icv_archive_value_type.PEAK_ICV_ARCHIVE_VALUE_TYPE_BOOL_ARRAY,
                ArchiveValueKind.BoolArray
            },
            { Backend.Types.peak_icv_archive_value_type.PEAK_ICV_ARCHIVE_VALUE_TYPE_INT, ArchiveValueKind.Int64 },
            {
                Backend.Types.peak_icv_archive_value_type.PEAK_ICV_ARCHIVE_VALUE_TYPE_INT_ARRAY,
                ArchiveValueKind.Int64Array
            },
            {
                Backend.Types.peak_icv_archive_value_type.PEAK_ICV_ARCHIVE_VALUE_TYPE_DOUBLE,
                ArchiveValueKind.Double
            },
            {
                Backend.Types.peak_icv_archive_value_type.PEAK_ICV_ARCHIVE_VALUE_TYPE_DOUBLE_ARRAY,
                ArchiveValueKind.DoubleArray
            },
            {
                Backend.Types.peak_icv_archive_value_type.PEAK_ICV_ARCHIVE_VALUE_TYPE_STRING,
                ArchiveValueKind.String
            },
            {
                Backend.Types.peak_icv_archive_value_type.PEAK_ICV_ARCHIVE_VALUE_TYPE_STRING_ARRAY,
                ArchiveValueKind.StringArray
            },
            {
                Backend.Types.peak_icv_archive_value_type.PEAK_ICV_ARCHIVE_VALUE_TYPE_ARCHIVE,
                ArchiveValueKind.Archive
            },
            {
                Backend.Types.peak_icv_archive_value_type.PEAK_ICV_ARCHIVE_VALUE_TYPE_ARCHIVE_ARRAY,
                ArchiveValueKind.ArchiveArray
            }
        };
 
    private bool _disposed;
 
    internal Handle _handle;
 
    internal Archive(Handle handle)
    {
        _handle = handle;
    }
 
    public Archive()
    {
        var handle = new Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_Create(ref handle));
        _handle = handle;
    }
 
    public void Dispose()
    {
        if (_disposed)
        {
            return;
        }
 
        _disposed = true;
        _handle.Dispose();
        GC.SuppressFinalize(this);
    }
 
    SafeHandle IHasSafeHandle.Handle => _handle;
 
    public override bool HasKey(string key)
    {
        var hasKey = false;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_HasKey(_handle, Utils.ToUtf8(key), ref hasKey));
        return hasKey;
    }
 
    public override ArchiveValueKind GetValueKind(string key)
    {
        var type = 0;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_GetValueType(_handle, Utils.ToUtf8(key), ref type));
 
        return _sValueKindMap[(Backend.Types.peak_icv_archive_value_type) type];
    }
 
    public override IReadOnlyList<string> GetKeys()
    {
        nuint keyCount = 0;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_GetKeys_GetCount(_handle, ref keyCount));
 
        var list = new List<string>((int) keyCount);
 
        for (nuint i = 0; i < keyCount; i++)
        {
            nuint elementSize = 0;
            nuint i1 = i;
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Archive_GetKeysElement_GetSizeInBytes(_handle, i1, ref elementSize));
 
            var data = new byte[elementSize];
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Archive_GetKeysElement(_handle, i1, data, elementSize));
 
            list.Add(Utils.FromUtf8(data));
        }
 
        return list;
    }
 
    public override void SetBool(string key, bool value)
    {
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_SetBool(_handle, Utils.ToUtf8(key), value));
    }
 
    public override bool GetBool(string key)
    {
        var value = false;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_GetBool(_handle, Utils.ToUtf8(key), ref value));
        return value;
    }
 
    public override void SetInt64(string key, long value)
    {
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_SetInt(_handle, Utils.ToUtf8(key), value));
    }
 
    public override long GetInt64(string key)
    {
        long value = 0;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_GetInt(_handle, Utils.ToUtf8(key), ref value));
        return value;
    }
 
    public override void SetDouble(string key, double value)
    {
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_SetDouble(_handle, Utils.ToUtf8(key), value));
    }
 
    public override double GetDouble(string key)
    {
        double value = 0;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_GetDouble(_handle, Utils.ToUtf8(key), ref value));
        return value;
    }
 
    public override void SetString(string key, string value)
    {
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_SetString(_handle, Utils.ToUtf8(key), Utils.ToUtf8(value)));
    }
 
    public override string GetString(string key)
    {
        nuint size = 0;
        var utf8Key = Utils.ToUtf8(key);
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_GetString_GetSizeInBytes(_handle, utf8Key, ref size));
 
        var data = new byte[size];
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_GetString(_handle, utf8Key, data, size));
 
        return Utils.FromUtf8(data);
    }
 
    public override void SetArchive(string key, IArchive value)
    {
        if (value is not Archive arch)
        {
            throw new IcvNullPointerException("Given archive or archive type is invalid.");
        }
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_SetArchive(_handle, Utils.ToUtf8(key), arch._handle));
    }
 
    public override IArchive GetArchive(string key)
    {
        var subArchiveHandle = new Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_GetArchive(_handle, Utils.ToUtf8(key), ref subArchiveHandle));
        return new Archive(subArchiveHandle);
    }
 
    public override int GetArrayCount(string key)
    {
        return GetArrayCount(Utils.ToUtf8(key));
    }
 
    private int GetArrayCount(byte[] key)
    {
        nuint count = 0;
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_GetArray_GetCount(_handle, key, ref count));
        return (int) count;
    }
 
    public override void SetBoolArray(string key, IEnumerable<bool> value)
    {
        var array = value.ToArray() ?? throw new IcvNullPointerException(nameof(value));
        var byteArray = array.Select(x => (byte) (x ? 1 : 0)).ToArray();
 
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_SetBoolArray(_handle, Utils.ToUtf8(key), byteArray, (nuint) array.Length));
    }
 
    public override IReadOnlyList<bool> GetBoolArray(string key)
    {
        var utf8Key = Utils.ToUtf8(key);
        var arrayCount = GetArrayCount(utf8Key);
        var values = new byte[arrayCount];
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_GetBoolArray(_handle, utf8Key, values, (nuint) arrayCount));
        return values.Select(x => x > 0).ToList();
    }
 
    public override void SetInt64Array(string key, IEnumerable<long> value)
    {
        var array = value.ToArray() ?? throw new IcvNullPointerException(nameof(value));
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_SetIntArray(_handle, Utils.ToUtf8(key), array, (nuint) array.Length));
    }
 
    public override IReadOnlyList<long> GetInt64Array(string key)
    {
        var utf8Key = Utils.ToUtf8(key);
        var arrayCount = GetArrayCount(utf8Key);
        var values = new long[arrayCount];
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_GetIntArray(_handle, utf8Key, values, (nuint) arrayCount));
        return values;
    }
 
    public override void SetDoubleArray(string key, IEnumerable<double> value)
    {
        var array = value.ToArray() ?? throw new IcvNullPointerException(nameof(value));
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_SetDoubleArray(_handle, Utils.ToUtf8(key), array, (nuint) array.Length));
    }
 
    public override IReadOnlyList<double> GetDoubleArray(string key)
    {
        var utf8Key = Utils.ToUtf8(key);
        var arrayCount = GetArrayCount(utf8Key);
        var values = new double[arrayCount];
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_GetDoubleArray(_handle, utf8Key, values, (nuint) arrayCount));
        return values;
    }
 
    public override void SetStringArray(string key, IEnumerable<string> value)
    {
        List<string> values = value.ToList() ?? throw new IcvNullPointerException(nameof(value));
 
        var stringPointers = new IntPtr[values.Count];
        var allocatedStrings = new List<IntPtr>();
 
        try
        {
            for (var i = 0; i < values.Count; i++)
            {
                var entry = values[i] ?? throw new IcvNullPointerException($"{nameof(values)}[{i}]");
 
                var bytes = Utils.ToUtf8(entry);
 
                IntPtr strPtr = Marshal.AllocHGlobal(bytes.Length);
                Marshal.Copy(bytes, 0, strPtr, bytes.Length);
 
                allocatedStrings.Add(strPtr);
                stringPointers[i] = strPtr;
            }
 
            IntPtr arrayPtr = Marshal.AllocHGlobal(IntPtr.Size * values.Count);
 
            try
            {
                Marshal.Copy(stringPointers, 0, arrayPtr, values.Count);
 
                DllHelper.ExecuteAndMapReturnCodes(() =>
                    CInterface.peak_icv_Archive_SetStringArray(_handle, Utils.ToUtf8(key), arrayPtr,
                        (nuint) values.Count));
            }
            finally
            {
                Marshal.FreeHGlobal(arrayPtr);
            }
        }
        finally
        {
            foreach (IntPtr ptr in allocatedStrings)
            {
                Marshal.FreeHGlobal(ptr);
            }
        }
    }
 
    public override IReadOnlyList<string> GetStringArray(string key)
    {
        var utf8Key = Utils.ToUtf8(key);
        var arrayCount = GetArrayCount(utf8Key);
        var values = new List<string>(arrayCount);
 
        for (var i = 0; i < arrayCount; i++)
        {
            nuint length = 0;
            var index = (nuint) i;
 
            DllHelper.ExecuteAndMapReturnCodes(() => CInterface.peak_icv_Archive_GetStringArrayElement_GetSizeInBytes(
                _handle, utf8Key, index,
                ref length));
 
            var data = new byte[length];
            DllHelper.ExecuteAndMapReturnCodes(() =>
                CInterface.peak_icv_Archive_GetStringArrayElement(_handle, utf8Key, index, data, length));
            values.Add(Utils.FromUtf8(data));
        }
 
        return values;
    }
 
    public override void SetArchiveArray(string key, IEnumerable<IArchive> value)
    {
        List<IArchive> values = value.ToList() ?? throw new IcvNullPointerException(nameof(value));
 
        IntPtr[] handles = SafeHandles.ExtractHandles(
            values,
            obj => obj is not Archive arch
                ? throw new IcvNullPointerException("Invalid archive type in array.")
                : arch._handle,
            out Action release);
        try
        {
            var utf8Key = Utils.ToUtf8(key);
            DllHelper.ExecuteAndMapReturnCodes(() =>
            {
                unsafe
                {
                    fixed (IntPtr* ptr = handles)
                    {
                        return (Backend.Types.peak_icv_status) CInterface.peak_icv_Archive_SetArchiveArray(_handle,
                            utf8Key, (IntPtr) ptr, (nuint) values.Count);
                    }
                }
            });
        }
        finally
        {
            release();
        }
    }
 
    public override IReadOnlyList<IArchive> GetArchiveArray(string key)
    {
        var utf8Key = Utils.ToUtf8(key);
        var arrayCount = GetArrayCount(utf8Key);
 
        if (arrayCount == 0)
        {
            return Array.Empty<IArchive>();
        }
 
        var archivePointers = new IntPtr[arrayCount];
        DllHelper.ExecuteAndMapReturnCodes(() =>
        {
            unsafe
            {
                fixed (IntPtr* ptr = archivePointers)
                {
                    return (Backend.Types.peak_icv_status) CInterface.peak_icv_Archive_GetArchiveArray(_handle,
                        utf8Key, (IntPtr) ptr, (nuint) arrayCount);
                }
            }
        });
 
        return archivePointers.Select(x => new Archive(new Handle(x))).ToList();
    }
 
    public override IArchive CreateArchive()
    {
        var handle = new Handle();
        DllHelper.ExecuteAndMapReturnCodes(() =>
            CInterface.peak_icv_Archive_Create(ref handle));
        return new Archive(handle);
    }
 
    internal sealed class Handle : SafeHandleZeroOrMinusOneIsInvalid
    {
        internal Handle() : base(true)
        {
        }
 
        internal Handle(IntPtr handle) : base(true)
        {
            SetHandle(handle);
        }
 
        protected override bool ReleaseHandle()
        {
            Backend.Types.peak_icv_status ret = CInterface.peak_icv_Archive_Destroy(handle);
            return ret == 0;
        }
    }
 
    private static class CInterface
    {
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_Create(ref Handle archiveHandle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_Destroy(IntPtr archiveHandle);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_HasKey(Handle archiveHandle,
            byte[] key,
            [MarshalAs(UnmanagedType.I1)] ref bool hasKey);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetKeys_GetCount(
            Handle archiveHandle, ref nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetKeysElement_GetSizeInBytes(
            Handle archiveHandle, nuint index, ref nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetKeysElement(
            Handle archiveHandle, nuint index, byte[] data, nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetValueType(
            Handle archiveHandle, byte[] key, ref int type);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetArray_GetCount(
            Handle archiveHandle, byte[] key, ref nuint count);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetInt(
            Handle archiveHandle, byte[] key, ref long value);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_SetInt(
            Handle archiveHandle, byte[] key, long value);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetIntArray(
            Handle archiveHandle, byte[] key, long[] values, nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_SetIntArray(
            Handle archiveHandle, byte[] key, long[] values, nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetDouble(
            Handle archiveHandle, byte[] key, ref double value);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_SetDouble(
            Handle archiveHandle, byte[] key, double value);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetDoubleArray(
            Handle archiveHandle, byte[] key, double[] values, nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_SetDoubleArray(
            Handle archiveHandle, byte[] key, double[] values, nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetBool(
            Handle archiveHandle, byte[] key, [MarshalAs(UnmanagedType.I1)] ref bool value);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_SetBool(
            Handle archiveHandle, byte[] key, [MarshalAs(UnmanagedType.I1)] bool value);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetBoolArray(
            Handle archiveHandle, byte[] key,
            byte[] values,
            nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_SetBoolArray(
            Handle archiveHandle, byte[] key,
            byte[] values,
            nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetString_GetSizeInBytes(
            Handle archiveHandle, byte[] key, ref nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetString(
            Handle archiveHandle, byte[] key, byte[] data, nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_SetString(
            Handle archiveHandle, byte[] key, byte[] data);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetStringArrayElement_GetSizeInBytes(
            Handle archiveHandle, byte[] key, nuint index, ref nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetStringArrayElement(
            Handle archiveHandle, byte[] key, nuint index, byte[] data, nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_SetStringArray(
            Handle archiveHandle, byte[] key, IntPtr data, nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_GetArchive(
            Handle archiveHandle, byte[] key, ref Handle subArchive);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern Backend.Types.peak_icv_status peak_icv_Archive_SetArchive(
            Handle archiveHandle, byte[] key, Handle subArchive);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern int peak_icv_Archive_GetArchiveArray(
            Handle archiveHandle,
            byte[] key,
            IntPtr subArchiveHandles,
            nuint size);
 
        [DllImport(Global.LibraryName, CallingConvention = Global.CallingConvention)]
        public static extern int peak_icv_Archive_SetArchiveArray(
            Handle archiveHandle,
            byte[] key,
            IntPtr subArchiveHandles,
            nuint size);
    }
}