BrawlLib.Internal.PString Struct Reference

Public Member Functions
	PString (byte *address)
override bool	Equals (object obj)
bool	Equals (PString s, bool ignoreCase)
bool	Equals (string s, bool ignoreCase)
override int	GetHashCode ()
override string	ToString ()
void	Write (string s)
void	Write (string s, int offset)
void	Write (string s, int offset, int len)
void	Write (char *p, int offset, int len)
void	Write (byte *p, int offset, int len)

Static Public Member Functions
static implicit	operator int (PString p)
static implicit	operator uint (PString p)
static implicit	operator sbyte * (PString p)
static implicit	operator PString (sbyte *p)
static implicit	operator byte * (PString p)
static implicit	operator PString (byte *p)
static implicit	operator VoidPtr (PString p)
static implicit	operator PString (VoidPtr p)
static	operator string (PString p)
static PString	operator+ (PString p, int amount)
static bool	operator== (PString p, string s)
static bool	operator!= (PString p, string s)
static bool	operator== (PString p, PString s)
static bool	operator!= (PString p, PString s)
static bool	Equals (PString s1, PString s2, bool ignoreCase)
static bool	Equals (PString s1, string s2, bool ignoreCase)

Properties
byte	this[int index] [get, set]
int	Length [get]

Constructor & Destructor Documentation

PString()

BrawlLib.Internal.PString.PString ( byte *  address )

inline

        {
            _address = address;
        }

Member Function Documentation

Equals() [1/5]

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

inline

        {
            if (obj is PString)
            {
                return Equals((PString) obj, false);
            }
 
            if (obj is string)
            {
                return Equals((string) obj, false);
            }
 
            return false;
        }

Equals() [2/5]

bool BrawlLib.Internal.PString.Equals ( PString  s, bool  ignoreCase  )

inline

        {
            byte* pStr1 = _address;
            byte* pStr2 = s._address;
            byte b1, b2;
 
            do
            {
                b1 = *pStr1++;
                b2 = *pStr2++;
                if (b1 != b2)
                {
                    if (ignoreCase)
                    {
                        if (b1 >= 0x41 && b1 <= 0x5A)
                        {
                            if (b1 + 0x20 == b2)
                            {
                                continue;
                            }
                        }
                        else if (b1 >= 0x61 && b1 <= 0x7A)
                        {
                            if (b1 - 0x20 == b2)
                            {
                                continue;
                            }
                        }
                    }
 
                    return false;
                }
            } while (b1 != 0);
 
            return true;
        }

Equals() [3/5]

static bool BrawlLib.Internal.PString.Equals ( PString  s1, PString  s2, bool  ignoreCase  )

inlinestatic

        {
            return s1.Equals(s2, ignoreCase);
        }

Equals() [4/5]

static bool BrawlLib.Internal.PString.Equals ( PString  s1, string  s2, bool  ignoreCase  )

inlinestatic

        {
            return s1.Equals(s2, ignoreCase);
        }

Equals() [5/5]

bool BrawlLib.Internal.PString.Equals ( string  s, bool  ignoreCase  )

inline

        {
            byte* pStr1 = _address;
            char* pStr2;
            byte b1, b2;
 
            fixed (char* pChar = s)
            {
                pStr2 = pChar;
                do
                {
                    b1 = *pStr1++;
                    b2 = (byte) *pStr2++;
                    if (b1 != b2)
                    {
                        if (ignoreCase)
                        {
                            if (b1 >= 0x41 && b1 <= 0x5A)
                            {
                                if (b1 + 0x20 == b2)
                                {
                                    continue;
                                }
                            }
                            else if (b1 >= 0x61 && b1 <= 0x7A)
                            {
                                if (b1 - 0x20 == b2)
                                {
                                    continue;
                                }
                            }
                        }
 
                        return false;
                    }
                } while (b1 != 0);
            }
 
            return true;
        }

GetHashCode()

override int BrawlLib.Internal.PString.GetHashCode ( )

