Inheritance diagram for Deveel.Data.Index.BlockIndexBase< T >.Enumerator:

Public Member Functions
	Enumerator (BlockIndexBase< T > index, int startOffset, int endOffset)

void	Dispose ()

bool	MoveNext ()

void	Reset ()

bool	MoveBack ()
	Reverses the direction of the enumerator to the previous element within the list. /summary> returns> Returns true if the enumerator has more elements when traversing the index in the reverse direction, otherwise it returns false. More...

void	Remove ()

Properties
T	Current `[get]`

object IEnumerator.	Current `[get]`

Private Member Functions
void	SetupVars (int offset)

void	WalkBack ()

Private Attributes
readonly BlockIndexBase< T >	index

readonly int	startOffset

int	endOffset

IIndexBlock< T >	currentBlock

int	currentBlockSize

int	blockIndex

int	blockOffset

int	currentOffset

Detailed Description

Definition at line 826 of file BlockIndexBase_T.cs.

Constructor & Destructor Documentation

Deveel.Data.Index.BlockIndexBase< T >.Enumerator.Enumerator	(	BlockIndexBase< T >	index,
		int	startOffset,
		int	endOffset
	)

inline

Definition at line 838 of file BlockIndexBase_T.cs.

                                                                                        {
                 this.index = index;
                 this.startOffset = startOffset;
                 this.endOffset = endOffset;
 
                 Reset();
             }

Member Function Documentation

void Deveel.Data.Index.BlockIndexBase< T >.Enumerator.Dispose ( )

inline

Definition at line 869 of file BlockIndexBase_T.cs.

869 {

870 }

bool Deveel.Data.Index.BlockIndexBase< T >.Enumerator.MoveBack ( )

inline

Reverses the direction of the enumerator to the previous element within the list. /summary> returns> Returns true if the enumerator has more elements when traversing the index in the reverse direction, otherwise it returns false.

summary> Removes from the underlying index the current element this enumerator is positioned at. /summary>

This method can be called only once per call to IEnumerator<T>.Current. The behavior of an iterator is unspecified if the underlying index is modified while the iteration is in progress in any way other than by calling this method.

Some implementations of IIndexEnumerator<T> may choose to not implement this method, in which case an appropriate exception is generated.

Implements Deveel.Data.Index.IIndexEnumerator< T >.

Definition at line 919 of file BlockIndexBase_T.cs.

                                    {
                 if (currentOffset > startOffset) {
                     WalkBack();
                     return true;
                 }
 
                 return false;
             }

bool Deveel.Data.Index.BlockIndexBase< T >.Enumerator.MoveNext ( )

inline

Definition at line 872 of file BlockIndexBase_T.cs.

                                    {
                 if (currentOffset < endOffset) {
                     ++currentOffset;
 
                     if (++blockOffset >= currentBlockSize) {
                         ++blockIndex;
                         currentBlock = index.Blocks[blockIndex];
                         currentBlockSize = currentBlock.Count;
                         blockOffset = 0;
                     }
 
                     return true;
                 }
 
                 return false;
             }

void Deveel.Data.Index.BlockIndexBase< T >.Enumerator.Remove ( )

inline

Implements Deveel.Data.Index.IIndexEnumerator< T >.

Definition at line 928 of file BlockIndexBase_T.cs.

                                  {
                 index.CheckImmutable();
 
                 // NOT ELEGANT: We check 'blocks' size to determine if the value
                 //   deletion caused blocks to be removed.  If it did, we set up the
                 //   internal variables afresh with a call to 'setupVars'.
                 int origBlockCount = index.Blocks.Count;
                 index.RemoveFromBlock(blockIndex, currentBlock, blockOffset);
 
                 // Did the number of blocks in the list change?
                 if (origBlockCount == index.Blocks.Count) {
                     // HACK: Evaluate the current cached block size
                     --currentBlockSize;
                     WalkBack();
                 } else {
                     --currentOffset;
                     SetupVars(currentOffset);
                 }
                 --endOffset;
             }

void Deveel.Data.Index.BlockIndexBase< T >.Enumerator.Reset ( )

inline

Definition at line 889 of file BlockIndexBase_T.cs.

                                 {
                 currentOffset = startOffset - 1;
 
                 if (endOffset >= startOffset) {
                     // Setup variables to 1 before the start
                     SetupVars(startOffset - 1);
                 }
             }

void Deveel.Data.Index.BlockIndexBase< T >.Enumerator.SetupVars ( int offset )

inlineprivate

Definition at line 846 of file BlockIndexBase_T.cs.

                                                {
                 int size = index.Blocks.Count;
                 int start = 0;
                 for (blockIndex = 0; blockIndex < size; ++blockIndex) {
                     var block = index.Blocks[blockIndex];
                     int bsize = block.Count;
                     if (offset < start + bsize) {
                         blockOffset = offset - start;
                         if (blockOffset < 0)
                             blockOffset = -1;
 
                         currentBlock = block;
                         currentBlockSize = bsize;
                         return;
                     }
                     start += bsize;
                 }
 
                 throw new IndexOutOfRangeException("'index' (" + offset + ") out of bounds.");
             }

void Deveel.Data.Index.BlockIndexBase< T >.Enumerator.WalkBack ( )

inlineprivate

Definition at line 906 of file BlockIndexBase_T.cs.

                                     {
                 --blockOffset;
                 --currentOffset;
                 if (blockOffset < 0) {
                     if (blockIndex > 0) {
                         --blockIndex;
                         currentBlock = index.Blocks[blockIndex];
                         currentBlockSize = currentBlock.Count;
                         blockOffset = currentBlock.Count - 1;
                     }
                 }
             }