public void Deinitialize(nint count)
{
unsafe
{
fixed(byte *ptr = SwiftData)
{
var actualPtr = Marshal.ReadIntPtr(new IntPtr(ptr));
NativeMethodsForUnsafeMutablePointer.Deinitialize(actualPtr, count, StructMarshal.Marshaler.Metatypeof(typeof(T)));
}
}
}
public static UnsafeMutablePointer <T> Allocate(nint capacity)
{
unsafe {
var self = new UnsafeMutablePointer <T> ();
fixed(byte *ptr = self.SwiftData)
{
var actualPtr = new IntPtr(ptr);
NativeMethodsForUnsafeMutablePointer.Allocate(actualPtr, capacity, StructMarshal.Marshaler.Metatypeof(typeof(T)));
}
return(self);
}
}
public void Initialize(T repeating, nint count)
{
unsafe
{
fixed(byte *ptr = SwiftData)
{
var actualPtr = Marshal.ReadIntPtr(new IntPtr(ptr));
var valPtr = stackalloc byte [StructMarshal.Marshaler.Strideof(typeof(T))];
var valIntPtr = new IntPtr(valPtr);
valIntPtr = StructMarshal.Marshaler.ToSwift(repeating, valIntPtr);
NativeMethodsForUnsafeMutablePointer.Initialize(actualPtr, valIntPtr, count, StructMarshal.Marshaler.Metatypeof(typeof(T)));
StructMarshal.Marshaler.ReleaseSwiftPointer(typeof(T), valIntPtr);
}
}
}
// "Why," you may ask, "is it that I'm using the same P/Invokes for UnsafePointer and UnsafeMutablePointer?"
// Because it's just pointer arithmetic. The difference between them is that UnsafeMutablePointer has set methods.
// The actual representation is identical: a pointer
public UnsafePointer <T> Advance(nint by)
{
var retval = new UnsafePointer <T> ();
unsafe
{
fixed(byte *ptr = SwiftData)
{
var actualPtr = Marshal.ReadIntPtr(new IntPtr(ptr));
fixed(byte *retvalPtr = StructMarshal.Marshaler.PrepareNominal(retval))
{
NativeMethodsForUnsafeMutablePointer.Advance(new IntPtr(retvalPtr), actualPtr, by, StructMarshal.Marshaler.Metatypeof(typeof(T)));
}
}
}
return(retval);
}