inline

        {
            return base.GetHashCode();
        }

operator byte *()

static implicit BrawlLib.Internal.PString.operator byte * ( PString  p )

inlinestatic

        {
            return p._address;
        }

operator int()

static implicit BrawlLib.Internal.PString.operator int ( PString  p )

inlinestatic

        {
            return (int) p._address;
        }

operator PString() [1/3]

static implicit BrawlLib.Internal.PString.operator PString ( byte *  p )

inlinestatic

        {
            return *(PString*) &p;
        }

operator PString() [2/3]

static implicit BrawlLib.Internal.PString.operator PString ( sbyte *  p )

inlinestatic

        {
            return *(PString*) &p;
        }

operator PString() [3/3]

static implicit BrawlLib.Internal.PString.operator PString ( VoidPtr  p )

inlinestatic

        {
            return *(PString*) &p;
        }

operator sbyte *()

static implicit BrawlLib.Internal.PString.operator sbyte * ( PString  p )

inlinestatic

        {
            return (sbyte*) p._address;
        }

operator string()

static BrawlLib.Internal.PString.operator string ( PString  p )

inlineexplicitstatic

        {
            return new string((sbyte*) p._address);
        }

operator uint()

static implicit BrawlLib.Internal.PString.operator uint ( PString  p )

inlinestatic

        {
            return (uint) p._address;
        }

operator VoidPtr()

static implicit BrawlLib.Internal.PString.operator VoidPtr ( PString  p )

inlinestatic

        {
            return *(VoidPtr*) &p;
        }

operator!=() [1/2]

static bool BrawlLib.Internal.PString.operator!= ( PString  p, PString  s  )

inlinestatic

        {
            return !p.Equals(s, false);
        }

operator!=() [2/2]

static bool BrawlLib.Internal.PString.operator!= ( PString  p, string  s  )

inlinestatic

        {
            return !p.Equals(s, false);
        }

operator+()

static PString BrawlLib.Internal.PString.operator+ ( PString  p, int  amount  )

inlinestatic

        {
            p._address += amount;
            return p;
        }

operator==() [1/2]

static bool BrawlLib.Internal.PString.operator== ( PString  p, PString  s  )

inlinestatic

        {
            return p.Equals(s, false);
        }

operator==() [2/2]

static bool BrawlLib.Internal.PString.operator== ( PString  p, string  s  )

inlinestatic

        {
            return p.Equals(s, false);
        }

ToString()

override string BrawlLib.Internal.PString.ToString ( )

inline

        {
            return new string(this);
        }

Write() [1/5]

void BrawlLib.Internal.PString.Write ( byte *  p, int  offset, int  len  )

inline

        {
            byte* s = _address;
            p += offset;
            for (int i = 0; i < len; i++)
            {
                *s++ = *p++;
            }
        }

Write() [2/5]

void BrawlLib.Internal.PString.Write ( char *  p, int  offset, int  len  )

inline

        {
            byte* s = _address;
            p += offset;
            for (int i = 0; i < len; i++)
            {
                *s++ = (byte) *p++;
            }
        }

Write() [3/5]

void BrawlLib.Internal.PString.Write ( string  s )

inline

        {
            Write(s, 0);
        }

Write() [4/5]

void BrawlLib.Internal.PString.Write ( string  s, int  offset  )

inline

        {
            Write(s, offset, s.Length);
        }

Write() [5/5]

void BrawlLib.Internal.PString.Write ( string  s, int  offset, int  len  )

inline

        {
            fixed (char* p = s)
            {
                Write(p, offset, len);
            }
        }

Property Documentation

Length

int BrawlLib.Internal.PString.Length

get

        {
            get
            {
                int len = 0;
                byte* p = _address;
                while (*p++ != 0)
                {
                    len++;
                }
 
                return len;
            }
        }

this[int index]

byte BrawlLib.Internal.PString.this[int index]

getsetadd

        {
            get => _address[index];
            set => _address[index] = value;
        }

---

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

• BrawlLib/Internal/PString.cs