public ClusteredMemoryStream(byte[][] buffer, bool writable) { int position = 0; foreach (byte[] bytes in buffer) { _buffer.CopyFrom(bytes, 0, position, bytes.Length); position += bytes.Length; } _length = _capacity = position; _writable = writable; _expandable = false; _origin = 0; _isOpen = true; }
//Changelog: Used ClusteredArray's internal CopyFrom method. public ClusteredMemoryStream(byte[] buffer, int index, int count, bool writable, bool publiclyVisible) { if (buffer == null) { throw new ArgumentNullException("buffer", ResourceHelper.GetResourceString("ArgumentNull_Buffer")); } if (index < 0) { throw new ArgumentOutOfRangeException("index", ResourceHelper.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); } if (count < 0) { throw new ArgumentOutOfRangeException("count", ResourceHelper.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); } if (buffer.Length - index < count) { throw new ArgumentException(ResourceHelper.GetResourceString("Argument_InvalidOffLen")); } #if DEBUG Contract.EndContractBlock(); #endif _buffer = new ClusteredArray <byte>(buffer.Length); _buffer.CopyFrom(buffer, 0, 0, buffer.Length); _origin = _position = index; _length = _capacity = index + count; _writable = writable; _exposable = publiclyVisible; // Can GetBuffer return the array? _expandable = false; _isOpen = true; }
// Inserts the elements of the given collection at a given index. If // required, the capacity of the list is increased to twice the previous // capacity or the new size, whichever is larger. Ranges may be added // to the end of the list by setting index to the List's size. // public void InsertRange(int index, IEnumerable <T> collection) { if (collection == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection); } if ((uint)index > (uint)_size) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index); } #if DEBUG Contract.EndContractBlock(); #endif ICollection <T> c = collection as ICollection <T>; if (c != null) { int count = c.Count; if (count > 0) { EnsureCapacity(_size + count); if (index < _size) { ClusteredArray <T> .Copy(_items, index, _items, index + count, _size - index); } // If we're inserting a List into itself, we want to be able to deal with that. if (this == c) { // Copy first part of _items to insert location ClusteredArray <T> .Copy(_items, 0, _items, index, index); // Copy last part of _items back to inserted location ClusteredArray <T> .Copy(_items, index + count, _items, index * 2, _size - index); } else { T[] itemsToInsert = new T[count]; c.CopyTo(itemsToInsert, 0); _items.CopyFrom(itemsToInsert, 0, index, count); } _size += count; } } else { using (IEnumerator <T> en = collection.GetEnumerator()) { while (en.MoveNext()) { Insert(index++, en.Current); } } } _version++; }
public ClusteredMemoryStream(byte[] buffer, bool writable) { if (buffer == null) { throw new ArgumentNullException("buffer", ResourceHelper.GetResourceString("ArgumentNull_Buffer")); } #if DEBUG Contract.EndContractBlock(); #endif _buffer = new ClusteredArray <byte>(buffer.Length); _buffer.CopyFrom(buffer, 0, 0, buffer.Length); _length = _capacity = buffer.Length; _writable = writable; _exposable = false; _origin = 0; _isOpen = true; }