/// <summary>
/// Creates a shallow copy of a range of elements in the source <see cref="BigArray{T}"/>.
/// </summary>
/// <param name="index">The zero-based <see cref="BigArray{T}"/> index at which the range starts.</param>
/// <param name="count">The number of elements in the range.</param>
/// <returns></returns>
public BigArray <T> GetRange(int index, int count)
{
if (!this.IsValidRange(index, count))
{
throw new ArgumentOutOfRangeException();
}
var newArray = new BigArray <T>();
if (count == 0)
{
return(newArray);
}
var enumerator = GetEnumerator();
((BigArrayEnumerator)enumerator).MoveToIndex(index);
bool isContinue = true;
while (isContinue && count != 0)
{
newArray.Add(enumerator.Current);
count--;
isContinue = enumerator.MoveNext();
}
return(newArray);
}
//API
/// <summary>
/// Supports a iteration over a <see cref="BigArray"/> collection.
/// </summary>
/// <param name="array"><see cref="BigArray"/> object using for enumerate it.</param>
public BigArrayEnumerator(BigArray <T> array)
{
Array = array;
_blockCollection = Array._blockCollection;
_blockCount = _blockCollection.Count;
if (Array.Count != 0)
{
Reset();
}
}
/// <summary>
/// Converts the elements in the current <see cref="BigArray{T}"/> to another type, and returns a list containing the converted elements.
/// </summary>
/// <typeparam name="TOutput">The type of the elements of the target array.</typeparam>
/// <param name="converter">A Converter{TInput, TOutput} delegate that converts each element from one type to another type.</param>
/// <returns>A <see cref="BigArray{T}"/> of the target type containing the converted elements from the current <see cref="BigArray{T}"/>.</returns>
public BigArray <TOutput> ConvertAll <TOutput>(Converter <T, TOutput> converter)
{
if (converter == null)
{
throw new ArgumentNullException("converter");
}
var result = new BigArray <TOutput>();
//Convert all blocks
foreach (var block in _blockCollection)
{
result._blockCollection.Add(block.ConvertAll(converter));
}
return(result);
}
/// <summary>
/// Retrieves all the elements that match the conditions defined by the specified predicate.
/// </summary>
/// <param name="match">The Predicate{T} delegate that defines the conditions of the elements to search for.</param>
/// <param name="isSaveOrder">If flag is true - return suitable elements in right order, otherwise - order doesn't matter.</param>
/// <returns>A <see cref="BigArray{T}"/> containing all the elements that match the conditions defined by the specified predicate,
/// if found; otherwise, an empty <see cref="BigArray{T}"/>.</returns>
public BigArray <T> FindAll(Predicate <T> match, bool isSaveOrder = false)
{
if (match == null)
{
throw new ArgumentNullException("match");
}
var resultArray = new BigArray <T>();
if (isSaveOrder)
{
foreach (var block in _blockCollection)
{
var findData = block.FindAll(match);
if (findData.Count != 0)
{
resultArray.AddRange(findData);
}
}
}
else
{
object locker = new object();
Parallel.ForEach(_blockCollection, block =>
{
var findData = block.FindAll(match);
lock (locker)
{
if (findData.Count != 0)
{
resultArray.AddRange(findData);
}
}
});
}
return(resultArray);
}
/// <summary>
/// Initializes a new instance of the <see cref="BigStack{T}"/> class that contains elements copied from the specified collection.
/// </summary>
/// <param name="collection">The collection to copy elements from.</param>
public BigStack(ICollection <T> collection)
{
_array = new BigArray <T>(collection);
}
/// <summary>
/// Crerate new instance of <see cref="BigQueue{T}"/> using specified collection.
/// </summary>
/// <param name="collection">Collection whitch use as base for the new <see cref="BigQueue{T}"/>.
/// The collection it self can't be null, but it can contains elements that are null, if type T is a reference type.</param>
public BigQueue(ICollection <T> collection)
{
_array = new BigArray <T>(collection);
}
