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; }