DotNext.Unsafe by Roman Sakno

<PackageReference Include="DotNext.Unsafe" Version="0.6.0" />

---

API Diff between 0.6.0 and 4.2.0

220 Additions 183 Removals

DotNext.Buffers

• public interface IUnmanagedMemoryOwner<T> : IUnmanagedMemory<T>, IUnmanagedMemory, IDisposable, ISupplier<Stream>, IMemoryOwner<T>, ISupplier<Memory<T>>, IUnmanagedArray<T>, IEnumerable<T>, IEnumerable, ICloneable, ISupplier<T[]> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public static class UnmanagedMemoryAllocator
• public sealed class UnmanagedMemoryPool<T> : MemoryPool<T> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)

DotNext.Collections.Generic

• public struct UnmanagedList<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IDisposable, IUnmanagedList<T>, IUnmanagedMemory<T>, IUnmanagedMemory, ICloneable, IReadOnlyList<T>, IReadOnlyCollection<T> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public IntPtr Address { get; }
  • public int Capacity { get; }
  • public int Count { get; }
  • public bool IsEmpty { get; }
  • public T this[int index] { get; set; }
  • public UnmanagedList(int capacity)
  • public static UnmanagedMemory op_Implicit(UnmanagedList<T> list)
  • public static Span<T> op_Implicit(UnmanagedList<T> list)
  • public void Add(T item)
  • public int BinarySearch(T item, IComparer<T> comparison)
  • public int BinarySearch(T item)
  • public void Clear()
  • public bool Contains(T item)
  • public UnmanagedList<T> Copy()
  • public void CopyTo(T[] output, int arrayIndex, int count)
  • public void CopyTo(T[] output, int arrayIndex)
  • public void CopyTo(UnmanagedArray<T> output, int arrayIndex, int count)
  • public void CopyTo(UnmanagedArray<T> output, int arrayIndex)
  • public void Dispose()
  • public int Find(Predicate<T> predicate)
  • public int FindLast(Predicate<T> predicate)
  • public Enumerator<T> GetEnumerator()
  • public int IndexOf(T item, IEqualityComparer<T> comparer)
  • public int IndexOf(T item)
  • public void Insert(int index, T item)
  • public int LastIndexOf(T item)
  • public int LastIndexOf(T item, IEqualityComparer<T> comparer)
  • public bool Remove(T item)
  • public void RemoveAt(int index)
  • public bool RemoveLast(T item)
  • public void Sort(IComparer<T> comparison)
  • public void Sort()
  • public UnmanagedArray<T> ToArray()
  • public void TrimExcess()

DotNext.IO.MemoryMappedFiles

• public interface IMappedMemoryOwner : IUnmanagedMemory<byte>, IUnmanagedMemory, IDisposable, ISupplier<Stream>, IMemoryOwner<byte>, ISupplier<Memory<byte>>, IFlushable
• public struct MemoryMappedDirectAccessor : IUnmanagedMemory, IDisposable, ISupplier<Stream>, IFlushable
• public static class MemoryMappedFileExtensions

DotNext.Runtime.InteropServices

