/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> step)
{
for (Node node = _head; !(node is null); node = node.Next)
{
if (step(node.Value) is Break)
{
return(Break);
}
}
return(Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> step)
{
for (Node current = _head; !(current is null); current = current.Next)
{
if (step(current.Value) is Break)
{
return(Break);
}
}
return(Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step_function">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> step_function)
{
for (int i = 0; i < this._count; i++)
{
if (step_function(this._list[i]) == StepStatus.Break)
{
return(StepStatus.Break);
}
}
return(StepStatus.Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="function">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> function)
{
for (Node looper = _head; looper != null; looper = looper.Next)
{
if (function(looper.Value) == Break)
{
return(Break);
}
}
return(Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step_function">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> step)
{
for (int i = 0; i < _count; i++)
{
if (step(_queue[i]) == StepStatus.Break)
{
return(StepStatus.Break);
}
}
return(StepStatus.Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="function">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> function)
{
for (int i = 0; i < _array.Length; i++)
{
if (function(_array[i]) == StepStatus.Break)
{
return(StepStatus.Break);
}
}
return(StepStatus.Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> step)
{
for (Node looper = _top; looper != null; looper = looper.Down)
{
if (step(looper.Value) == Break)
{
return(Break);
}
}
return(Continue);
}
/// <summary>Steps through all the values of the set.</summary>
/// <param name="step">The action to perform on every value in the set.</param>
/// <returns>The status of the stepper.</returns>
/// <runtime>Θ(n * step)</runtime>
public StepStatus Stepper(StepBreak <T> step)
{
for (int i = 0; i < _table.Length; i++)
{
for (Node node = _table[i]; node != null; node = node.Next)
{
if (step(node.Value) == Break)
{
return(Break);
}
}
}
return(Continue);
}
/// <summary>Steps through all the values of the set.</summary>
/// <param name="step">The action to perform on every value in the set.</param>
/// <returns>The status of the stepper.</returns>
/// <runtime>Θ(n * step)</runtime>
public StepStatus Stepper(StepBreak <T> step)
{
for (int i = 0; i < _table.Length; i++)
{
if (!(_table[i] is null))
{
if (_table[i].Stepper(step) == Break)
{
return(Break);
}
}
}
return(Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> step)
{
for (int i = 0; i < _elements.Length; i++)
{
T[] array = _elements[i];
int arrayLength = array.Length;
for (int j = 0; j < arrayLength; j++)
{
if (step(array[i]) == StepStatus.Break)
{
return(StepStatus.Break);
}
}
}
return(StepStatus.Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Pairs(StepBreak <T, K> step)
{
int num = 0;
for (int index = 0; index < _lastIndex && num < _count; ++index)
{
if (_nodes[index].Hash >= 0)
{
++num;
if (step(_nodes[index].Value, _nodes[index].Key) == StepStatus.Break)
{
return(StepStatus.Break);
}
}
}
return(StepStatus.Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
/// <runtime>O(n * step)</runtime>
public StepStatus StepperReverse(StepBreak <T> step)
{
StepStatus StepperReverse(Node NODE)
{
if (NODE != null && NODE != _sentinelNode)
{
return
(StepperReverse(NODE.RightChild) == Break ? Break :
step(NODE.Value) == Break ? Break :
StepperReverse(NODE.LeftChild) == Break ? Break :
Continue);
}
return(Continue);
}
return(StepperReverse(_root));
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
/// <runtime>O(n * step)</runtime>
public StepStatus StepperReverse(StepBreak <T> step)
{
StepStatus StepperReverse(Node node)
{
if (node != null)
{
return
(StepperReverse(node.RightChild) == Break ? Break :
step(node.Value) == Break ? Break :
StepperReverse(node.LeftChild) == Break ? Break :
Continue);
}
return(Continue);
}
return(StepperReverse(_root));
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
/// <runtime>O(n * step)</runtime>
public StepStatus Stepper(StepBreak <T> step)
{
StepStatus Stepper(Node node)
{
if (node != null && node != _sentinelNode)
{
return
(Stepper(node.LeftChild) == Break ? Break :
step(node.Value) == Break ? Break :
Stepper(node.RightChild) == Break ? Break :
Continue);
}
return(Continue);
}
return(Stepper(_root));
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step_function">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> step_function)
{
for (int i = 0; i < this._stack.Length; i++)
{
switch (step_function(this._stack[i]))
{
case StepStatus.Break:
return(StepStatus.Break);
case StepStatus.Continue:
continue;
default:
throw new System.NotImplementedException();
}
}
return(StepStatus.Continue);
}
internal StepStatus StepperReverse(StepBreak <T> step_delegate, Node node)
{
if (node == null)
{
return(Continue);
}
switch (Stepper(step_delegate, node.Children[node.ItemCount]))
{
case Break:
return(Break);
case Continue:
break;
default:
throw new System.NotImplementedException();
}
for (int i = node.ItemCount - 1; i > -1; i--)
{
switch (step_delegate(node.Items[i]))
{
case Break:
return(Break);
case Continue:
break;
default:
throw new System.NotImplementedException();
}
switch (Stepper(step_delegate, node.Children[i]))
{
case Break:
return(Break);
case Continue:
break;
default:
throw new System.NotImplementedException();
}
}
return(Continue);
}
/// <summary>Steps through all the pairs.</summary>
/// <param name="step">The step function.</param>
public StepStatus Pairs(StepBreak <T, K> step)
{
Node node;
for (int i = 0; i < _table.Length; i++)
{
if ((node = _table[i]) != null)
{
do
{
if (step(node.Value, node.Key) == StepStatus.Break)
{
return(StepStatus.Break);
}
} while ((node = node.Next) != null);
}
}
return(StepStatus.Continue);
}
private StepStatus StepperInOrder(StepBreak <T> function, Node node)
{
if (node != null && node.LeftChild != null && node.RightChild != null)
{
if (StepperInOrder(function, node.LeftChild) == StepStatus.Break)
{
return(StepStatus.Break);
}
if (function(node.Value) == StepStatus.Break)
{
return(StepStatus.Break);
}
if (StepperInOrder(function, node.RightChild) == StepStatus.Break)
{
return(StepStatus.Break);
}
}
return(StepStatus.Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="function">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> function)
{
Node node;
for (int i = 0; i < _table.Length; i++)
{
if ((node = _table[i]) != null)
{
do
{
if (function(node.Value) == StepStatus.Break)
{
return(StepStatus.Break);
}
} while ((node = node.Next) != null);
}
}
return(StepStatus.Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="function">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> function)
{
for (int i = 0; i < this._table.Length; i++)
{
if (object.ReferenceEquals(null, this._table[i]))
{
switch (this._table[i].Stepper(function))
{
case StepStatus.Break:
return(StepStatus.Break);
case StepStatus.Continue:
continue;
default:
throw new System.NotImplementedException();
}
}
}
return(StepStatus.Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step_function">The delegate to invoke on each item in the structure.</param>
/// <param name="minimum">The minimum value of the optimized stepper function.</param>
/// <param name="maximum">The maximum value of the optimized stepper function.</param>
/// <remarks>Runtime: O(n * traversalFunction).</remarks>
public virtual StepStatus StepperReverse(StepBreak <T> step_function, T minimum, T maximum)
{
StepStatus StepperReverse(StepBreak <T> STEP, Node NODE, T MINIMUM, T MAXIMUM)
{
if (NODE != null)
{
if (_compare(NODE.Value, MINIMUM) == Comparison.Less)
{
return(StepperReverse(STEP, NODE.RightChild, MINIMUM, MAXIMUM));
}
else if (_compare(NODE.Value, MAXIMUM) == Comparison.Greater)
{
return(StepperReverse(STEP, NODE.LeftChild, MINIMUM, MAXIMUM));
}
else
{
if (StepperReverse(STEP, NODE.RightChild, MINIMUM, MAXIMUM) == StepStatus.Break)
{
return(StepStatus.Break);
}
if (STEP(NODE.Value) == StepStatus.Break)
{
return(StepStatus.Break);
}
if (StepperReverse(STEP, NODE.LeftChild, MINIMUM, MAXIMUM) == StepStatus.Break)
{
return(StepStatus.Break);
}
}
}
return(StepStatus.Continue);
}
if (_compare(minimum, maximum) == Comparison.Greater)
{
throw new InvalidOperationException("!(" + nameof(minimum) + " <= " + nameof(maximum) + ")");
}
return(StepperReverse(step_function, _root, minimum, maximum));
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="function">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> function)
{
Node current = this._head;
while (current != null)
{
switch (function(current.Value))
{
case StepStatus.Break:
current = current.Next;
return(StepStatus.Break);
case StepStatus.Continue:
current = current.Next;
continue;
default:
current = current.Next;
throw new System.NotImplementedException();
}
}
return(StepStatus.Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Pairs(StepBreak <Link <T, K> > step)
{
int num = 0;
for (int index = 0; index < this._lastIndex && num < _count; ++index)
{
if (_nodes[index].Hash >= 0)
{
++num;
switch (step(new Link <T, K>(_nodes[index].Value, _nodes[index].Key)))
{
case StepStatus.Break:
return(StepStatus.Break);
case StepStatus.Continue:
continue;
default:
throw new System.NotImplementedException();
}
}
}
return(StepStatus.Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="function">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> function)
{
int num = 0;
for (int index = 0; index < this._lastIndex && num < this._count; ++index)
{
if (this._nodes[index].Hash >= 0)
{
++num;
switch (function(this._nodes[index].Value))
{
case StepStatus.Break:
return(StepStatus.Break);
case StepStatus.Continue:
continue;
default:
throw new System.NotImplementedException();
}
}
}
return(StepStatus.Continue);
}
/// <summary>Steps through all the keys.</summary>
/// <param name="step">The step function.</param>
public StepStatus Keys(StepBreak <K> step)
{
int num = 0;
for (int index = 0; index < _lastIndex && num < _count; ++index)
{
if (this._nodes[index].Hash >= 0)
{
++num;
switch (step(_nodes[index].Key))
{
case StepStatus.Break:
return(StepStatus.Break);
case StepStatus.Continue:
continue;
default:
throw new NotImplementedException();
}
}
}
return(StepStatus.Continue);
}
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="step">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
/// <remarks>Runtime: O(n * traversalFunction).</remarks>
public StepStatus StepperReverse(StepBreak <T> step)
{
StepStatus StepperReverse(StepBreak <T> STEP, Node NODE)
{
if (NODE != null)
{
if (StepperReverse(STEP, NODE.RightChild) == StepStatus.Break)
{
return(StepStatus.Break);
}
if (STEP(NODE.Value) == StepStatus.Break)
{
return(StepStatus.Break);
}
if (StepperReverse(STEP, NODE.LeftChild) == StepStatus.Break)
{
return(StepStatus.Break);
}
}
return(StepStatus.Continue);
}
return(StepperReverse(step, _root));
}
public StepStatus Stepper(StepBreak <T, T> step)
{
throw new NotImplementedException();
}
/// <summary>Steps through all the edges in the graph.</summary> /// <param name="step">The action to perform on all the edges in the graph.</param> /// <returns>The status of the stepper operation.</returns> public StepStatus Stepper(StepBreak <T, T> step) => _edges.Stepper(edge => step(edge.Start, edge.End));
/// <summary>Invokes a delegate for each entry in the data structure.</summary>
/// <param name="function">The delegate to invoke on each item in the structure.</param>
/// <returns>The resulting status of the iteration.</returns>
public StepStatus Stepper(StepBreak <T> function)
{
throw new System.NotImplementedException();
}
/// <summary>Steps through all the nodes in the graph.</summary> /// <param name="step">The action to perform on all the nodes in the graph.</param> /// <returns>The status of the stepper operation.</returns> public StepStatus Stepper(StepBreak <T> step) => _nodes.Stepper(step);
