예제 #1
0
        public int SearchLastSegment(SearchMarkState <T> state)
        {
            if (m_Segments.Count <= 0)
            {
                return(-1);
            }
            ArraySegmentEx <T> arraySegmentEx = m_Segments[m_Segments.Count - 1];

            if (arraySegmentEx == null)
            {
                return(-1);
            }
            int?num = arraySegmentEx.Array.SearchMark(arraySegmentEx.Offset, arraySegmentEx.Count, state.Mark);

            if (!num.HasValue)
            {
                return(-1);
            }
            if (num.Value > 0)
            {
                state.Matched = 0;
                return(num.Value - arraySegmentEx.Offset + arraySegmentEx.From);
            }
            state.Matched = -num.Value;
            return(-1);
        }
        // Token: 0x0600066A RID: 1642 RVA: 0x0001A8EC File Offset: 0x00018AEC
        public void DecodeMask(byte[] mask, int offset, int length)
        {
            int num  = mask.Length;
            int num2 = 0;
            ArraySegmentEx <byte> arraySegmentEx = base.QuickSearchSegment(0, base.Segments.Count - 1, offset, out num2);
            int num3 = Math.Min(length, arraySegmentEx.Count - offset + arraySegmentEx.From);
            int num4 = offset - arraySegmentEx.From + arraySegmentEx.Offset;
            int num5 = 0;

            for (int i = num4; i < num4 + num3; i++)
            {
                arraySegmentEx.Array[i] = (arraySegmentEx.Array[i] ^ mask[num5++ % num]);
            }
            if (num5 >= length)
            {
                return;
            }
            for (int j = num2 + 1; j < base.SegmentCount; j++)
            {
                ArraySegmentEx <byte> arraySegmentEx2 = base.Segments[j];
                num3 = Math.Min(length - num5, arraySegmentEx2.Count);
                for (int k = arraySegmentEx2.Offset; k < arraySegmentEx2.Offset + num3; k++)
                {
                    arraySegmentEx2.Array[k] = (arraySegmentEx2.Array[k] ^ mask[num5++ % num]);
                }
                if (num5 >= length)
                {
                    return;
                }
            }
        }
예제 #3
0
        public T[] ToArrayData(int startIndex, int length)
        {
            T[] array        = new T[length];
            int num          = 0;
            int num2         = 0;
            int num3         = 0;
            int segmentIndex = 0;

            if (startIndex != 0)
            {
                ArraySegmentEx <T> arraySegmentEx = QuickSearchSegment(0, m_Segments.Count - 1, startIndex, out segmentIndex);
                num = startIndex - arraySegmentEx.From;
                if (arraySegmentEx == null)
                {
                    throw new IndexOutOfRangeException();
                }
            }
            for (int i = segmentIndex; i < m_Segments.Count; i++)
            {
                ArraySegmentEx <T> arraySegmentEx2 = m_Segments[i];
                num2 = Math.Min(arraySegmentEx2.Count - num, length - num3);
                Array.Copy(arraySegmentEx2.Array, arraySegmentEx2.Offset + num, array, num3, num2);
                num3 += num2;
                if (num3 >= length)
                {
                    break;
                }
                num = 0;
            }
            return(array);
        }
예제 #4
0
        public ArraySegmentEx <T> QuickSearchSegment(int from, int to, int index, out int segmentIndex)
        {
            segmentIndex = -1;
            int num = to - from;

            switch (num)
            {
            case 0:
            {
                ArraySegmentEx <T> arraySegmentEx = m_Segments[from];
                if (index >= arraySegmentEx.From && index <= arraySegmentEx.To)
                {
                    segmentIndex = from;
                    return(arraySegmentEx);
                }
                return(null);
            }

            case 1:
            {
                ArraySegmentEx <T> arraySegmentEx = m_Segments[from];
                if (index >= arraySegmentEx.From && index <= arraySegmentEx.To)
                {
                    segmentIndex = from;
                    return(arraySegmentEx);
                }
                arraySegmentEx = m_Segments[to];
                if (index >= arraySegmentEx.From && index <= arraySegmentEx.To)
                {
                    segmentIndex = to;
                    return(arraySegmentEx);
                }
                return(null);
            }

            default:
            {
                int num2 = from + num / 2;
                ArraySegmentEx <T> arraySegmentEx = m_Segments[num2];
                if (index >= arraySegmentEx.From)
                {
                    if (index <= arraySegmentEx.To)
                    {
                        segmentIndex = num2;
                        return(arraySegmentEx);
                    }
                    return(QuickSearchSegment(num2 + 1, to, index, out segmentIndex));
                }
                return(QuickSearchSegment(from, num2 - 1, index, out segmentIndex));
            }
            }
        }
