servicepoint/crates/servicepoint_binding_cs/ServicePoint/Packet.g.cs

// <auto-generated>
// This code is generated by csbindgen.
// DON'T CHANGE THIS DIRECTLY.
// </auto-generated>
#pragma warning disable CS8500
#pragma warning disable CS8981
using System;
using System.Runtime.InteropServices;


namespace ServicePoint
{

    public unsafe sealed partial class Packet: IDisposable
    {
#nullable enable
        /// <summary>
        ///  Turns a [SPCommand] into a [SPPacket].
        ///  The [SPCommand] gets consumed.
        ///
        ///  Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `command` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - [SPCommand] points to a valid instance of [SPCommand]
        ///  - [SPCommand] is not used concurrently or after this call
        ///  - the returned [SPPacket] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_packet_free`.
        ///
        ///  servicepoint_csbindgen_consumes: command
        /// </summary>
        public static Packet FromCommand(Command command)
        {
            return new Packet(Packet.sp_packet_from_command(command.Into()));
        }

        /// <summary>
        ///  Tries to load a [SPPacket] from the passed array with the specified length.
        ///
        ///  returns: NULL in case of an error, pointer to the allocated packet otherwise
        ///
        ///  # Panics
        ///
        ///  - when `data` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `data` points to a valid memory region of at least `length` bytes
        ///  - `data` is not written to concurrently
        ///  - the returned [SPPacket] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_packet_free`.
        /// </summary>
        public static Packet? TryLoad(byte* data, nuint length)
        {
            var native = Packet.sp_packet_try_load(data, length);
            return native == null ? null : new Packet(native);
        }

        /// <summary>
        ///  Clones a [SPPacket].
        ///
        ///  Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `packet` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `packet` points to a valid [SPPacket]
        ///  - `packet` is not written to concurrently
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_packet_free`.
        /// </summary>
        public Packet Clone()
        {
            return new Packet(Packet.sp_packet_clone(this.Instance));
        }


#region internal machinery
        private SPPacket* _instance;
        internal SPPacket* Instance
        {
            get
            {
                if (_instance == null)
                    throw new NullReferenceException("instance is null");
                return _instance;
            }
        }

        private Packet(SPPacket* instance)
        {
            ArgumentNullException.ThrowIfNull(instance);
            _instance = instance;
        }

        internal SPPacket* Into()
        {
            var instance = Instance;
            _instance = null;
            return instance;
        }

        private void Free()
        {
            if (_instance != null)
                Packet.sp_packet_free(Into());
        }

        public void Dispose()
        {
            Free();
            GC.SuppressFinalize(this);
        }

        ~Packet() => Free();
            
#endregion

#nullable restore
#region native methods
        const string __DllName = "servicepoint_binding_c";
        [DllImport(__DllName, EntryPoint = "sp_packet_from_command", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        private static extern SPPacket* sp_packet_from_command(SPCommand* command);

        [DllImport(__DllName, EntryPoint = "sp_packet_try_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        private static extern SPPacket* sp_packet_try_load(byte* data, nuint length);

        [DllImport(__DllName, EntryPoint = "sp_packet_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        private static extern SPPacket* sp_packet_clone(SPPacket* packet);

        [DllImport(__DllName, EntryPoint = "sp_packet_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        private static extern void sp_packet_free(SPPacket* packet);


#endregion
    }

    [StructLayout(LayoutKind.Sequential)]
    public unsafe partial struct SPPacket
    {
    }



}