BrawlLib.Internal.VoidPtr Struct Reference

Public Member Functions
override int	GetHashCode ()
override bool	Equals (object obj)
string	GetUTF8String ()
string	GetUTF8String (uint offset)
string	GetUTF8String (uint offset, uint size)
uint	WriteUTF8String (string s)
uint	WriteUTF8String (string s, bool nullTerminated)
uint	WriteUTF8String (string s, uint offset)
uint	WriteUTF8String (string s, bool nullTerminated, uint offset)
uint	WriteUTF8String (string s, uint offset, uint size)
uint	WriteUTF8String (string s, bool nullTerminated, uint offset, uint size)

Static Public Member Functions
static int	operator- (VoidPtr p1, VoidPtr p2)
static VoidPtr	operator+ (VoidPtr p1, uint addr)
static VoidPtr	operator- (VoidPtr p1, uint addr)
static VoidPtr	operator+ (VoidPtr p1, int addr)
static VoidPtr	operator- (VoidPtr p1, int addr)
static VoidPtr	operator+ (VoidPtr p1, ulong addr)
static VoidPtr	operator- (VoidPtr p1, ulong addr)
static VoidPtr	operator+ (VoidPtr p1, long addr)
static VoidPtr	operator- (VoidPtr p1, long addr)
static bool	operator> (VoidPtr p1, VoidPtr p2)
static bool	operator< (VoidPtr p1, VoidPtr p2)
static bool	operator>= (VoidPtr p1, VoidPtr p2)
static bool	operator<= (VoidPtr p1, VoidPtr p2)
static bool	operator== (VoidPtr p1, VoidPtr p2)
static bool	operator!= (VoidPtr p1, VoidPtr p2)
static implicit	operator bool (VoidPtr ptr)
static implicit	operator void * (VoidPtr ptr)
static implicit	operator VoidPtr (void *ptr)
static implicit	operator uint (VoidPtr ptr)
static implicit	operator VoidPtr (uint ptr)
static implicit	operator int (VoidPtr ptr)
static implicit	operator VoidPtr (int ptr)
static implicit	operator ulong (VoidPtr ptr)
static implicit	operator VoidPtr (ulong ptr)
static implicit	operator long (VoidPtr ptr)
static implicit	operator VoidPtr (long ptr)
static implicit	operator VoidPtr (IntPtr ptr)
static implicit	operator IntPtr (VoidPtr ptr)
static void	Swap (float *p1, float *p2)
static void	Swap (int *p1, int *p2)
static void	Swap (short *p1, short *p2)
static void	Swap (ushort *p1, ushort *p2)
static void	Swap (byte *p1, byte *p2)

Public Attributes
void *	address

Properties
byte	Byte [get]
sbyte	SByte [get]
char	Char [get]
ushort	UShort [get]
short	Short [get]
uint	UInt [get]
int	Int [get]
float	Single [get]
VoidPtr	this[int count, int stride] [get]

Member Function Documentation

Equals()

override bool BrawlLib.Internal.VoidPtr.Equals ( object  obj )

inline

        {
            return base.Equals(obj);
        }

GetHashCode()

override int BrawlLib.Internal.VoidPtr.GetHashCode ( )

inline

        {
            return (int) address;
        }

GetUTF8String() [1/3]

string BrawlLib.Internal.VoidPtr.GetUTF8String ( )

inline

        {
            return GetUTF8String(0);
        }

GetUTF8String() [2/3]

string BrawlLib.Internal.VoidPtr.GetUTF8String ( uint  offset )

inline

        {
            byte[] bytes = new byte[new string((sbyte*)(this + offset)).Length];
            for (int i = 0; i < bytes.Length; i++)
            {
                bytes[i] = (this + offset).Byte;
                offset++;
            }
 
            return Encoding.UTF8.GetString(bytes);
        }

GetUTF8String() [3/3]

string BrawlLib.Internal.VoidPtr.GetUTF8String ( uint  offset, uint  size  )

inline

        {
            byte[] bytes = new byte[size];
            for (int i = 0; i < size; i++)
            {
                bytes[i] = (this + offset).Byte;
                offset++;
            }
 
            return Encoding.UTF8.GetString(bytes);
        }

operator bool()

static implicit BrawlLib.Internal.VoidPtr.operator bool ( VoidPtr  ptr )

inlinestatic

        {
            return ptr.address != null;
        }

operator int()

static implicit BrawlLib.Internal.VoidPtr.operator int ( VoidPtr  ptr )

inlinestatic

        {
            return checked((int) ptr.address);
        }

operator IntPtr()

static implicit BrawlLib.Internal.VoidPtr.operator IntPtr ( VoidPtr  ptr )

inlinestatic

        {
            return (IntPtr) ptr.address;
        }

