BytePtr.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
 
namespace be.gaudry.bibliobrol.model.eid
{
    public struct BytePtr
    {
        private IntPtr data;
 
        public BytePtr(byte[] data)
            : this((data != null) ? data : null, 0, (data != null) ? data.Length : 0)
        {
 
        }
        public BytePtr(byte[] data, int offset, int count)
        {
            // allocate
            this.data = (data == null) ? IntPtr.Zero : Memory.ByteToHLocal(data, offset, count);
        }
 
 
        public BytePtr(int size)
        {
            // allocate
            this.data = Memory.AllocHLocal(size);
        }
 
        public override string ToString()
        {
            // return 
            return data.ToString();
        }
 
        public IntPtr Handle
        {
            get
            {
                // return value
                return this.data;
            }
        }
        public void Free()
        {
            // free
            Memory.FreeHLocal(this.data);
        }
 
        public static BytePtr Zero
        {
            get
            {
                // return empty version
                return new BytePtr(null);
            }
        }
        public static bool operator ==(BytePtr v1, BytePtr v2)
        {
            // check
            return v1.Equals(v2);
        }
        public static bool operator !=(BytePtr v1, BytePtr v2)
        {
            // check
            return !v1.Equals(v2);
        }
        public override bool Equals(object obj)
        {
            // check if it is an instance
            return ((obj is BytePtr) && ((BytePtr)obj).data.Equals(this.data));
        }
        public override int GetHashCode()
        {
            // return hash code of data block
            return data.GetHashCode();
        }
        public static void Free(BytePtr ptr)
        {
            // check if zero
            if (BytePtr.Zero != ptr)
            {
                // free it
                ptr.Free();
            }
        }
 
 
 
 
        public static byte[] Free(BytePtr ptr, int length)
        {
            // declare
            byte[] result = null;
            // check if zero
            if (BytePtr.Zero != ptr)
            {
                // convert to array
                result = ptr.ToArray(length);
                // free it
                ptr.Free();
            }
            // return result
            return result;
        }
 
        public byte[] ToArray(int length)
        {
            // declare result
            byte[] result = null;
            // check if zer
            if (this.data != IntPtr.Zero)
            {
                // allocate
                result = new byte[length];
                // copy
                Marshal.Copy(this.data, result, 0, Convert.ToInt32(length));
            }
            // return result
            return result;
        }
        public void Dispose()
        {
            // just free
            Free();
        }
    }
}