예제 #5
0
 public void AddSegment(T[] array, int offset, int length, bool toBeCopied)
 {
     if (length > 0)
     {
         int count = m_Count;
         ArraySegmentEx <T> arraySegmentEx = null;
         arraySegmentEx      = (toBeCopied ? new ArraySegmentEx <T>(array.CloneRange(offset, length), 0, length) : new ArraySegmentEx <T>(array, offset, length));
         arraySegmentEx.From = count;
         m_Count             = count + arraySegmentEx.Count;
         arraySegmentEx.To   = m_Count - 1;
         m_Segments.Add(arraySegmentEx);
     }
 }
        // Token: 0x06000669 RID: 1641 RVA: 0x0001A7B8 File Offset: 0x000189B8
        public string Decode(Encoding encoding, int offset, int length)
        {
            if (length == 0)
            {
                return(string.Empty);
            }
            IList <ArraySegmentEx <byte> > segments = base.Segments;

            if (segments == null || segments.Count <= 0)
            {
                return(string.Empty);
            }
            char[]  array   = new char[encoding.GetMaxCharCount(base.Count)];
            int     num     = 0;
            int     num2    = 0;
            int     num3    = segments.Count - 1;
            bool    flush   = false;
            Decoder decoder = encoding.GetDecoder();
            int     num4    = 0;

            if (offset > 0)
            {
                base.QuickSearchSegment(0, segments.Count - 1, offset, out num4);
            }
            for (int i = num4; i < segments.Count; i++)
            {
                ArraySegmentEx <byte> arraySegmentEx = segments[i];
                if (i == num3)
                {
                    flush = true;
                }
                int byteIndex = arraySegmentEx.Offset;
                int num5      = Math.Min(length - num, arraySegmentEx.Count);
                if (i == num4 && offset > 0)
                {
                    byteIndex = offset - arraySegmentEx.From + arraySegmentEx.Offset;
                    num5      = Math.Min(arraySegmentEx.Count - offset + arraySegmentEx.From, num5);
                }
                int  num6;
                int  num7;
                bool flag;
                decoder.Convert(arraySegmentEx.Array, byteIndex, num5, array, num2, array.Length - num2, flush, out num6, out num7, out flag);
                num2 += num7;
                num  += num6;
                if (num >= length)
                {
                    break;
                }
            }
            return(new string(array, 0, num2));
        }
        // Token: 0x06000653 RID: 1619 RVA: 0x0001A330 File Offset: 0x00018530
        public ArraySegmentEx <T> QuickSearchSegment(int from, int to, int index, out int segmentIndex)
        {
            segmentIndex = -1;
            int num = to - from;

            if (num == 0)
            {
                ArraySegmentEx <T> arraySegmentEx = this.m_Segments[from];
                if (index >= arraySegmentEx.From && index <= arraySegmentEx.To)
                {
                    segmentIndex = from;
                    return(arraySegmentEx);
                }
                return(null);
            }
            else if (num == 1)
            {
                ArraySegmentEx <T> arraySegmentEx = this.m_Segments[from];
                if (index >= arraySegmentEx.From && index <= arraySegmentEx.To)
                {
                    segmentIndex = from;
                    return(arraySegmentEx);
                }
                arraySegmentEx = this.m_Segments[to];
                if (index >= arraySegmentEx.From && index <= arraySegmentEx.To)
                {
                    segmentIndex = to;
                    return(arraySegmentEx);
                }
                return(null);
            }
            else
            {
                int num2 = from + num / 2;
                ArraySegmentEx <T> arraySegmentEx = this.m_Segments[num2];
                if (index < arraySegmentEx.From)
                {
                    return(this.QuickSearchSegment(from, num2 - 1, index, out segmentIndex));
                }
                if (index <= arraySegmentEx.To)
                {
                    segmentIndex = num2;
                    return(arraySegmentEx);
                }
                return(this.QuickSearchSegment(num2 + 1, to, index, out segmentIndex));
            }
        }
예제 #8
0
        public void RemoveSegmentAt(int index)
        {
            ArraySegmentEx <T> arraySegmentEx = m_Segments[index];
            int num = arraySegmentEx.To - arraySegmentEx.From + 1;

            m_Segments.RemoveAt(index);
            m_PrevSegment = null;
            if (index != m_Segments.Count)
            {
                for (int i = index; i < m_Segments.Count; i++)
                {
                    m_Segments[i].From -= num;
                    m_Segments[i].To   -= num;
                }
            }
            m_Count -= num;
        }
예제 #9
0
        public int IndexOf(T item)
        {
            int num = 0;

            for (int i = 0; i < m_Segments.Count; i++)
            {
                ArraySegmentEx <T> arraySegmentEx = m_Segments[i];
                int offset = arraySegmentEx.Offset;
                for (int j = 0; j < arraySegmentEx.Count; j++)
                {
                    if (arraySegmentEx.Array[j + offset].Equals(item))
                    {
                        return(num);
                    }
                    num++;
                }
            }
            return(-1);
        }
예제 #10
0
        // Token: 0x06000664 RID: 1636 RVA: 0x0001A5C4 File Offset: 0x000187C4
        public void TrimEnd(int trimSize)
        {
            if (trimSize <= 0)
            {
                return;
            }
            int num = this.Count - trimSize - 1;

            for (int i = this.m_Segments.Count - 1; i >= 0; i--)
            {
                ArraySegmentEx <T> arraySegmentEx = this.m_Segments[i];
                if (arraySegmentEx.From <= num && num < arraySegmentEx.To)
                {
                    arraySegmentEx.To = num;
                    this.m_Count     -= trimSize;
                    return;
                }
                this.RemoveSegmentAt(i);
            }
        }
