Adapter: a wrapper of a list that provides a view of a range of elements. Objects of this type are returned from ListExt.Slice{T} More...

Source file:

/Core/Loyc.Essentials/Collections/Adapters/ListSlice.cs

Inheritance diagram for Loyc.Collections.ListSlice< T >:

Remarks

Adapter: a wrapper of a list that provides a view of a range of elements. Objects of this type are returned from ListExt.Slice{T}

ListSlice provides both a IList{T} interface and a IRange{T} interface, and it is important not to confuse them. The IList{T} interface allows you to insert and remove items from both the original list and the slice simultaneously. The IRange{T} interface allows you to "Pop" items from the front and back, but this reduces the length of the slice only, not the original list.

Public fields
IList< T >	_list

int	_start

int	_count

Public static fields
static readonly ListSlice< T >	Empty = new ListSlice<T>()

Properties
int	Count `[get]`

bool	IsEmpty `[get]`

T	Front `[get]`

T	Back `[get]`

T	this[int index] `[get, set]`

T	this[int index, T defaultValue] `[get]`

IList< T >	InternalList `[get]`
	Returns the original list. More...

int	InternalStart `[get]`

int	InternalStop `[get]`

bool	IsReadOnly `[get]`

Properties inherited from Loyc.Collections.IBRange< out T >
T	Back `[get]`
	Returns the value of the last item in the range. More...

Properties inherited from Loyc.Collections.IFRange< out T >
T	Front `[get]`
	Returns the first value in the range, without popping it. More...

Properties inherited from Loyc.Collections.IIsEmpty
bool	IsEmpty `[get]`

Properties inherited from Loyc.Collections.ICount
int	Count `[get]`
	Gets the number of items in the collection. More...

Properties inherited from Loyc.Collections.IArray< T >
new T	this[int index] `[get, set]`
	Gets or sets an element of the array-like collection. More...

Properties inherited from Loyc.Collections.ISinkArray< T >
T	this[int index] `[set]`

Public Member Functions
	ListSlice (IList< T > list, int start, int count)
	Initializes a slice. More...

	ListSlice (IList< T > list)

T	PopFront (out bool fail)
	Removes the first item from the range and returns it. More...

T	PopBack (out bool fail)
	Removes the last item from the range and returns it. More...

IFRange< T > ICloneable < IFRange< T > >.	Clone ()

IBRange< T > ICloneable < IBRange< T > >.	Clone ()

IRange< T > ICloneable< IRange < T > >.	Clone ()

ListSlice< T > ICloneable < ListSlice< T > >.	Clone ()

IEnumerator< T > IEnumerable< T >.	GetEnumerator ()

System.Collections.IEnumerator System.Collections.IEnumerable.	GetEnumerator ()

RangeEnumerator< ListSlice< T > , T >	GetEnumerator ()

T	TryGet (int index, out bool fail)
	Gets the item at the specified index, and does not throw an exception on failure. More...

IRange< T > IListSource< T >.	Slice (int start, int count)
	Returns a sub-range of this list. More...

ListSlice< T >	Slice (int start, int count=int.MaxValue)
	Returns a sub-range of this list. More...

int	IndexOf (T item)

void	Insert (int index, T item)

void	RemoveAt (int index)

void	Add (T item)

void	Clear ()

bool	Contains (T item)

void	CopyTo (T[] array, int arrayIndex)

bool	Remove (T item)

bool	TrySet (int index, T value)

void	AddRange (IReadOnlyCollection< T > list)

void	AddRange (IEnumerable< T > list)

int	RemoveAll (Predicate< T > match)
	Removes the all the elements that match the conditions defined by the specified predicate. More...

Constructor & Destructor Documentation

Loyc.Collections.ListSlice< T >.ListSlice	(	IList< T >	list,
		int	start,
		int	count
	)

inline

Initializes a slice.

Exceptions

ArgumentException The start index was below zero.

The (start, count) range is allowed to be invalid, as long as 'start' and 'count' are zero or above.

If 'start' is above the original Count, the Count of the new slice is set to zero.
if (start + count) is above the original Count, the Count of the new slice is reduced to list.Count - start. Note that the Count of the slice will not increase if the list expands after the slice is created.

Member Function Documentation

T Loyc.Collections.ListSlice< T >.PopBack ( out bool fail )

inline

Removes the last item from the range and returns it.

Parameters

fail	Receives the current value of IsEmpty.

Returns: The first item of the range, or default(T) if IsEmpty.

The remarks of IFRange{T}.PopFront apply to this method.

