BrawlLib.Internal.StringExtension Class Reference

Static Public Member Functions
static bool	Contains (this string source, char value)
static bool	Contains (this string source, char value, StringComparison comp)
static bool	Contains (this string source, string value, StringComparison comp)
static unsafe string	TruncateAndFill (this string s, int length, char fillChar)
static unsafe int	IndexOfOccurance (this string s, char c, int index)
static unsafe void	Write (this string s, sbyte *ptr)
static unsafe void	Write (this string s, ref sbyte *ptr)
static unsafe string	Read (this string s, byte *ptr)
static string	ToBinaryArray (this string s)
static int	CompareBits (this string t1, string t2)
static bool	AtBit (this string s, int bitIndex)
static string	RemoveInvalidCharacters (this string s, string valid)
static int	UTF8Length (this string s)

Member Function Documentation

AtBit()

static bool BrawlLib.Internal.StringExtension.AtBit ( this string  s, int  bitIndex  )

inlinestatic

        {
            int bit = bitIndex % 8;
            int byteIndex = (bitIndex - bit) / 8;
            return ((s[byteIndex] >> (7 - bit)) & 1) != 0;
        }

CompareBits()

static int BrawlLib.Internal.StringExtension.CompareBits ( this string  t1, string  t2  )

inlinestatic

        {
            int bit = 0;
            bool found = false;
            int min = Math.Min(t1.Length, t2.Length);
            for (int i = 0; i < min; i++)
            {
                byte c1 = (byte) t1[i];
                byte c2 = (byte) t2[i];
 
                for (int x = 0; x < 8; x++)
                {
                    if (c1 >> (7 - x) != c2 >> (7 - x))
                    {
                        bit = i * 8 + x;
                        found = true;
                        break;
                    }
                }
 
                if (bit != 0)
                {
                    break;
                }
            }
 
            if (!found)
            {
                bit = min * 8 + 1;
            }
 
            return bit;
        }

Contains() [1/3]

static bool BrawlLib.Internal.StringExtension.Contains ( this string  source, char  value  )

inlinestatic

        {
            return source.IndexOf(value) >= 0;
        }

Contains() [2/3]

static bool BrawlLib.Internal.StringExtension.Contains ( this string  source, char  value, StringComparison  comp  )

inlinestatic

        {
            return source.IndexOf(value.ToString(), comp) >= 0;
        }

Contains() [3/3]

static bool BrawlLib.Internal.StringExtension.Contains ( this string  source, string  value, StringComparison  comp  )

inlinestatic

        {
            return source.IndexOf(value, comp) >= 0;
        }

IndexOfOccurance()

static unsafe int BrawlLib.Internal.StringExtension.IndexOfOccurance ( this string  s, char  c, int  index  )

inlinestatic

        {
            int len = s.Length;
            fixed (char* cPtr = s)
            {
                for (int i = 0, count = 0; i < len; i++)
                {
                    if (cPtr[i] == c && count++ == index)
                    {
                        return i;
                    }
                }
            }
 
            return -1;
        }

Read()

static unsafe string BrawlLib.Internal.StringExtension.Read ( this string  s, byte *  ptr  )

inlinestatic

        {
            //List<byte> vals = new List<byte>();
            //byte val;
            //while ((val = *ptr++) != 0)
            //    vals.Add(val);
            //return encoder.GetString(vals.ToArray());
            return new string((sbyte*) ptr);
        }

RemoveInvalidCharacters()

static string BrawlLib.Internal.StringExtension.RemoveInvalidCharacters ( this string  s, string  valid  )

inlinestatic

        {
            string m = "";
            char[] t = s.ToCharArray().Where(x => valid.Contains(x)).ToArray();
            foreach (char c in t)
            {
                m += c;
            }
 
            return m;
        }

ToBinaryArray()

static string BrawlLib.Internal.StringExtension.ToBinaryArray ( this string  s )

inlinestatic

        {
            //string value = "";
            //for (int i = 0; i < s.Length; i++)
            //{
            //    byte c = (byte)s[i];
            //    for (int x = 0; x < 8; x++)
            //        value += ((c >> (7 - x)) & 1);
            //}
            //return value;
            string result = string.Empty;
            foreach (char ch in s)
            {
                result += Convert.ToString(ch, 2);
            }
 
            return result.PadLeft(result.Length.Align(8), '0');
        }

TruncateAndFill()

static unsafe string BrawlLib.Internal.StringExtension.TruncateAndFill ( this string  s, int  length, char  fillChar  )

inlinestatic

        {
            char* buffer = stackalloc char[length];
 
            int i;
            int min = Math.Min(s.Length, length);
            for (i = 0; i < min; i++)
            {
                buffer[i] = s[i];
            }
 
            while (i < length)
            {
                buffer[i++] = fillChar;
            }
 
            return new string(buffer, 0, length);
        }

UTF8Length()

static int BrawlLib.Internal.StringExtension.UTF8Length ( this string  s )

inlinestatic

        {
            return Encoding.UTF8.GetByteCount(s);
        }

Write() [1/2]

static unsafe void BrawlLib.Internal.StringExtension.Write ( this string  s, ref sbyte *  ptr  )

inlinestatic

        {
            //var b = encoder.GetBytes(s);
            for (int i = 0; i < s.Length; i++)
            {
                *ptr++ = (sbyte) s[i];
            }
 
            *ptr++ = 0; //Null terminator
        }

Write() [2/2]

static unsafe void BrawlLib.Internal.StringExtension.Write ( this string  s, sbyte *  ptr  )

inlinestatic

        {
            //var b = encoder.GetBytes(s);
            for (int i = 0; i < s.Length; i++)
            {
                ptr[i] = (sbyte) s[i];
            }
        }

---

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

• BrawlLib/Internal/StringExtension.cs