operator long()

static implicit BrawlLib.Internal.VoidPtr.operator long ( VoidPtr  ptr )

inlinestatic

        {
            return (long) ptr.address;
        }

operator uint()

static implicit BrawlLib.Internal.VoidPtr.operator uint ( VoidPtr  ptr )

inlinestatic

        {
            return checked((uint) ptr.address);
        }

operator ulong()

static implicit BrawlLib.Internal.VoidPtr.operator ulong ( VoidPtr  ptr )

inlinestatic

        {
            return (ulong) ptr.address;
        }

operator void *()

static implicit BrawlLib.Internal.VoidPtr.operator void * ( VoidPtr  ptr )

inlinestatic

        {
            return ptr.address;
        }

operator VoidPtr() [1/6]

static implicit BrawlLib.Internal.VoidPtr.operator VoidPtr ( int  ptr )

inlinestatic

        {
            return new VoidPtr {address = (void*) ptr};
        }

operator VoidPtr() [2/6]

static implicit BrawlLib.Internal.VoidPtr.operator VoidPtr ( IntPtr  ptr )

inlinestatic

        {
            return new VoidPtr {address = (void*) ptr};
        }

operator VoidPtr() [3/6]

static implicit BrawlLib.Internal.VoidPtr.operator VoidPtr ( long  ptr )

inlinestatic

        {
            return new VoidPtr {address = (void*) ptr};
        }

operator VoidPtr() [4/6]

static implicit BrawlLib.Internal.VoidPtr.operator VoidPtr ( uint  ptr )

inlinestatic

        {
            return new VoidPtr {address = (void*) ptr};
        }

operator VoidPtr() [5/6]

static implicit BrawlLib.Internal.VoidPtr.operator VoidPtr ( ulong  ptr )

inlinestatic

        {
            return new VoidPtr {address = (void*) ptr};
        }

operator VoidPtr() [6/6]

static implicit BrawlLib.Internal.VoidPtr.operator VoidPtr ( void *  ptr )

inlinestatic

        {
            return new VoidPtr {address = ptr};
        }

operator!=()

static bool BrawlLib.Internal.VoidPtr.operator!= ( VoidPtr  p1, VoidPtr  p2  )

inlinestatic

        {
            return p1.address != p2.address;
        }

operator+() [1/4]

static VoidPtr BrawlLib.Internal.VoidPtr.operator+ ( VoidPtr  p1, int  addr  )

inlinestatic

        {
            return new VoidPtr {address = (byte*) p1.address + addr};
        }

operator+() [2/4]

static VoidPtr BrawlLib.Internal.VoidPtr.operator+ ( VoidPtr  p1, long  addr  )

inlinestatic

        {
            return new VoidPtr {address = (byte*) p1.address + addr};
        }

operator+() [3/4]

static VoidPtr BrawlLib.Internal.VoidPtr.operator+ ( VoidPtr  p1, uint  addr  )

inlinestatic

        {
            return new VoidPtr {address = (byte*) p1.address + addr};
        }

operator+() [4/4]

static VoidPtr BrawlLib.Internal.VoidPtr.operator+ ( VoidPtr  p1, ulong  addr  )

inlinestatic

        {
            return new VoidPtr {address = (byte*) p1.address + addr};
        }

operator-() [1/5]

static VoidPtr BrawlLib.Internal.VoidPtr.operator- ( VoidPtr  p1, int  addr  )

inlinestatic

        {
            return new VoidPtr {address = (byte*) p1.address - addr};
        }

operator-() [2/5]

static VoidPtr BrawlLib.Internal.VoidPtr.operator- ( VoidPtr  p1, long  addr  )

inlinestatic

        {
            return new VoidPtr {address = (byte*) p1.address - addr};
        }

operator-() [3/5]

static VoidPtr BrawlLib.Internal.VoidPtr.operator- ( VoidPtr  p1, uint  addr  )

inlinestatic

        {
            return new VoidPtr {address = (byte*) p1.address - addr};
        }

operator-() [4/5]

static VoidPtr BrawlLib.Internal.VoidPtr.operator- ( VoidPtr  p1, ulong  addr  )

inlinestatic

        {
            return new VoidPtr {address = (byte*) p1.address - addr};
        }

operator-() [5/5]

static int BrawlLib.Internal.VoidPtr.operator- ( VoidPtr  p1, VoidPtr  p2  )

inlinestatic

        {
            return checked((int) ((byte*) p1.address - (byte*) p2.address));
        }

operator<()

static bool BrawlLib.Internal.VoidPtr.operator< ( VoidPtr  p1, VoidPtr  p2  )

inlinestatic

        {
            return p1.address < p2.address;
        }

operator<=()