• public interface IUnmanagedArray<T> : IUnmanagedMemory, IDisposable, ISupplier<Stream>, IEnumerable<T>, IEnumerable, ICloneable, ISupplier<T[]> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public interface IUnmanagedMemory : IDisposable, ICloneable
  • Span<byte> Bytes { get; }
  • Pointer<byte> Pointer { get; }
  • IntPtr Address { get; }
  • Stream AsStream()
  • int BitwiseCompare(IUnmanagedMemory other)
  • bool BitwiseEquals(IUnmanagedMemory other)
  • void Clear()
  • long ReadFrom(Stream source)
  • void ReadFrom(Pointer<byte> source)
  • ValueTask<long> ReadFromAsync(Stream source, CancellationToken token = default)
  • void WriteTo(Stream destination)
  • void WriteTo(Pointer<byte> destination)
  • ValueTask WriteToAsync(Stream destination, CancellationToken token = default)
  • Pointer<T> ToPointer<T>() where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public interface IUnmanagedMemory<T> : IUnmanagedMemory, IDisposable, ISupplier<Stream>, IMemoryOwner<T>, ISupplier<Memory<T>> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public struct PinnedArray<T> : IUnmanagedArray<T>, IUnmanagedMemory, IDisposable, ISupplier<Stream>, IEnumerable<T>, IEnumerable, ICloneable, ISupplier<T[]>, IList<T>, ICollection<T>, IReadOnlyList<T>, IReadOnlyCollection<T>, IEquatable<PinnedArray<T>> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public struct Pointer<T> : IEquatable<Pointer<T>> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static int Size { get; }
  • public Span<byte> Bytes { get; }
  • public bool IsAligned { get; }
  • public ref T this[long index] { get; }
  • public ref T this[UIntPtr index] { get; }
  • public ref T Value { get; }
  • public T this[long index] { get; set; }
  • public ref T Ref { get; }
  • public T Value { get; set; }
  • public Pointer(Void* ptr)
  • public static Pointer<T> op_Addition(Pointer<T> pointer, IntPtr offset)
  • public static Pointer<T> op_Addition(Pointer<T> pointer, UIntPtr offset)
  • public static Pointer<T> op_Addition(Pointer<T> pointer, ulong offset)
  • public static Pointer<T> op_Explicit(ref MemoryHandle handle)
  • public static bool op_GreaterThan(Pointer<T> first, Pointer<T> second)
  • public static bool op_GreaterThanOrEqual(Pointer<T> first, Pointer<T> second)
  • public static Reference<T> op_Implicit(Pointer<T> ptr)
  • public static bool op_LessThan(Pointer<T> first, Pointer<T> second)
  • public static bool op_LessThanOrEqual(Pointer<T> first, Pointer<T> second)
  • public static Pointer<T> op_Subtraction(Pointer<T> pointer, IntPtr offset)
  • public static Pointer<T> op_Subtraction(Pointer<T> pointer, UIntPtr offset)
  • public static Pointer<T> op_Subtraction(Pointer<T> pointer, ulong offset)
  • public Pointer<TOther> As<TOther>() where TOther : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public Stream AsStream(long count, FileAccess access = 3)
  • public Pointer<U> As<U>() where U : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public UnmanagedMemoryStream AsStream(long count)
  • public int BitwiseHashCode<THashFunction>(long count, bool salted = true) where THashFunction : struct, IConsumer<int>, ISupplier<int>
  • public long BitwiseHashCode64(long count, bool salted = true)
  • public long BitwiseHashCode64<THashFunction>(long count, bool salted = true) where THashFunction : struct, IConsumer<long>, ISupplier<long>
  • public long BitwiseHashCode64(long count, long hash, Func<long, long, long> hashFunction, bool salted = true)
  • public long BitwiseHashCode(long count, long hash, Func<long, long, long> hashFunction, bool salted = true)
  • public void Clear()
  • public bool Equals<TOther>(Pointer<TOther> other) where TOther : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public bool Equals<U>(Pointer<U> other) where U : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public T Get()
  • public T Get(long index)
  • public object GetBoxedPointer()
  • public Enumerator<T> GetEnumerator(UIntPtr length)
  • public Reference<T> GetReference()
  • public ValueTask<long> ReadFromAsync(Stream source, long count, CancellationToken token = default)
  • public void Set(T value)
  • public void Set(T value, long index)
  • public Task<long> ReadFromAsync(Stream source, long count)
  • public T[] ToArray(long length)
  • public IMemoryOwner<T> ToMemoryOwner(int length)
  • public Span<T> ToSpan(int length)
  • public ValueTask WriteToAsync(Stream destination, long count, CancellationToken token = default)
  • public Task WriteToAsync(Stream destination, long count)
