/// <summary>
/// Deletes given <paramref name="node"/> from deque.
/// </summary>
public void Delete(Node <T> node)
{
node.ThrowIfArgumentNull(nameof(node));
if (node.owner != this)
{
throw new InvalidOperationException("Node does not belong to the deque.");
}
Ex.ThrowIfEmpty(IsEmpty(), "Deque is empty.");
count--;
node.owner = null;
if (node == head && node == tail)
{
head = tail = null;
}
else if (node == head)
{
head = head.next;
node.next = head.prev = null;
}
else if (node == tail)
{
tail = tail.prev;
tail.next = node.prev = null;
}
else
{
node.prev.next = node.next;
node.next.prev = node.prev;
node.next = node.prev = null;
}
}
/// <summary>
/// Throws exception if <paramref name="x"/> is out of range (uint).
/// </summary>
/// <param name="x">Input.</param>
/// <param name="exMessage">Exception message.</param>
/// <param name="minRange">Min range value.</param>
/// <param name="maxRange">Max range value.</param>
/// <returns>Input.</returns>
public static uint ThrowIfArgumentOutOfRange(this uint x, string exMessage = "",
uint minRange = 0, uint maxRange = uint.MaxValue)
{
Ex.ThrowIfArgumentOutOfRange(x <minRange || x> maxRange,
exMessage);
return(x);
}
/// <summary>
/// Dequeues head from hashqueue.
/// </summary>
public T Dequeue()
{
Ex.ThrowIfEmpty(IsEmpty(), "HashQueue is empty.");
var x = dq.Dequeue();
DeleteFromMap(x);
return(x);
}
/// <summary>
/// Deletes given <paramref name="x"/> from hashqueue.
/// Returns true if successful.
/// </summary>
public bool Delete(T x)
{
Ex.ThrowIfEmpty(IsEmpty(), "HashQueue is empty.");
x.ThrowIfArgumentNull(nameof(x));
if (!Has(x))
{
return(false);
}
dq.Delete(DeleteFromMap(x));
return(true);
}
/// <summary>
/// Dequeues head from deque.
/// </summary>
public T Dequeue()
{
Ex.ThrowIfEmpty(IsEmpty(), "Deque is empty.");
count--;
var node = head;
node.owner = null;
if (head == tail)
{
head = tail = null;
}
else
{
head = head.next;
node.next = head.prev = null;
}
return(node.Value);
}
/// <summary>
/// Toggles <paramref name="n"/>.
/// </summary>
public void Toggle(int n)
{
Ex.ThrowIfArgumentOutOfRange(!(0 <= n && n <= Max), nameof(n));
Toggle((uint)n);
}
/// <summary>
/// Removes <paramref name="n"/>.
/// </summary>
/// <returns>Returns true if removed else false.</returns>
public bool Remove(int n)
{
Ex.ThrowIfArgumentOutOfRange(!(0 <= n && n <= Max), nameof(n));
return(Remove((uint)n));
}
/// <summary>
/// Peeks tail of hashqueue.
/// </summary>
public T PeekTail()
{
Ex.ThrowIfEmpty(IsEmpty(), "HashQueue is empty.");
return(dq.PeekTail());
}
/// <summary>
/// Peeks tail of deque.
/// </summary>
public T PeekTail()
{
Ex.ThrowIfEmpty(IsEmpty(), "Deque is empty.");
return(tail.Value);
}
/// <summary>
/// Peeks head of deque.
/// </summary>
public T Peek()
{
Ex.ThrowIfEmpty(IsEmpty(), "Deque is empty.");
return(head.Value);
}
/// <summary>
/// Throws exception if the string argument is null or empty.
/// </summary>
/// <param name="s">Input.</param>
/// <param name="exMessage">Exception message.</param>
/// <returns>Input.</returns>
public static string ThrowIfNullOrEmptyArgument(this string s, string exMessage = "")
{
Ex.ThrowIfArgumentNull(s == null, exMessage);
Ex.ThrowIfEmpty(s.Length == 0, exMessage);
return(s);
}
/// <summary>
/// Throws exception if <paramref name="t"/> argument is null.
/// </summary>
/// <param name="t">Input.</param>
/// <param name="exMessage">Exception message.</param>
/// <returns>Input.</returns>
public static T ThrowIfArgumentNull <T>(this T t, string exMessage = "")
{
Ex.ThrowIfArgumentNull(t == null, exMessage);
return(t);
}
/// <summary>
/// Throws exception if the string is null or whitespace.
/// </summary>
/// <param name="s">Input.</param>
/// <param name="exMessage">Exception message.</param>
/// <returns>Input.</returns>
public static string ThrowIfNullOrWhiteSpace(this string s, string exMessage = "")
{
Ex.ThrowIfNull(s == null, exMessage);
Ex.ThrowIfEmpty(s.Trim().Length == 0, exMessage);
return(s);
}
