SystemEx.FlexSpan< T > Struct Template Reference

A lightweight view over an array supporting System, Reverse, and Ring (circular) indexing. FlexSpan does not allocate and provides ref-return access to elements. More...

Classes
struct	Enumerator
	Enumerator for FlexSpan. Supports forward, reverse, and ring traversal. More...

Public Member Functions
bool	MoveNext ()
	Moves to the next element in the span.
void IEnumerator.	Reset ()
	Resets the enumerator to the initial position. Ring mode resets to index 0; other modes reset to -1.
void IDisposable.	Dispose ()
	No resources to dispose.
	FlexSpan (ref T[]? reference, long start, FlexSpanMode mode)
	Creates a FlexSpan over an array starting at a given index.
	FlexSpan (ref T[]? array, long start, long length, FlexSpanMode mode)
	Creates a FlexSpan over an array with a defined view length.
FlexSpan< T >	Slice (int start, FlexSpanMode? mode=null)
	Creates a new FlexSpan starting at the given offset.
FlexSpan< T >	Slice (int start, int length, FlexSpanMode? mode=null)
	Creates a new FlexSpan with a given offset and length.
override bool	Equals (object? obj)
override int	GetHashCode ()
Enumerator	GetEnumerator ()
	Returns an enumerator for the span.
Collections.Generic.Vector< T >	ToArray ()
	Copies the view into a new Array<T>.
void	CopyTo (FlexSpan< T > destination)
	Copies this FlexSpan's view into another FlexSpan.
bool	TryCopyTo (FlexSpan< T > destination)
	Attempts to copy the view into another FlexSpan.
void	Fill (T value)
	Fills the view with a given value.
ref T	ElementAt (long index)
	Returns a reference to the element at the given index according to the current mode. System = forward indexing Reverse = reverse indexing Ring = circular indexing (wrap-around).

Static Public Member Functions
static bool	operator== (FlexSpan< T > left, FlexSpan< T > right)
	Structural equality comparison.
static bool	operator!= (FlexSpan< T > left, FlexSpan< T > right)
	Structural not equality comparison.

Properties
bool	HasNext [get]
	Indicates whether another element can be produced. Ring mode always returns true (infinite iteration).
ref T	Current [get]
	Gets the element at the current enumerator position.
T IEnumerator< T >.	Current [get]
object IEnumerator.	Current [get]
bool	IsEmpty [get]
	True if the span has zero length.
long	Length [get]
	Total length of the underlying array.
long	ViewLength [get]
	Length of the view (End - Start).
long	Start [get]
	Start index of the view.
long	End [get]
	End index of the view (exclusive).
ref T	this[int index] [get]
	Provides ref-access to the element at the given index within the view.
static FlexSpan< T >	Empty [get]
	Returns an empty FlexSpan.

Detailed Description

A lightweight view over an array supporting System, Reverse, and Ring (circular) indexing. FlexSpan does not allocate and provides ref-return access to elements.

---

Class Documentation

SystemEx::FlexSpan-1-g::Enumerator

struct SystemEx::FlexSpan-1-g::Enumerator

Enumerator for FlexSpan. Supports forward, reverse, and ring traversal.

Member Function Documentation

CopyTo()

void SystemEx.FlexSpan< T >.CopyTo

(

FlexSpan< T >

destination

)

Copies this FlexSpan's view into another FlexSpan.

                                                       {
            if ( destination.ViewLength < this.ViewLength )
                throw new ArgumentException("Destination FlexSpan is too small.");
 
 
            for ( long i = 0 ; i < ViewLength ; i++ )
                destination.ElementAt(i) = this.ElementAt(i);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Dispose()

void IDisposable. SystemEx.FlexSpan< T >.Dispose

(

)

No resources to dispose.

{ }

ElementAt()

ref T SystemEx.FlexSpan< T >.ElementAt

(

long

index

)

Returns a reference to the element at the given index according to the current mode. System = forward indexing Reverse = reverse indexing Ring = circular indexing (wrap-around).

                                              {
 
            ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, ViewLength);
 
 
            switch ( m_eMode ) {
                case FlexSpanMode.System:
                    return ref m_pReference[m_lStart + index];
 
                case FlexSpanMode.Reverse:
                    return ref m_pReference[m_lEnd - (1 + index)];
 
 
                case FlexSpanMode.Ring: {
                    long pos = m_lStart + (index % ViewLength);
 
                    return ref m_pReference[pos];
                }
            default:
                    throw new InvalidOperationException();
            }
        }

Here is the caller graph for this function:

Equals()

override bool SystemEx.FlexSpan< T >.Equals

(

object?

obj

)

=> throw new NotSupportedException();

Fill()

void SystemEx.FlexSpan< T >.Fill

(

T

value

)

Fills the view with a given value.

                                     {
 
            for ( long i = 0 ; i < ViewLength ; i++ )
                ElementAt(i) = value;
 
        }

Here is the call graph for this function:

FlexSpan() [1/2]

SystemEx.FlexSpan< T >.FlexSpan	(	ref T?[]	array,
		long	start,
		long	length,
		FlexSpanMode	mode )

Creates a FlexSpan over an array with a defined view length.

                                                                                       {
            if ( array == null ) throw new NullReferenceException();
 
            ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual((ulong)length, (ulong)(array.Length - start));
            ArgumentOutOfRangeException.ThrowIfGreaterThan((ulong)start, (ulong)array.Length);
 
            m_pReference = ref array!;
            m_llength = array.Length;
            m_eMode = mode;
 
            // View 
            m_lStart = start;
            m_lEnd = start + length;
 
        }

FlexSpan() [2/2]