• public struct UnmanagedArray<T> : IEquatable<UnmanagedArray<T>>, IUnmanagedList<T>, IUnmanagedMemory<T>, IUnmanagedMemory, IDisposable, ICloneable, IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public sealed class Handle<T> : UnmanagedMemoryHandle<T> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public static UnmanagedArray<T> Empty { get; }
  • public IntPtr Address { get; }
  • public bool IsEmpty { get; }
  • public T this[long index] { get; set; }
  • public long Length { get; set; }
  • public long Size { get; }
  • public UnmanagedArray(long length, bool zeroMem = true)
  • public static Pointer<T> op_Addition(UnmanagedArray<T> array, int elementIndex)
  • public static bool op_Equality(UnmanagedArray<T> first, UnmanagedArray<T> second)
  • public static bool op_Equality(UnmanagedArray<T> first, Pointer<T> second)
  • public static Pointer<T> op_Implicit(UnmanagedArray<T> array)
  • public static Span<T> op_Implicit(UnmanagedArray<T> array)
  • public static UnmanagedMemory op_Implicit(UnmanagedArray<T> array)
  • public static bool op_Inequality(UnmanagedArray<T> first, UnmanagedArray<T> second)
  • public static bool op_Inequality(UnmanagedArray<T> first, Pointer<T> second)
  • public UnmanagedArray<U> As<U>() where U : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public long BinarySearch(T item, long startIndex, long count, IComparer<T> comparison)
  • public long BinarySearch(T item, IComparer<T> comparison)
  • public long BinarySearch(T item)
  • public int BitwiseCompare(Pointer<T> other)
  • public int BitwiseCompare(T[] other)
  • public bool BitwiseEquals(Pointer<T> other)
  • public bool BitwiseEquals(T[] other)
  • public int Compare(T[] other, IComparer<T> comparer)
  • public int Compare(UnmanagedArray<T> other, IComparer<T> comparer)
  • public UnmanagedArray<T> Copy()
  • public T[] CopyToManagedHeap()
  • public void Dispose()
  • public Pointer<T> ElementAt(long index)
  • public bool Equals<U>(UnmanagedArray<U> other) where U : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public bool Equals(T[] other, IEqualityComparer<T> comparer)
  • public bool Equals(UnmanagedArray<T> other, IEqualityComparer<T> comparer)
  • public void Fill(T value)
  • public long Find(Predicate<T> predicate, long startIndex, long count)
  • public long Find(Predicate<T> predicate, long startIndex)
  • public long Find(Predicate<T> predicate)
  • public long FindLast(Predicate<T> predicate, long startIndex, long count)
  • public long FindLast(Predicate<T> predicate, long startIndex)
  • public long FindLast(Predicate<T> predicate)
  • public Enumerator<T> GetEnumerator()
  • public long IndexOf(T item, long startIndex, long count, IEqualityComparer<T> comparer)
  • public long IndexOf(T item, long startIndex, IEqualityComparer<T> comparer)
  • public long IndexOf(T item, long startIndex)
  • public long IndexOf(T item)
  • public long LastIndexOf(T item, long startIndex, long count, IEqualityComparer<T> comparer)
  • public long LastIndexOf(T item, long startIndex, IEqualityComparer<T> comparer)
  • public long LastIndexOf(T item, long startIndex)
  • public long LastIndexOf(T item)
  • public long ReadFrom(T[] source, long offset, long count)
  • public long ReadFrom(T[] source)
  • public long ReadFrom(UnmanagedArray<T> source, long offset, long count)
  • public long ReadFrom(UnmanagedArray<T> source)
  • public UnmanagedArray<T> Slice(long startIndex)
  • public UnmanagedArray<T> Slice(long startIndex, long count)
  • public void Sort(long startIndex, long count, IComparer<T> comparison)
  • public void Sort(IComparer<T> comparison)
  • public void Sort()
  • public Pointer<U> ToPointer<U>() where U : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public long WriteTo(UnmanagedArray<T> destination, long offset, long count)
  • public long WriteTo(UnmanagedArray<T> destination)
  • public long WriteTo(T[] destination, long offset, long count)
  • public long WriteTo(T[] destination)