예제 #11
0
        // Token: 0x0600065F RID: 1631 RVA: 0x0001A4AC File Offset: 0x000186AC
        public void AddSegment(T[] array, int offset, int length, bool toBeCopied)
        {
            if (length <= 0)
            {
                return;
            }
            int count = this.m_Count;
            ArraySegmentEx <T> arraySegmentEx;

            if (!toBeCopied)
            {
                arraySegmentEx = new ArraySegmentEx <T>(array, offset, length);
            }
            else
            {
                arraySegmentEx = new ArraySegmentEx <T>(array.CloneRange(offset, length), 0, length);
            }
            arraySegmentEx.From = count;
            this.m_Count        = count + arraySegmentEx.Count;
            arraySegmentEx.To   = this.m_Count - 1;
            this.m_Segments.Add(arraySegmentEx);
        }
예제 #12
0
        public int CopyTo(T[] to, int srcIndex, int toIndex, int length)
        {
            int num  = 0;
            int num2 = 0;
            ArraySegmentEx <T> arraySegmentEx;
            int segmentIndex;

            if (srcIndex > 0)
            {
                arraySegmentEx = QuickSearchSegment(0, m_Segments.Count - 1, srcIndex, out segmentIndex);
            }
            else
            {
                arraySegmentEx = m_Segments[0];
                segmentIndex   = 0;
            }
            int num3 = srcIndex - arraySegmentEx.From + arraySegmentEx.Offset;

            num2 = Math.Min(arraySegmentEx.Count - num3 + arraySegmentEx.Offset, length - num);
            Array.Copy(arraySegmentEx.Array, num3, to, num + toIndex, num2);
            num += num2;
            if (num >= length)
            {
                return(num);
            }
            for (int i = segmentIndex + 1; i < m_Segments.Count; i++)
            {
                ArraySegmentEx <T> arraySegmentEx2 = m_Segments[i];
                num2 = Math.Min(arraySegmentEx2.Count, length - num);
                Array.Copy(arraySegmentEx2.Array, arraySegmentEx2.Offset, to, num + toIndex, num2);
                num += num2;
                if (num >= length)
                {
                    break;
                }
            }
            return(num);
        }
예제 #13
0
 public void ClearSegements()
 {
     m_Segments.Clear();
     m_PrevSegment = null;
     m_Count       = 0;
 }
예제 #14
0
        private int GetElementpublicIndex(int index, out ArraySegmentEx <T> segment)
        {
            segment = null;
            if (index < 0 || index > Count - 1)
            {
                return(-1);
            }
            if (index == 0)
            {
                m_PrevSegment      = m_Segments[0];
                m_PrevSegmentIndex = 0;
                segment            = m_PrevSegment;
                return(m_PrevSegment.Offset);
            }
            int num = 0;

            if (m_PrevSegment != null)
            {
                if (index >= m_PrevSegment.From)
                {
                    if (index <= m_PrevSegment.To)
                    {
                        segment = m_PrevSegment;
                        return(m_PrevSegment.Offset + index - m_PrevSegment.From);
                    }
                    num = 1;
                }
                else
                {
                    num = -1;
                }
            }
            int num2;
            int to;

            if (num != 0)
            {
                num2 = m_PrevSegmentIndex + num;
                ArraySegmentEx <T> arraySegmentEx = m_Segments[num2];
                if (index >= arraySegmentEx.From && index <= arraySegmentEx.To)
                {
                    segment = arraySegmentEx;
                    return(arraySegmentEx.Offset + index - arraySegmentEx.From);
                }
                num2 += num;
                ArraySegmentEx <T> arraySegmentEx2 = m_Segments[num2];
                if (index >= arraySegmentEx2.From && index <= arraySegmentEx2.To)
                {
                    m_PrevSegment      = arraySegmentEx2;
                    m_PrevSegmentIndex = num2;
                    segment            = arraySegmentEx2;
                    return(arraySegmentEx2.Offset + index - arraySegmentEx2.From);
                }
                if (num > 0)
                {
                    num2++;
                    to = m_Segments.Count - 1;
                }
                else
                {
                    int num3 = num2 - 1;
                    num2 = 0;
                    to   = num3;
                }
            }
            else
            {
                num2 = 0;
                to   = m_Segments.Count - 1;
            }
            int segmentIndex = -1;
            ArraySegmentEx <T> arraySegmentEx3 = QuickSearchSegment(num2, to, index, out segmentIndex);

            if (arraySegmentEx3 != null)
            {
                m_PrevSegment      = arraySegmentEx3;
                m_PrevSegmentIndex = segmentIndex;
                segment            = m_PrevSegment;
                return(arraySegmentEx3.Offset + index - arraySegmentEx3.From);
            }
            m_PrevSegment = null;
            return(-1);
        }