SystemEx.FlexSpan< T >.FlexSpan	(	ref T?[]	reference,
		long	start,
		FlexSpanMode	mode )

Creates a FlexSpan over an array starting at a given index.

                                                                              {
            if ( reference == null ) throw new NullReferenceException();
            ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(start, reference.Length);
 
            m_pReference = ref reference!;
            m_llength = reference.Length;
            m_eMode = mode;
 
            // View 
            m_lStart = start;
            m_lEnd = m_llength;
        }

Here is the caller graph for this function:

GetEnumerator()

Enumerator SystemEx.FlexSpan< T >.GetEnumerator

(

)

Returns an enumerator for the span.

=> new Enumerator(this);

GetHashCode()

override int SystemEx.FlexSpan< T >.GetHashCode

(

)

=> throw new NotSupportedException();

MoveNext()

bool SystemEx.FlexSpan< T >.MoveNext

(

)

Moves to the next element in the span.

                                    {
                bool _ret = false;
 
                if( HasNext ) {
                    m_index++;
                    if ( m_index < 0 ) m_index = 0;
                    _ret = true;
                }
                return _ret;
            }

operator!=()

bool SystemEx.FlexSpan< T >.operator!= ( FlexSpan< T > left, FlexSpan< T > right )

static

Structural not equality comparison.

=> !(left == right);

Here is the call graph for this function:

operator==()

bool SystemEx.FlexSpan< T >.operator== ( FlexSpan< T > left, FlexSpan< T > right )

static

Structural equality comparison.

                                                                             =>
            left.m_llength == right.m_llength &&
            left.m_pReference.Equals(right.m_pReference) &&
            left.m_eMode == right.m_eMode &&
            left.m_lStart == right.m_lStart &&
            left.m_lEnd == right.m_lEnd;

Here is the call graph for this function:

Reset()

void IEnumerator. SystemEx.FlexSpan< T >.Reset

(

)

Resets the enumerator to the initial position. Ring mode resets to index 0; other modes reset to -1.

=> m_index = m_span.m_eMode == FlexSpanMode.Ring ? 0 : m_index = -1;

Slice() [1/2]

FlexSpan< T > SystemEx.FlexSpan< T >.Slice	(	int	start,
		FlexSpanMode?	mode = null )

Creates a new FlexSpan starting at the given offset.

            => new FlexSpan<T>(ref m_pReference!, m_lStart + start, m_llength - start, mode ?? m_eMode);

Here is the call graph for this function:

Slice() [2/2]

FlexSpan< T > SystemEx.FlexSpan< T >.Slice	(	int	start,
		int	length,
		FlexSpanMode?	mode = null )

Creates a new FlexSpan with a given offset and length.

            => new FlexSpan<T>(ref m_pReference!, m_lStart + start, length, mode ?? m_eMode);

Here is the call graph for this function:

ToArray()

Collections.Generic.Vector< T > SystemEx.FlexSpan< T >.ToArray

(

)

Copies the view into a new Array<T>.

                                                        {
            if ( m_llength == 0 )
                return new Collections.Generic.Vector<T>();
 
            var destination = new Collections.Generic.Vector<T>( (int)(m_lEnd - m_lStart) );
 
            for ( long i = m_lStart, j = 0 ; i < m_lEnd ; i++, j++ ) {
                T _e = ElementAt(j);
                destination[(int)j] = _e;
#if DEBUG
                Console.WriteLine("ToArray, i = {0} j = {1} {2} [{3} ... {4}]", i, j, _e , m_lStart, m_lEnd);
#endif
            }
 
            return destination;
        }

Here is the call graph for this function:

TryCopyTo()

bool SystemEx.FlexSpan< T >.TryCopyTo

(

FlexSpan< T >

destination

)

Attempts to copy the view into another FlexSpan.

                                                          {
            bool _ret = false;
            try {
                CopyTo(destination);
 
                _ret = true;
            } catch(Exception ) {
                _ret = false;
            }
            return _ret;
        }

Here is the call graph for this function:

Property Documentation

Current [1/3]

object IEnumerator. SystemEx.FlexSpan< T >.Current

get

Current [2/3]

T IEnumerator<T>. SystemEx.FlexSpan< T >.Current

get

Current [3/3]

ref T SystemEx.FlexSpan< T >.Current

get

Gets the element at the current enumerator position.

                                 {
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                get => ref m_span[m_index];
            }

Empty

FlexSpan<T> SystemEx.FlexSpan< T >.Empty

staticget

Returns an empty FlexSpan.

End

long SystemEx.FlexSpan< T >.End

get

End index of the view (exclusive).

HasNext

bool SystemEx.FlexSpan< T >.HasNext

get

Indicates whether another element can be produced. Ring mode always returns true (infinite iteration).

                                {
                [MethodImpl(MethodImplOptions.AggressiveInlining)]
                get {
                    bool _ret = false;
                    if ( m_span.m_eMode == FlexSpanMode.Ring )
                        _ret = true;
                    else
                        _ret = (m_index + 1) < (m_span.m_lEnd - m_span.m_lStart);
                    return _ret;
                }
            }

IsEmpty

bool SystemEx.FlexSpan< T >.IsEmpty

get

True if the span has zero length.

Length

long SystemEx.FlexSpan< T >.Length

get

Total length of the underlying array.

Start

long SystemEx.FlexSpan< T >.Start

get

Start index of the view.

this[int index]

ref T SystemEx.FlexSpan< T >.this[int index]

get

Provides ref-access to the element at the given index within the view.

                                     {
            get => ref ElementAt(index);
        }

ViewLength

long SystemEx.FlexSpan< T >.ViewLength

get

Length of the view (End - Start).

---

The documentation for this struct was generated from the following file:

• FlexSpan.cs