public void DecodeMask(byte[] mask, int offset, int length)
{
int length1 = mask.Length;
int segmentIndex = 0;
ArraySegmentEx <byte> arraySegmentEx =
this.QuickSearchSegment(0, this.Segments.Count - 1, offset, out segmentIndex);
int num1 = Math.Min(length, arraySegmentEx.Count - offset + arraySegmentEx.From);
int num2 = offset - arraySegmentEx.From + arraySegmentEx.Offset;
int num3 = 0;
for (int index = num2; index < num2 + num1; ++index)
{
arraySegmentEx.Array[index] = (byte)((int)arraySegmentEx.Array[index] ^ (int)mask[num3++ % length1]);
}
if (num3 >= length)
{
return;
}
for (int index = segmentIndex + 1; index < this.SegmentCount; ++index)
{
ArraySegmentEx <byte> segment = this.Segments[index];
int num4 = Math.Min(length - num3, segment.Count);
for (int offset1 = segment.Offset; offset1 < segment.Offset + num4; ++offset1)
{
segment.Array[offset1] = (byte)((int)segment.Array[offset1] ^ (int)mask[num3++ % length1]);
}
if (num3 >= length)
{
break;
}
}
}
public int SearchLastSegment(SearchMarkState <T> state)
{
if (this.m_Segments.Count <= 0)
{
return(-1);
}
ArraySegmentEx <T> segment = this.m_Segments[this.m_Segments.Count - 1];
if (segment == null)
{
return(-1);
}
int?nullable = Extensions.SearchMark <T>((IList <T>)segment.Array, segment.Offset, segment.Count, state.Mark);
if (!nullable.HasValue)
{
return(-1);
}
if (nullable.Value > 0)
{
state.Matched = 0;
return(nullable.Value - segment.Offset + segment.From);
}
state.Matched = -nullable.Value;
return(-1);
}
public string Decode(Encoding encoding, int offset, int length)
{
if (length == 0)
{
return(string.Empty);
}
IList <ArraySegmentEx <byte> > segments = this.Segments;
if (segments == null || segments.Count <= 0)
{
return(string.Empty);
}
char[] chars = new char[encoding.GetMaxCharCount(this.Count)];
int num1 = 0;
int num2 = 0;
int num3 = segments.Count - 1;
bool flush = false;
Decoder decoder = encoding.GetDecoder();
int segmentIndex = 0;
if (offset > 0)
{
this.QuickSearchSegment(0, segments.Count - 1, offset, out segmentIndex);
}
for (int index = segmentIndex; index < segments.Count; ++index)
{
ArraySegmentEx <byte> arraySegmentEx = segments[index];
if (index == num3)
{
flush = true;
}
int byteIndex = arraySegmentEx.Offset;
int num4 = Math.Min(length - num1, arraySegmentEx.Count);
if (index == segmentIndex && offset > 0)
{
byteIndex = offset - arraySegmentEx.From + arraySegmentEx.Offset;
num4 = Math.Min(arraySegmentEx.Count - offset + arraySegmentEx.From, num4);
}
int bytesUsed;
int charsUsed;
bool completed;
decoder.Convert(arraySegmentEx.Array, byteIndex, num4, chars, num2, chars.Length - num2, flush, out bytesUsed,
out charsUsed, out completed);
num2 += charsUsed;
num1 += bytesUsed;
if (num1 >= length)
{
break;
}
}
return(new string(chars, 0, num2));
}
internal ArraySegmentEx <T> QuickSearchSegment(
int from,
int to,
int index,
out int segmentIndex)
{
segmentIndex = -1;
int num = to - from;
switch (num)
{
case 0:
ArraySegmentEx <T> segment1 = this.m_Segments[from];
if (index < segment1.From || index > segment1.To)
{
return((ArraySegmentEx <T>)null);
}
segmentIndex = from;
return(segment1);
case 1:
ArraySegmentEx <T> segment2 = this.m_Segments[from];
if (index >= segment2.From && index <= segment2.To)
{
segmentIndex = from;
return(segment2);
}
ArraySegmentEx <T> segment3 = this.m_Segments[to];
if (index < segment3.From || index > segment3.To)
{
return((ArraySegmentEx <T>)null);
}
segmentIndex = to;
return(segment3);
default:
int index1 = from + num / 2;
ArraySegmentEx <T> segment4 = this.m_Segments[index1];
if (index < segment4.From)
{
return(this.QuickSearchSegment(from, index1 - 1, index, out segmentIndex));
}
if (index > segment4.To)
{
return(this.QuickSearchSegment(index1 + 1, to, index, out segmentIndex));
}
segmentIndex = index1;
return(segment4);
}
}
public void AddSegment(T[] array, int offset, int length, bool toBeCopied)
{
if (length <= 0)
{
return;
}
int count = this.m_Count;
ArraySegmentEx <T> arraySegmentEx = toBeCopied
? new ArraySegmentEx <T>(Extensions.CloneRange <T>(array, offset, length), 0, length)
: new ArraySegmentEx <T>(array, offset, length);
arraySegmentEx.From = count;
this.m_Count = count + arraySegmentEx.Count;
arraySegmentEx.To = this.m_Count - 1;
this.m_Segments.Add(arraySegmentEx);
}
public void RemoveSegmentAt(int index)
{
ArraySegmentEx <T> segment = this.m_Segments[index];
int num = segment.To - segment.From + 1;
this.m_Segments.RemoveAt(index);
this.m_PrevSegment = (ArraySegmentEx <T>)null;
if (index != this.m_Segments.Count)
{
for (int index1 = index; index1 < this.m_Segments.Count; ++index1)
{
this.m_Segments[index1].From -= num;
this.m_Segments[index1].To -= num;
}
}
this.m_Count -= num;
}
public int IndexOf(T item)
{
int num = 0;
for (int index1 = 0; index1 < this.m_Segments.Count; ++index1)
{
ArraySegmentEx <T> segment = this.m_Segments[index1];
int offset = segment.Offset;
for (int index2 = 0; index2 < segment.Count; ++index2)
{
if (segment.Array[index2 + offset].Equals(item))
{
return(num);
}
++num;
}
}
return(-1);
}
public void TrimEnd(int trimSize)
{
if (trimSize <= 0)
{
return;
}
int num = this.Count - trimSize - 1;
for (int index = this.m_Segments.Count - 1; index >= 0; --index)
{
ArraySegmentEx <T> segment = this.m_Segments[index];
if (segment.From <= num && num < segment.To)
{
segment.To = num;
this.m_Count -= trimSize;
break;
}
this.RemoveSegmentAt(index);
}
}
public int CopyTo(T[] to, int srcIndex, int toIndex, int length)
{
int num1 = 0;
int segmentIndex;
ArraySegmentEx <T> arraySegmentEx;
if (srcIndex > 0)
{
arraySegmentEx = this.QuickSearchSegment(0, this.m_Segments.Count - 1, srcIndex, out segmentIndex);
}
else
{
arraySegmentEx = this.m_Segments[0];
segmentIndex = 0;
}
int sourceIndex = srcIndex - arraySegmentEx.From + arraySegmentEx.Offset;
int length1 = Math.Min(arraySegmentEx.Count - sourceIndex + arraySegmentEx.Offset, length - num1);
Array.Copy((Array)arraySegmentEx.Array, sourceIndex, (Array)to, num1 + toIndex, length1);
int num2 = num1 + length1;
if (num2 >= length)
{
return(num2);
}
for (int index = segmentIndex + 1; index < this.m_Segments.Count; ++index)
{
ArraySegmentEx <T> segment = this.m_Segments[index];
int length2 = Math.Min(segment.Count, length - num2);
Array.Copy((Array)segment.Array, segment.Offset, (Array)to, num2 + toIndex, length2);
num2 += length2;
if (num2 >= length)
{
break;
}
}
return(num2);
}
public T[] ToArrayData(int startIndex, int length)
{
T[] objArray = new T[length];
int num = 0;
int destinationIndex = 0;
int segmentIndex = 0;
if (startIndex != 0)
{
ArraySegmentEx <T> arraySegmentEx =
this.QuickSearchSegment(0, this.m_Segments.Count - 1, startIndex, out segmentIndex);
num = startIndex - arraySegmentEx.From;
if (arraySegmentEx == null)
{
throw new IndexOutOfRangeException();
}
}
for (int index = segmentIndex; index < this.m_Segments.Count; ++index)
{
ArraySegmentEx <T> segment = this.m_Segments[index];
int length1 = Math.Min(segment.Count - num, length - destinationIndex);
Array.Copy((Array)segment.Array, segment.Offset + num, (Array)objArray, destinationIndex, length1);
destinationIndex += length1;
if (destinationIndex < length)
{
num = 0;
}
else
{
break;
}
}
return(objArray);
}
private int GetElementInternalIndex(int index, out ArraySegmentEx <T> segment)
{
segment = (ArraySegmentEx <T>)null;
if (index < 0 || index > this.Count - 1)
{
return(-1);
}
if (index == 0)
{
this.m_PrevSegment = this.m_Segments[0];
this.m_PrevSegmentIndex = 0;
segment = this.m_PrevSegment;
return(this.m_PrevSegment.Offset);
}
int num1 = 0;
if (this.m_PrevSegment != null)
{
if (index >= this.m_PrevSegment.From)
{
if (index <= this.m_PrevSegment.To)
{
segment = this.m_PrevSegment;
return(this.m_PrevSegment.Offset + index - this.m_PrevSegment.From);
}
num1 = 1;
}
else
{
num1 = -1;
}
}
int from;
int to;
if (num1 != 0)
{
int index1 = this.m_PrevSegmentIndex + num1;
ArraySegmentEx <T> segment1 = this.m_Segments[index1];
if (index >= segment1.From && index <= segment1.To)
{
segment = segment1;
return(segment1.Offset + index - segment1.From);
}
int index2 = index1 + num1;
ArraySegmentEx <T> segment2 = this.m_Segments[index2];
if (index >= segment2.From && index <= segment2.To)
{
this.m_PrevSegment = segment2;
this.m_PrevSegmentIndex = index2;
segment = segment2;
return(segment2.Offset + index - segment2.From);
}
if (num1 > 0)
{
from = index2 + 1;
to = this.m_Segments.Count - 1;
}
else
{
int num2 = index2 - 1;
from = 0;
to = num2;
}
}
else
{
from = 0;
to = this.m_Segments.Count - 1;
}
int segmentIndex = -1;
ArraySegmentEx <T> arraySegmentEx = this.QuickSearchSegment(from, to, index, out segmentIndex);
if (arraySegmentEx != null)
{
this.m_PrevSegment = arraySegmentEx;
this.m_PrevSegmentIndex = segmentIndex;
segment = this.m_PrevSegment;
return(arraySegmentEx.Offset + index - arraySegmentEx.From);
}
this.m_PrevSegment = (ArraySegmentEx <T>)null;
return(-1);
}
public void ClearSegements()
{
this.m_Segments.Clear();
this.m_PrevSegment = (ArraySegmentEx <T>)null;
this.m_Count = 0;
}