Implements Loyc.Collections.IBRange< out T >.

T Loyc.Collections.ListSlice< T >.PopFront ( out bool fail )

inline

Removes the first item from the range and returns it.

Parameters

fail	Receives the current value of IIsEmpty.IsEmpty.

Returns: The first item of the range, or default(T) if IsEmpty.

This method is a little unweildy in plain C#, but in EC# it will be a bit more convenient to use via extension methods like PopFirst(ref this Range range, T defaultValue) and PopFirst(ref this Range range), which are illegal in plain C#.

I wanted to give this method the signature "bool PopFirst(out T first)" but the generic parameter "T" is covariant, i.e. it is marked "out T" which, ironically, is not compatible with "out T" parameters, only with return values.

Implements Loyc.Collections.IFRange< out T >.

int Loyc.Collections.ListSlice< T >.RemoveAll ( Predicate< T > match )

inline

Removes the all the elements that match the conditions defined by the specified predicate.

Parameters

match A delegate that defines the conditions of the elements to remove

Returns: The number of elements removed.

Implements Loyc.Collections.ICollectionEx< T >.

IRange<T> IListSource<T>. Loyc.Collections.ListSlice< T >.Slice	(	int	start,
		int	count
	)

inline

Returns a sub-range of this list.

Parameters

start	The new range will start at this index in the current list (this location will be index [0] in the new range).
count	The desired number of elements in the new range, or int.MaxValue to get all elements until the end of the list.

Returns: Returns a sub-range of this range.

Exceptions

ArgumentException The start index was below zero.

The (start, count) range is allowed to be invalid, as long as start is zero or above.

If count is below zero, or if start is above the original Count, the Count of the new slice is set to zero.
if (start + count) is above the original Count, the Count of the new slice is reduced to this.Count - start. Implementation note: do not compute (start + count) because it may overflow. Instead, test whether (count > this.Count - start).

Most collections should use the following implementation:

IRange<T> IListSource<T>.Slice(int start, int count) { return Slice(start, count); }
public Slice_<T> Slice(int start, int count) { return new Slice_<T>(this, start, count); }

Implements Loyc.Collections.IListSource< out T >.

References Loyc.Collections.ListSlice< T >.Slice().

Referenced by Loyc.Collections.ListSlice< T >.Slice().

ListSlice<T> Loyc.Collections.ListSlice< T >.Slice	(	int	start,
		int	count = `int.MaxValue`
	)

inline

Returns a sub-range of this list.

Parameters

start	The new range will start at this index in the current list (this location will be index [0] in the new range).
count	The desired number of elements in the new range, or int.MaxValue to get all elements until the end of the list.

Returns: Returns a sub-range of this range.

Exceptions

ArgumentException The start index was below zero.

The (start, count) range is allowed to be invalid, as long as start is zero or above.

If count is below zero, or if start is above the original Count, the Count of the new slice is set to zero.
if (start + count) is above the original Count, the Count of the new slice is reduced to this.Count - start. Implementation note: do not compute (start + count) because it may overflow. Instead, test whether (count > this.Count - start).

Most collections should use the following implementation:

IRange<T> IListSource<T>.Slice(int start, int count) { return Slice(start, count); }
public Slice_<T> Slice(int start, int count) { return new Slice_<T>(this, start, count); }

Implements Loyc.Collections.IListSource< out T >.

T Loyc.Collections.ListSlice< T >.TryGet	(	int	index,
		out bool	fail
	)

inline

Gets the item at the specified index, and does not throw an exception on failure.

Parameters

index	An index in the range 0 to Count-1.
fail	A flag that is set on failure.

Returns: The element at the specified index, or default(T) if the index is not valid.

In my original design, the caller could provide a value to return on failure, but this would not allow T to be marked as "out" in C# 4. For the same reason, we cannot have a ref/out T parameter. Instead, the following extension methods are provided:

bool TryGet(int index, ref T value);

T TryGet(int, T defaultValue);

Implements Loyc.Collections.IListSource< out T >.

Property Documentation

IList<T> Loyc.Collections.ListSlice< T >.InternalList

get

Returns the original list.

Ideally, to protect the list there would be no way to access its contents beyond the boundaries of the slice. However, the reality in .NET today is that many methods accept "slices" in the form of a triple (list, start index, count). In order to call such an old-style API using a slice, one must be able to extract the internal list and start index values.

Documentation moved to ecsharp.net

Remarks

Public fields

Public static fields

Properties

Public Member Functions

Constructor & Destructor Documentation

Member Function Documentation

Property Documentation