• public struct UnmanagedMemory : IUnmanagedMemory, IDisposable, ICloneable, IEquatable<UnmanagedMemory>, IEnumerable<byte>, IEnumerable
  • public sealed class Handle : UnmanagedMemoryHandle
  • public readonly IntPtr Address
  • public bool IsEmpty { get; }
  • public byte this[long offset] { get; set; }
  • public long Size { get; set; }
  • public UnmanagedMemory(long size, bool zeroMem = true)
  • public static bool op_Equality(UnmanagedMemory first, UnmanagedMemory second)
  • public static bool op_Inequality(UnmanagedMemory first, UnmanagedMemory second)
  • public ref T AsRef<T>() where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public UnmanagedMemory Copy()
  • public void Dispose()
  • public bool Equals(UnmanagedMemory other)
  • public Enumerator<byte> GetEnumerator()
  • public Pointer<T> ToPointer<T>() where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public struct UnmanagedMemory<T> : IUnmanagedMemory<T>, IUnmanagedMemory, IDisposable, ICloneable, IStrongBox, IEquatable<UnmanagedMemory<T>> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public sealed class Handle<T> : UnmanagedMemoryHandle<T> where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public IntPtr Address { get; }
  • public byte this[long offset] { get; set; }
  • public ref T Ref { get; }
  • public T Value { get; set; }
  • public UnmanagedMemory(bool zeroMem)
  • public UnmanagedMemory(T value)
  • public static bool op_Equality(UnmanagedMemory<T> first, UnmanagedMemory<T> second)
  • public static bool op_Equality(UnmanagedMemory<T> first, Pointer<T> second)
  • public static Pointer<T> op_Implicit(UnmanagedMemory<T> memory)
  • public static Span<T> op_Implicit(UnmanagedMemory<T> memory)
  • public static T op_Implicit(UnmanagedMemory<T> memory)
  • public static UnmanagedMemory op_Implicit(UnmanagedMemory<T> memory)
  • public static bool op_Inequality(UnmanagedMemory<T> first, UnmanagedMemory<T> second)
  • public static bool op_Inequality(UnmanagedMemory<T> first, Pointer<T> second)
  • public UnmanagedMemory<U> As<U>() where U : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public int BitwiseCompare(Pointer<T> other)
  • public bool BitwiseEquals(Pointer<T> other)
  • public UnmanagedMemory<T> Copy()
  • public StrongBox<T> CopyToManagedHeap()
  • public void Dispose()
  • public bool Equals<U>(UnmanagedMemory<U> other) where U : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public bool Equals(T other, IEqualityComparer<T> comparer)
  • public int GetHashCode(IEqualityComparer<T> comparer)
  • public void ReadFrom<U>(Pointer<U> source) where U : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public Pointer<U> ToPointer<U>() where U : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public void WriteTo<U>(Pointer<U> destination) where U : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public void WriteTo(ref T destination)
  • public void WriteTo<U>(UnmanagedMemory<U> destination) where U : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public static class UnmanagedMemoryExtensions
  • public static UnmanagedMemoryStream AsStream<M>(this ref M memory) where M : struct, IUnmanagedMemory
  • public static int BitwiseCompare<M1, M2>(this ref M1 first, M2 second) where M1 : struct, IUnmanagedMemory where M2 : IUnmanagedMemory
  • public static bool BitwiseEquals<M1, M2>(this ref M1 first, M2 second) where M1 : struct, IUnmanagedMemory where M2 : struct, IUnmanagedMemory
  • public static int BitwiseHashCode<M>(this ref M memory, bool salted = true) where M : struct, IUnmanagedMemory
  • public static void Clear<M>(this ref M memory) where M : struct, IUnmanagedMemory
  • public static byte[] ToByteArray<M>(this ref M memory) where M : struct, IUnmanagedMemory
  • public static Pointer<byte> ToPointer<M>(this ref M memory, long offset) where M : struct, IUnmanagedMemory
  • public static void WriteTo<M>(this ref M source, Stream destination) where M : struct, IUnmanagedMemory
  • public static long WriteTo<M>(this ref M source, byte[] destination, long offset, long count) where M : struct, IUnmanagedMemory
  • public static long WriteTo<M>(this ref M source, byte[] destination) where M : struct, IUnmanagedMemory
  • public static long WriteTo<M>(this byte[] source, M destination, long offset, long count) where M : IUnmanagedMemory
  • public static long WriteTo<M>(this byte[] source, M destination) where M : IUnmanagedMemory
  • public static long WriteTo<M>(this Stream source, M destination) where M : IUnmanagedMemory
  • public static Task WriteToAsync<M>(this ref M source, Stream destination) where M : struct, IUnmanagedMemory
  • public static Task<long> WriteToAsync<M>(this Stream source, M destination) where M : IUnmanagedMemory
