// Sets the length of the stream to a given value. The new
// value must be nonnegative and less than the space remaining in
// the array, Int32.MaxValue - origin
// Origin is 0 in all cases other than a MemoryStream created on
// top of an existing array and a specific starting offset was passed
// into the MemoryStream constructor. The upper bounds prevents any
// situations where a stream may be created on top of an array then
// the stream is made longer than the maximum possible length of the
// array (Int32.MaxValue).
//
public override void SetLength(long value)
{
if (value < 0 || value > Int32.MaxValue)
{
throw new ArgumentOutOfRangeException("value", ResourceHelper.GetResourceString("ArgumentOutOfRange_StreamLength"));
}
#if DEBUG
Contract.Ensures(_length - _origin == value);
Contract.EndContractBlock();
#endif
EnsureWriteable();
// Origin wasn't publicly exposed above.
#if DEBUG
Contract.Assert(MemStreamMaxLength == Int32.MaxValue); // Check parameter validation logic in this method if this fails.
#endif
if (value > (Int32.MaxValue - _origin))
{
throw new ArgumentOutOfRangeException("value", ResourceHelper.GetResourceString("ArgumentOutOfRange_StreamLength"));
}
int newLength = _origin + (int)value;
bool allocatedNewArray = EnsureCapacity(newLength);
if (!allocatedNewArray && newLength > _length)
{
ClusteredArray <byte> .Clear(_buffer, _length, newLength - _length);
}
_length = newLength;
if (_position > newLength)
{
_position = newLength;
}
}
public ClusteredArray <byte> ToClusteredArray()
{
ClusteredArray <byte> clone = (ClusteredArray <byte>)_buffer.Clone();
clone.Resize(_length);
return(clone);
}
public override void WriteByte(byte value)
{
if (!_isOpen)
{
__Error.StreamIsClosed();
}
EnsureWriteable();
if (_position >= _length)
{
int newLength = _position + 1;
bool mustZero = _position > _length;
if (newLength >= _capacity)
{
bool allocatedNewArray = EnsureCapacity(newLength);
if (allocatedNewArray)
{
mustZero = false;
}
}
if (mustZero)
{
ClusteredArray <byte> .Clear(_buffer, _length, _position - _length);
}
_length = newLength;
}
_buffer[_position++] = value;
}
public static void Clear(ClusteredArray <T> array, int index, int length)
{
if (index < 0 || index > array._length)
{
throw new ArgumentOutOfRangeException("index");
}
if (length < 0 || index + length > array._length)
{
throw new ArgumentOutOfRangeException("length");
}
int _lengthThreshold = array._lengthThreshold;
int superStartIndex = (index / _lengthThreshold);
int superEndIndex = ((index + length) / _lengthThreshold);
int chunkIndex = index % _lengthThreshold;
if (superStartIndex == superEndIndex)
{
Array.Clear(array._chunks[superStartIndex], chunkIndex, length);
return;
}
for (int i = superStartIndex; i <= superEndIndex; i++)
{
int toBeCleared = i == superStartIndex
? _lengthThreshold - chunkIndex
: i == superEndIndex ? length % _lengthThreshold : 0;
Array.Clear(array._chunks[i], i == superStartIndex ? chunkIndex : 0, toBeCleared);
length -= toBeCleared;
}
}
//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;
}
public object Clone()
{
ClusteredArray <T> newarray = new ClusteredArray <T>(_length);
Copy(this, 0, newarray, 0, _length);
return(newarray);
}
public ClusteredMemoryStream(int chunkLength, int size)
{
_buffer = new ClusteredArray <byte>(chunkLength, size);
_capacity = size;
_expandable = true;
_writable = true;
_exposable = true;
_origin = 0; // Must be 0 for byte[]'s created by MemoryStream
_isOpen = true;
}
public static void Copy(ClusteredArray <T> source, int sourceIndex, ClusteredArray <T> destination,
int destinationIndex, int length)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (destination == null)
{
throw new ArgumentNullException("destination");
}
if (sourceIndex > source.Length)
{
throw new ArgumentOutOfRangeException("sourceIndex");
}
if (destinationIndex > destination.Length)
{
throw new ArgumentOutOfRangeException("destinationIndex");
}
if ((sourceIndex + length) > source.Length)
{
throw new ArgumentOutOfRangeException("length");
}
if ((destinationIndex + length) > destination.Length)
{
throw new ArgumentOutOfRangeException("length");
}
VirtualIndex srcIndex = new VirtualIndex(source._lengthThreshold, sourceIndex);
VirtualIndex dstIndex = new VirtualIndex(source._lengthThreshold, destinationIndex);
int dataCopied = 0;
while (dataCopied < length)
{
T[] srcArray = source._chunks[srcIndex.YIndex];
T[] dstArray = destination._chunks[dstIndex.YIndex];
int dataRemaining = length - dataCopied;
int dstSpaceLeft = dstArray.Length - dstIndex.XIndex;
int data2Copy = dataRemaining > dstSpaceLeft ? dstSpaceLeft : dataRemaining;
int srcSpaceLeft = srcArray.Length - srcIndex.XIndex;
if (data2Copy > srcSpaceLeft)
{
data2Copy = srcSpaceLeft;
}
Array.Copy(srcArray, srcIndex.XIndex, dstArray, dstIndex.XIndex, data2Copy);
dataCopied += data2Copy;
srcIndex.IncrementBy(data2Copy);
dstIndex.IncrementBy(data2Copy);
}
}
// Creates a queue with room for capacity objects. The default grow factor
// is used.
//
/// <include file='doc\Queue.uex' path='docs/doc[@for="Queue.Queue1"]/*' />
public ClusteredQueue(int capacity)
{
if (capacity < 0)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
}
_array = new ClusteredArray <T>(capacity);
_head = 0;
_tail = 0;
_size = 0;
}
public ClusteredMemoryStream(ClusteredArray <byte> buffer)
{
_buffer = new ClusteredArray <byte>(buffer.LengthThreshold, buffer.Length);
ClusteredArray <byte> .Copy(buffer, 0, _buffer, 0, buffer.Length);
_length = _capacity = buffer.Length;
_expandable = true;
_writable = true;
_exposable = true;
_origin = 0; // Must be 0 for byte[]'s created by MemoryStream
_isOpen = true;
}
public ClusteredMemoryStream(int capacity)
{
if (capacity < 0)
{
throw new ArgumentOutOfRangeException("capacity", ResourceHelper.GetResourceString("ArgumentOutOfRange_NegativeCapacity"));
}
#if DEBUG
Contract.EndContractBlock();
#endif
_buffer = new ClusteredArray <byte>(capacity);
_capacity = capacity;
_expandable = true;
_writable = true;
_exposable = true;
_origin = 0; // Must be 0 for byte[]'s created by MemoryStream
_isOpen = true;
}
// Creates a queue with room for capacity objects with the given grow factor
//
/// <include file='doc\Queue.uex' path='docs/doc[@for="Queue.Queue1"]/*' />
public ClusteredQueue(int capacity, float growFactor)
{
if (capacity < 0)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity);
}
if (!(growFactor >= 1.0 && growFactor <= 10.0))
{
throw new ArgumentOutOfRangeException("growFactor", ResourceHelper.GetResourceString("ArgumentOutOfRange_QueueGrowFactor"));
}
_array = new ClusteredArray <T>(capacity);
_head = 0;
_tail = 0;
_size = 0;
_GrowFactor = (int)(growFactor * 100);
}
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;
}
// Removes all Objects from the queue.
/// <include file='doc\Queue.uex' path='docs/doc[@for="Queue.Clear"]/*' />
public virtual void Clear()
{
if (_head < _tail)
{
ClusteredArray <T> .Clear(_array, _head, _size);
}
else
{
ClusteredArray <T> .Clear(_array, _head, _array.Length - _head);
ClusteredArray <T> .Clear(_array, 0, _tail);
}
_head = 0;
_tail = 0;
_size = 0;
_version++;
}
// Fills a Queue with the elements of an ICollection. Uses the enumerator
// to get each of the elements.
//
/// <include file='doc\Queue.uex' path='docs/doc[@for="Queue.Queue3"]/*' />
public ClusteredQueue(IEnumerable <T> collection)
{
if (collection == null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
}
_array = new ClusteredArray <T>(_DefaultCapacity);
_size = 0;
_version = 0;
using (IEnumerator <T> en = collection.GetEnumerator())
{
while (en.MoveNext())
{
Enqueue(en.Current);
}
}
}
// PRIVATE Grows or shrinks the buffer to hold capacity objects. Capacity
// must be >= _size.
private void SetCapacity(int capacity)
{
ClusteredArray <T> newarray = new ClusteredArray <T>(capacity);
if (_size > 0)
{
if (_head < _tail)
{
ClusteredArray <T> .Copy(_array, _head, newarray, 0, _size);
}
else
{
ClusteredArray <T> .Copy(_array, _head, newarray, 0, _array.Length - _head);
ClusteredArray <T> .Copy(_array, 0, newarray, _array.Length - _head, _tail);
}
}
_array = newarray;
_head = 0;
_tail = (_size == capacity) ? 0 : _size;
_version++;
}
// Creates a queue with room for capacity objects. The default initial
// capacity and grow factor are used.
/// <include file='doc\Queue.uex' path='docs/doc[@for="Queue.Queue"]/*' />
public ClusteredQueue()
{
_array = _emptyArray;
}
//Changelog: Used ClusteredArray's internal CopyFrom method.
public override void Write(byte[] buffer, int offset, int count)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer", ResourceHelper.GetResourceString("ArgumentNull_Buffer"));
}
if (offset < 0)
{
throw new ArgumentOutOfRangeException("offset", ResourceHelper.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
if (count < 0)
{
throw new ArgumentOutOfRangeException("count", ResourceHelper.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
}
if (buffer.Length - offset < count)
{
throw new ArgumentException(ResourceHelper.GetResourceString("Argument_InvalidOffLen"));
}
#if DEBUG
Contract.EndContractBlock();
#endif
if (!_isOpen)
{
__Error.StreamIsClosed();
}
EnsureWriteable();
int i = _position + count;
// Check for overflow
if (i < 0)
{
throw new IOException(ResourceHelper.GetResourceString("IO.IO_StreamTooLong"));
}
if (i > _length)
{
bool mustZero = _position > _length;
if (i > _capacity)
{
bool allocatedNewArray = EnsureCapacity(i);
if (allocatedNewArray)
{
mustZero = false;
}
}
if (mustZero)
{
ClusteredArray <byte> .Clear(_buffer, _length, i - _length);
}
_length = i;
}
if (count <= 8)
{
int byteCount = count;
while (--byteCount >= 0)
{
_buffer[_position + byteCount] = buffer[offset + byteCount];
}
}
else
{
_buffer.CopyFrom(buffer, offset, _position, count);
}
_position = i;
}