static bool BrawlLib.Internal.VoidPtr.operator<= ( VoidPtr  p1, VoidPtr  p2  )

inlinestatic

        {
            return p1.address <= p2.address;
        }

operator==()

static bool BrawlLib.Internal.VoidPtr.operator== ( VoidPtr  p1, VoidPtr  p2  )

inlinestatic

        {
            return p1.address == p2.address;
        }

operator>()

static bool BrawlLib.Internal.VoidPtr.operator> ( VoidPtr  p1, VoidPtr  p2  )

inlinestatic

        {
            return p1.address > p2.address;
        }

operator>=()

static bool BrawlLib.Internal.VoidPtr.operator>= ( VoidPtr  p1, VoidPtr  p2  )

inlinestatic

        {
            return p1.address >= p2.address;
        }

Swap() [1/5]

static void BrawlLib.Internal.VoidPtr.Swap ( byte *  p1, byte *  p2  )

inlinestatic

        {
            byte f = *p1;
            *p1 = *p2;
            *p2 = f;
        }

Swap() [2/5]

static void BrawlLib.Internal.VoidPtr.Swap ( float *  p1, float *  p2  )

inlinestatic

        {
            float f = *p1;
            *p1 = *p2;
            *p2 = f;
        }

Swap() [3/5]

static void BrawlLib.Internal.VoidPtr.Swap ( int *  p1, int *  p2  )

inlinestatic

        {
            int f = *p1;
            *p1 = *p2;
            *p2 = f;
        }

Swap() [4/5]

static void BrawlLib.Internal.VoidPtr.Swap ( short *  p1, short *  p2  )

inlinestatic

        {
            short f = *p1;
            *p1 = *p2;
            *p2 = f;
        }

Swap() [5/5]

static void BrawlLib.Internal.VoidPtr.Swap ( ushort *  p1, ushort *  p2  )

inlinestatic

        {
            ushort f = *p1;
            *p1 = *p2;
            *p2 = f;
        }

WriteUTF8String() [1/6]

uint BrawlLib.Internal.VoidPtr.WriteUTF8String ( string  s )

inline

        {
            return WriteUTF8String(s, true, 0);
        }

WriteUTF8String() [2/6]

uint BrawlLib.Internal.VoidPtr.WriteUTF8String ( string  s, bool  nullTerminated  )

inline

        {
            return WriteUTF8String(s, nullTerminated, 0);
        }

WriteUTF8String() [3/6]

uint BrawlLib.Internal.VoidPtr.WriteUTF8String ( string  s, bool  nullTerminated, uint  offset  )

inline

        {
            return WriteUTF8String(s, nullTerminated, offset, (uint)(s.UTF8Length() + (nullTerminated ? 1 : 0)));
        }

WriteUTF8String() [4/6]

uint BrawlLib.Internal.VoidPtr.WriteUTF8String ( string  s, bool  nullTerminated, uint  offset, uint  size  )

inline

        {
            byte* ptr = (byte*)(this + offset);
            byte[] name = Encoding.UTF8.GetBytes(s);
            for (int j = 0; j < name.Length && j < size; j++)
            {
                ptr[j] = name[j];
            }
 
            if (name.Length < size && nullTerminated)
            {
                ptr[name.Length] = 0;
            }
            else if (nullTerminated)
            {
                ptr[size - 1] = 0;
            }
 
            for (int j = name.Length; j < size; j++)
            {
                ptr[j] = 0;
            }
 
            return size;
        }

WriteUTF8String() [5/6]

uint BrawlLib.Internal.VoidPtr.WriteUTF8String ( string  s, uint  offset  )

inline

        {
            return WriteUTF8String(s, true, offset);
        }

WriteUTF8String() [6/6]

uint BrawlLib.Internal.VoidPtr.WriteUTF8String ( string  s, uint  offset, uint  size  )

inline

        {
            return WriteUTF8String(s, false, offset, size);
        }

Member Data Documentation

address

void* BrawlLib.Internal.VoidPtr.address

Property Documentation

Byte

byte BrawlLib.Internal.VoidPtr.Byte

get

Char

char BrawlLib.Internal.VoidPtr.Char

get

Int

int BrawlLib.Internal.VoidPtr.Int

get

SByte

sbyte BrawlLib.Internal.VoidPtr.SByte

get

Short

short BrawlLib.Internal.VoidPtr.Short

get

Single

float BrawlLib.Internal.VoidPtr.Single

get

this[int count, int stride]

VoidPtr BrawlLib.Internal.VoidPtr.this[int count, int stride]

get

UInt

uint BrawlLib.Internal.VoidPtr.UInt

get

UShort

ushort BrawlLib.Internal.VoidPtr.UShort

get

---

The documentation for this struct was generated from the following file:

• BrawlLib/Internal/VoidPtr.cs