• public abstract class UnmanagedMemoryHandle : SafeHandle, IUnmanagedMemory, IDisposable, ICloneable, IEquatable<UnmanagedMemoryHandle>
  • public IntPtr Address { get; }
  • public abstract long Size { get; }
  • public static bool op_Equality(UnmanagedMemoryHandle first, UnmanagedMemoryHandle second)
  • public static bool op_Inequality(UnmanagedMemoryHandle first, UnmanagedMemoryHandle second)
  • public bool Equals(UnmanagedMemoryHandle other)
  • public Pointer<T> ToPointer<T>() where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
• public abstract class UnmanagedMemoryHandle<T> : UnmanagedMemoryHandle, IUnmanagedMemory<T>, IUnmanagedMemory, IDisposable, ICloneable where T : ValueType modreq(System.Runtime.InteropServices.UnmanagedType)
  • public Pointer<T> Pointer { get; }
  • public abstract Span<T> Span { get; }

DotNext.Threading

• public static class AtomicPointer
  • public static double AccumulateAndGetValue(this Pointer<double> pointer, double x, Func<double, double, double> accumulator)
  • public static double AccumulateAndGetValue(this Pointer<double> pointer, double x, method accumulator)
  • public static int AccumulateAndGetValue(this Pointer<int> pointer, int x, method accumulator)
  • public static long AccumulateAndGetValue(this Pointer<long> pointer, long x, method accumulator)
  • public static IntPtr AccumulateAndGetValue(this Pointer<IntPtr> pointer, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
  • public static IntPtr AccumulateAndGetValue(this Pointer<IntPtr> pointer, IntPtr x, method accumulator)
  • public static float AccumulateAndGetValue(this Pointer<float> pointer, float x, method accumulator)
  • public static uint AccumulateAndGetValue(this Pointer<uint> pointer, uint x, Func<uint, uint, uint> accumulator)
  • public static uint AccumulateAndGetValue(this Pointer<uint> pointer, uint x, method accumulator)
  • public static ulong AccumulateAndGetValue(this Pointer<ulong> pointer, ulong x, Func<ulong, ulong, ulong> accumulator)
  • public static ulong AccumulateAndGetValue(this Pointer<ulong> pointer, ulong x, method accumulator)
  • public static double AddAndGetValue(this Pointer<double> pointer, double value)
  • public static int AddAndGetValue(this Pointer<int> pointer, int value)
  • public static long AddAndGetValue(this Pointer<long> pointer, long value)
  • public static IntPtr AddAndGetValue(this Pointer<IntPtr> pointer, IntPtr value)
  • public static float AddAndGetValue(this Pointer<float> pointer, float value)
  • public static uint AddAndGetValue(this Pointer<uint> pointer, uint value)
  • public static ulong AddAndGetValue(this Pointer<ulong> pointer, ulong value)
  • public static int BitwiseAndAndGetValue(this Pointer<int> pointer, int operand)
  • public static long BitwiseAndAndGetValue(this Pointer<long> pointer, int operand)
  • public static IntPtr BitwiseAndAndGetValue(this Pointer<IntPtr> pointer, IntPtr operand)
  • public static uint BitwiseAndAndGetValue(this Pointer<uint> pointer, uint operand)
  • public static ulong BitwiseAndAndGetValue(this Pointer<ulong> pointer, ulong operand)
  • public static int BitwiseOrAndGetValue(this Pointer<int> pointer, int operand)
  • public static long BitwiseOrAndGetValue(this Pointer<long> pointer, long operand)
  • public static IntPtr BitwiseOrAndGetValue(this Pointer<IntPtr> pointer, IntPtr operand)
  • public static uint BitwiseOrAndGetValue(this Pointer<uint> pointer, uint operand)
  • public static ulong BitwiseOrAndGetValue(this Pointer<ulong> pointer, ulong operand)
  • public static int BitwiseXorAndGetValue(this Pointer<int> pointer, int operand)
  • public static long BitwiseXorAndGetValue(this Pointer<long> pointer, long operand)
  • public static IntPtr BitwiseXorAndGetValue(this Pointer<IntPtr> pointer, IntPtr operand)
  • public static uint BitwiseXorAndGetValue(this Pointer<uint> pointer, uint operand)
  • public static ulong BitwiseXorAndGetValue(this Pointer<ulong> pointer, ulong operand)
  • public static bool CompareAndSetValue(this Pointer<double> pointer, double expected, double update)
  • public static bool CompareAndSetValue(this Pointer<int> pointer, int expected, int update)
  • public static double AccumulateAndGetValue(this Pointer<double> pointer, double x, Func<double, double, double> accumulator)
  • public static int AddValue(this Pointer<int> pointer, int value)
  • public static long AddValue(this Pointer<long> pointer, long value)
  • public static float AddValue(this Pointer<float> pointer, float value)
  • public static double AddValue(this Pointer<double> pointer, double value)
  • public static bool CompareAndSetValue(this Pointer<IntPtr> pointer, IntPtr expected, IntPtr update)
  • public static bool CompareAndSetValue(this Pointer<int> pointer, int expected, int update)
  • public static bool CompareAndSetValue(this Pointer<uint> pointer, uint expected, uint update)
  • public static bool CompareAndSetValue(this Pointer<ulong> pointer, ulong expected, ulong update)
  • public static double CompareExchangeValue(this Pointer<double> pointer, double value, double comparand)
  • public static int CompareExchangeValue(this Pointer<int> pointer, int value, int comparand)
  • public static bool CompareAndSetValue(this Pointer<double> pointer, double expected, double update)
  • public static IntPtr CompareExchangeValue(this Pointer<IntPtr> pointer, IntPtr value, IntPtr comparand)
  • public static int CompareExchangeValue(this Pointer<int> pointer, int value, int comparand)
  • public static uint CompareExchangeValue(this Pointer<uint> pointer, uint value, uint comparand)
  • public static ulong CompareExchangeValue(this Pointer<ulong> pointer, ulong value, ulong comparand)
  • public static double DecrementValue(this Pointer<double> pointer)
  • public static int DecrementValue(this Pointer<int> pointer)
  • public static double CompareExchangeValue(this Pointer<double> pointer, double value, double comparand)
  • public static IntPtr DecrementValue(this Pointer<IntPtr> pointer)
  • public static int DecrementValue(this Pointer<int> pointer)
  • public static uint DecrementValue(this Pointer<uint> pointer)
  • public static ulong DecrementValue(this Pointer<ulong> pointer)
  • public static double GetAndAccumulateValue(this Pointer<double> pointer, double x, Func<double, double, double> accumulator)
  • public static double GetAndAccumulateValue(this Pointer<double> pointer, double x, method accumulator)
  • public static double DecrementValue(this Pointer<double> pointer)
  • public static int GetAndAccumulateValue(this Pointer<int> pointer, int x, method accumulator)
  • public static long GetAndAccumulateValue(this Pointer<long> pointer, long x, method accumulator)
  • public static IntPtr GetAndAccumulateValue(this Pointer<IntPtr> pointer, IntPtr x, Func<IntPtr, IntPtr, IntPtr> accumulator)
  • public static IntPtr GetAndAccumulateValue(this Pointer<IntPtr> pointer, IntPtr x, method accumulator)
  • public static float GetAndAccumulateValue(this Pointer<float> pointer, float x, method accumulator)
  • public static uint GetAndAccumulateValue(this Pointer<uint> pointer, uint x, Func<uint, uint, uint> accumulator)
  • public static uint GetAndAccumulateValue(this Pointer<uint> pointer, uint x, method accumulator)
  • public static ulong GetAndAccumulateValue(this Pointer<ulong> pointer, ulong x, Func<ulong, ulong, ulong> accumulator)
  • public static ulong GetAndAccumulateValue(this Pointer<ulong> pointer, ulong x, method accumulator)
  • public static double GetAndAddValue(this Pointer<double> pointer, double value)
  • public static int GetAndAddValue(this Pointer<int> pointer, int value)
  • public static long GetAndAddValue(this Pointer<long> pointer, long value)
  • public static IntPtr GetAndAddValue(this Pointer<IntPtr> pointer, IntPtr value)
  • public static float GetAndAddValue(this Pointer<float> pointer, float value)
  • public static int GetAndBitwiseAndGetValue(this Pointer<int> pointer, int operand)
  • public static long GetAndBitwiseAndGetValue(this Pointer<long> pointer, int operand)
  • public static IntPtr GetAndBitwiseAndGetValue(this Pointer<IntPtr> pointer, IntPtr operand)
  • public static uint GetAndBitwiseAndGetValue(this Pointer<uint> pointer, uint operand)
  • public static ulong GetAndBitwiseAndGetValue(this Pointer<ulong> pointer, ulong operand)
  • public static int GetAndBitwiseOrValue(this Pointer<int> pointer, int operand)
  • public static long GetAndBitwiseOrValue(this Pointer<long> pointer, long operand)
  • public static IntPtr GetAndBitwiseOrValue(this Pointer<IntPtr> pointer, IntPtr operand)
  • public static uint GetAndBitwiseOrValue(this Pointer<uint> pointer, uint operand)
  • public static ulong GetAndBitwiseOrValue(this Pointer<ulong> pointer, ulong operand)
  • public static int GetAndBitwiseXorValue(this Pointer<int> pointer, int operand)
  • public static long GetAndBitwiseXorValue(this Pointer<long> pointer, long operand)
  • public static IntPtr GetAndBitwiseXorValue(this Pointer<IntPtr> pointer, IntPtr operand)
  • public static uint GetAndBitwiseXorValue(this Pointer<uint> pointer, uint operand)
  • public static ulong GetAndBitwiseXorValue(this Pointer<ulong> pointer, ulong operand)
  • public static double GetAndSetValue(this Pointer<double> pointer, double update)
  • public static int GetAndSetValue(this Pointer<int> pointer, int update)
  • public static double GetAndAccumulateValue(this Pointer<double> pointer, double x, Func<double, double, double> accumulator)
  • public static IntPtr GetAndSetValue(this Pointer<IntPtr> pointer, IntPtr update)
  • public static int GetAndSetValue(this Pointer<int> pointer, int update)
  • public static uint GetAndSetValue(this Pointer<uint> pointer, uint update)
  • public static ulong GetAndSetValue(this Pointer<ulong> pointer, ulong update)
  • public static double GetAndUpdateValue(this Pointer<double> pointer, Func<double, double> updater)
  • public static double GetAndUpdateValue(this Pointer<double> pointer, method updater)
  • public static double GetAndSetValue(this Pointer<double> pointer, double update)
  • public static IntPtr GetAndSetValue(this Pointer<IntPtr> pointer, IntPtr update)
  • public static int GetAndUpdateValue(this Pointer<int> pointer, method updater)
  • public static long GetAndUpdateValue(this Pointer<long> pointer, method updater)
  • public static IntPtr GetAndUpdateValue(this Pointer<IntPtr> pointer, Func<IntPtr, IntPtr> updater)
  • public static IntPtr GetAndUpdateValue(this Pointer<IntPtr> pointer, method updater)
  • public static float GetAndUpdateValue(this Pointer<float> pointer, method updater)
  • public static uint GetAndUpdateValue(this Pointer<uint> pointer, Func<uint, uint> updater)
  • public static uint GetAndUpdateValue(this Pointer<uint> pointer, method updater)
  • public static ulong GetAndUpdateValue(this Pointer<ulong> pointer, Func<ulong, ulong> updater)
  • public static ulong GetAndUpdateValue(this Pointer<ulong> pointer, method updater)
  • public static double IncrementValue(this Pointer<double> pointer)
  • public static int IncrementValue(this Pointer<int> pointer)
  • public static double GetAndUpdateValue(this Pointer<double> pointer, Func<double, double> updater)
  • public static IntPtr IncrementValue(this Pointer<IntPtr> pointer)
  • public static int IncrementValue(this Pointer<int> pointer)
  • public static uint IncrementValue(this Pointer<uint> pointer)
  • public static ulong IncrementValue(this Pointer<ulong> pointer)
  • public static double UpdateAndGetValue(this Pointer<double> pointer, Func<double, double> updater)
  • public static double UpdateAndGetValue(this Pointer<double> pointer, method updater)
  • public static double IncrementValue(this Pointer<double> pointer)
  • public static int UpdateAndGetValue(this Pointer<int> pointer, method updater)
  • public static long UpdateAndGetValue(this Pointer<long> pointer, method updater)
  • public static IntPtr UpdateAndGetValue(this Pointer<IntPtr> pointer, Func<IntPtr, IntPtr> updater)
  • public static IntPtr UpdateAndGetValue(this Pointer<IntPtr> pointer, method updater)
  • public static float UpdateAndGetValue(this Pointer<float> pointer, method updater)
  • public static uint UpdateAndGetValue(this Pointer<uint> pointer, Func<uint, uint> updater)
  • public static uint UpdateAndGetValue(this Pointer<uint> pointer, method updater)
  • public static ulong UpdateAndGetValue(this Pointer<ulong> pointer, Func<ulong, ulong> updater)
  • public static ulong UpdateAndGetValue(this Pointer<ulong> pointer, method updater)
  • public static bool VolatileRead(this Pointer<bool> pointer)
  • public static double VolatileRead(this Pointer<double> pointer)
  • public static short VolatileRead(this Pointer<short> pointer)
  • public static int VolatileRead(this Pointer<int> pointer)
  • public static double UpdateAndGetValue(this Pointer<double> pointer, Func<double, double> updater)
  • public static sbyte VolatileRead(this Pointer<sbyte> pointer)
  • public static int VolatileRead(this Pointer<int> pointer)
  • public static short VolatileRead(this Pointer<short> pointer)
  • public static byte VolatileRead(this Pointer<byte> pointer)
  • public static bool VolatileRead(this Pointer<bool> pointer)
  • public static ushort VolatileRead(this Pointer<ushort> pointer)
  • public static uint VolatileRead(this Pointer<uint> pointer)
  • public static double VolatileRead(this Pointer<double> pointer)
  • public static byte VolatileRead(this Pointer<byte> pointer)
  • public static uint VolatileRead(this Pointer<uint> pointer)
  • public static ushort VolatileRead(this Pointer<ushort> pointer)
  • public static sbyte VolatileRead(this Pointer<sbyte> pointer)
  • public static void VolatileWrite(this Pointer<bool> pointer, bool value)
  • public static void VolatileWrite(this Pointer<double> pointer, double value)
  • public static void VolatileWrite(this Pointer<short> pointer, short value)
  • public static void VolatileWrite(this Pointer<int> pointer, int value)
  • public static void VolatileWrite(this Pointer<sbyte> pointer, sbyte value)
  • public static void VolatileWrite(this Pointer<int> pointer, int value)
  • public static void VolatileWrite(this Pointer<short> pointer, short value)
  • public static void VolatileWrite(this Pointer<byte> pointer, byte value)
  • public static void VolatileWrite(this Pointer<bool> pointer, bool value)
  • public static void VolatileWrite(this Pointer<ushort> pointer, ushort value)
  • public static void VolatileWrite(this Pointer<uint> pointer, uint value)
  • public static void VolatileWrite(this Pointer<double> pointer, double value)
  • public static void VolatileWrite(this Pointer<byte> pointer, byte value)
  • public static void VolatileWrite(this Pointer<uint> pointer, uint value)
  • public static void VolatileWrite(this Pointer<ushort> pointer, ushort value)
  • public static void VolatileWrite(this Pointer<sbyte> pointer, sbyte value)