// Removes all Objects from the queue.
/// <include file='doc\Queue.uex' path='docs/doc[@for="Queue.Clear"]/*' />
public virtual void Clear()
{
ClusteredArray <T> oldArray = null;
if (_transaction != null)
{
oldArray = _array;
_array = new ClusteredArray <T>(0);
}
else 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++;
if (_transaction != null)
{
_transaction.AddRollbackOperation(new ClearRollbackOperation(this, oldArray));
}
}
// 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 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;
}
// Removes a range of elements from this list.
//
public void RemoveRange(int index, int count)
{
if (index < 0)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
}
if (count < 0)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
}
if (_size - index < count)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
}
#if DEBUG
Contract.EndContractBlock();
#endif
if (count > 0)
{
int i = _size;
_size -= count;
if (index < _size)
{
ClusteredArray <T> .Copy(_items, index + count, _items, index, _size - index);
}
ClusteredArray <T> .Clear(_items, _size, count);
_version++;
}
}
// Clears the contents of List.
public void Clear()
{
if (_size > 0)
{
ClusteredArray <T> .Clear(_items, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.
_size = 0;
}
_version++;
}
// This method removes all items which matches the predicate.
// The complexity is O(n).
public int RemoveAll(Predicate <T> match)
{
if (match == null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match);
}
#if DEBUG
Contract.Ensures(Contract.Result <int>() >= 0);
Contract.Ensures(Contract.Result <int>() <= Contract.OldValue(Count));
Contract.EndContractBlock();
#endif
int freeIndex = 0; // the first free slot in items array
// Find the first item which needs to be removed.
while (freeIndex < _size && !match(_items[freeIndex]))
{
freeIndex++;
}
if (freeIndex >= _size)
{
return(0);
}
int current = freeIndex + 1;
while (current < _size)
{
// Find the first item which needs to be kept.
while (current < _size && match(_items[current]))
{
current++;
}
if (current < _size)
{
// copy item to the free slot.
_items[freeIndex++] = _items[current++];
}
}
ClusteredArray <T> .Clear(_items, freeIndex, _size - freeIndex);
int result = _size - freeIndex;
_size = freeIndex;
_version++;
return(result);
}
// 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++;
}
//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;
}
