public MeCabNode Next()
{
while (this.agenda.Count != 0)
{
QueueElement top = this.agenda.Pop();
MeCabNode rNode = top.Node;
if (rNode.Stat == MeCabNodeStat.Bos)
{
for (QueueElement n = top; n.Next != null; n = n.Next)
{
n.Node.Next = n.Next.Node; // change next & prev
n.Next.Node.Prev = n.Node;
}
return(rNode);
}
for (MeCabPath path = rNode.LPath; path != null; path = path.LNext)
{
QueueElement n = new QueueElement()
{
Node = path.LNode,
Gx = path.Cost + top.Gx,
Fx = path.LNode.Cost + path.Cost + top.Gx,
Next = top
};
this.agenda.Push(n);
}
}
return(null);
}
public MeCabNode Next()
{
while (this.agenda.Count != 0)
{
QueueElement queueElement = this.agenda.Pop();
MeCabNode node = queueElement.Node;
if (node.Stat == MeCabNodeStat.Bos)
{
QueueElement queueElement2 = queueElement;
while (queueElement2.Next != null)
{
queueElement2.Node.Next = queueElement2.Next.Node;
queueElement2.Next.Node.Prev = queueElement2.Node;
queueElement2 = queueElement2.Next;
}
return(node);
}
for (MeCabPath meCabPath = node.LPath; meCabPath != null; meCabPath = meCabPath.LNext)
{
QueueElement queueElement3 = new QueueElement();
queueElement3.Node = meCabPath.LNode;
queueElement3.Gx = meCabPath.Cost + queueElement.Gx;
queueElement3.Fx = meCabPath.LNode.Cost + meCabPath.Cost + queueElement.Gx;
queueElement3.Next = queueElement;
QueueElement item = queueElement3;
this.agenda.Push(item);
}
}
return(null);
}
/// <summary>
/// Return the oldest value of the queue and remove it.
/// </summary>
public async Task <T> Pop()
{
QueueElement Oldest = _FirstQueueElement;
QueueElement PreOldest = null;
while (Oldest.Next != null)
{
PreOldest = Oldest;
Oldest = Oldest.Next;
}
if (PreOldest != null)
{
PreOldest.Next = null;
Interlocked.Decrement(ref _Count);
}
var OnRemovedLocal = OnRemoved;
if (OnRemovedLocal != null)
{
await Task.WhenAll(OnRemovedLocal.GetInvocationList().
Cast <QueueDelegate>().
Select(e => e(this,
_FirstQueueElement.Value)));
}
return(Oldest.Value);
}
private void ProcessEvaluation(object obj)
{
_parameters.Logger.LogMethodInfo($"{Thread.CurrentThread.Name} {Thread.CurrentThread.ManagedThreadId} thread started.");
CancellationToken token;
try
{
token = (CancellationToken)obj;
}
catch (Exception ex)
{
_parameters.Logger.LogMethodError($"Arrived parameter is not {nameof(CancellationToken)}. Exception: {ex}");
return;
}
WaitHandle[] handles = new WaitHandle[] { _queueHandle, token.WaitHandle };
while (true)
{
WaitHandle.WaitAny(handles);
if (token.IsCancellationRequested)
{
_parameters.Logger.LogMethodInfo($"{Thread.CurrentThread.Name} (ID:{Thread.CurrentThread.ManagedThreadId}) thread cancelled.");
break;
}
while (true)
{
if (token.IsCancellationRequested)
{
_parameters.Logger.LogMethodInfo($"{Thread.CurrentThread.Name} (ID:{Thread.CurrentThread.ManagedThreadId}) thread cancelled.");
break;
}
QueueElement item = null;
lock (_queueLockObj)
{
if (_processorQueue.Count > 0)
{
_parameters.Logger.LogTrace("New queue element arrived!");
item = _processorQueue.Dequeue();
}
else
{
break;
}
}
if (item == null)
{
_parameters.Logger.LogMethodError("Started to process item, but it is null");
continue;
}
Evaluate(item);
}
}
}
/// <summary>
/// Push a new value into the queue.
/// </summary>
/// <param name="Value">The value.</param>
public async Task <QueueElement> Push(T Value)
{
var NewQueueElement = new QueueElement(Value);
QueueElement OldFirst;
do
{
OldFirst = First;
NewQueueElement.Next = OldFirst;
}while (Interlocked.CompareExchange(ref _FirstQueueElement, NewQueueElement, OldFirst) != OldFirst);
Interlocked.Increment(ref _Count);
// Multiple concurrent threads might remove more than expected!
// But it is assumed, that this is not a problem to anyone.
while ((UInt64)_Count > MaxNumberOfElements)
{
await Pop();
}
var OnAddedLocal = OnAdded;
if (OnAddedLocal != null)
{
await Task.WhenAll(OnAddedLocal.GetInvocationList().
Cast <QueueDelegate>().
Select(e => e(this,
Value)));
}
return(NewQueueElement);
}
public void Enque(QueueElement qe)
{
if (Count == 0)
{
List.Add(qe);
}
else
{
var start = 0;
var end = Count;
var i = (end - start) / 2;
while (end - start > 0)
{
if (qe.Weight > List[i].Weight)
{
start = i + 1;
i = (end - start) / 2 + start;
}
else
{
end = i;
i = (end - start) / 2;
}
}
List.Insert(start, qe);
}
}
public void Enqueue(int value, int priority)
{
if (this.tail == null)
{
this.tail = new QueueElement(value, priority, null);
}
else
{
if (tail.Priority < priority)
{
QueueElement exTail = this.tail;
this.tail = new QueueElement(value, priority, exTail);
return;
}
QueueElement temp = this.tail;
QueueElement after;
while (temp.Priority >= priority)
{
after = temp;
if (temp.Previous == null)
{
temp.Previous = new QueueElement(value, priority, null);
return;
}
temp = temp.Previous;
}
QueueElement newElement = new QueueElement(value, priority, temp);
after.Previous = newElement;
}
}
/// <summary>
/// The enqueue.
/// </summary>
/// <param name="item">
/// The item.
/// </param>
public Status Enqueue(string item)
{
if (this.count == BufferLen)
{
Trace.Error("Queue is full. Dropping item.");
return(Status.Full);
}
if (false == this.enabled)
{
Trace.Error("Queue in purge. Dropping item.");
return(Status.Purge);
;
}
// Create a new queue item with a unique id
var queueItem = new QueueElement(Interlocked.Increment(ref this.currentIndex), item);
this.buffer[queueItem.Id % BufferLen] = queueItem;
Interlocked.Increment(ref this.count);
this.semaphore.Release();
Trace.Info($"Item pushed to {this.name}, current count {this.count}");
if (BufferLen - this.count < 100)
{
Trace.Warning($"{this.name} length {this.count} approaching maximum: {BufferLen}");
}
return(Status.Success);
}
/// <summary>
/// replaces an enqueued request with an updated version of that request. Is the old request not found, then the replacement will be added normaly,
/// </summary>
/// <param name="toReplace"></param>
/// <param name="replacement"></param>
public void Replace(IPdfRequest toReplace, IPdfRequest replacement)
{
lock (synchronisationLock)
{
if (firstElement == null || firstElement.value.Priority < replacement.Priority)
{
firstElement = new QueueElement <IPdfRequest>(replacement, firstElement);
Monitor.Pulse(synchronisationLock);
}
else if (firstElement.value == toReplace)
{
firstElement.value = replacement;
}
else
{
QueueElement <IPdfRequest> element = firstElement;
while (element.next != null && element.next.value.Priority >= toReplace.Priority && element.next.value != toReplace)
{
element = element.next;
}
if (element.next != null && element.next.value == toReplace)
{
element.next.value = replacement;
}
else
{
element.next = new QueueElement <IPdfRequest>(replacement, element.next);
Monitor.Pulse(synchronisationLock);
}
}
}
}
public override String ToString()
{
QueueElement iterator = first;
StringBuilder builder = new StringBuilder();
builder.Append("[");
if (iterator != null)
{
builder.Append(" ");
builder.Append(iterator.GetPriority());
builder.Append(". ");
builder.Append(iterator.GetData());
iterator = iterator.GetPrev();
while (iterator != null)
{
builder.Append(", ");
builder.Append(iterator.GetPriority());
builder.Append(". ");
builder.Append(iterator.GetData());
iterator = iterator.GetPrev();
}
builder.Append(" ");
}
builder.Append("]");
return(builder.ToString());
}
public static async Task HandleMessage <T>(QueueElement <T> message)
{
Console.WriteLine("Message received through HandleMessage()");
var imageUrl = "";
//var message = await serviceBus.GetMessage<QueueElement<object>>(m);
switch (message.Type)
{
case "TelemetrySend": // FROM OTHER WORKER
var telemetrySendModel = ForceCast <Telemetry>(message.Data);
telemetryRepository.Insert(telemetrySendModel);
break;
case "ActivityClose": // TO WORKER TRIO
var closeData = ForceCast <QueueElement <ActivityIdViewModel> >(message);
activityRepository.Close(closeData.Data.Id);
//--
closeData.Data.FromOrganizer = true;
await queueToOtherWorker.SendMessage(closeData);
//--
break;
case "ActivityStart":
var startData = ForceCast <QueueElement <ActivityIdViewModel> >(message); // GetValue<int>(message.Data);
activityRepository.Start(startData.Data.Id);
//--
startData.Data.FromOrganizer = true;
await queueToOtherWorker.SendMessage(startData);
//--
break;
case "ActivityCreate":
var activityCreateModel = ForceCast <ActivityCreateViewModel>(message.Data);
activityRepository.Insert(new Activity()
{
// Id = 0,
CreationDate = DateTime.Now,
EndDate = null,
Location = activityCreateModel.Location,
Name = activityCreateModel.Name,
RaceUrl = "", //$"https://localhost/raceSample/{new Random().Next(0, 1000)}",
IdUser = activityCreateModel.IdUser,
Status = 0,
Type = activityCreateModel.Type,
});
break;
case "ActivityJoin":
var activityJoinModel = ForceCast <ActivityIdViewModel>(message.Data);
activityRepository.AddRunner(
activityJoinModel.Id,
activityJoinModel.IdUser
);
break;
}
}
/// <summary>
/// Tests the functionality of the queue passed in.
/// </summary>
/// <param name="queue">The queue.</param>
/// <param name="numberOfElements">The number of elements.</param>
/// <param name="performEnumerateTest">if set to <c>true</c> [perform enumerate test].</param>
private static void PriorityQueueFunctionalityTest(PriorityQueueBase <QueueElement> queue, int numberOfElements, bool performEnumerateTest)
{
// create list of random priorities.
List <int> priorities = new List <int>();
Random rand = new Random(unchecked ((int)DateTime.Now.Ticks));
for (int i = 0; i < numberOfElements; i++)
{
priorities.Add(rand.Next(numberOfElements));
}
// fill queue with elements
for (int i = 0; i < numberOfElements; i++)
{
// add a new element to the queue, with a random priority from the list and a value.
queue.Add(new QueueElement(priorities[i], "Value: " + i));
}
Assert.AreEqual(numberOfElements, queue.Count);
// sort the priorities, descending, so we know the highest priority
priorities.Sort(SortAlgorithm.ShellSort, SortDirection.Descending);
// check if peek reveals the highest priority
QueueElement highestPriorityElement = queue.Peek();
Assert.IsNotNull(highestPriorityElement);
Assert.AreEqual(priorities[0], highestPriorityElement.Priority);
QueueElement current;
QueueElement previous;
if (performEnumerateTest)
{
// test the enumerator to see if it gives back the elements in the right order
current = highestPriorityElement;
foreach (QueueElement element in queue)
{
previous = current;
current = element;
Assert.IsTrue(previous.Priority >= current.Priority);
}
}
// now remove all elements one by one. Each element has to have a lower (or equal) priority than the one before it.
previous = queue.Remove();
current = queue.Remove();
while (current != null)
{
Assert.IsTrue(previous.Priority >= current.Priority);
previous = current;
current = queue.Remove();
}
// queue is now empty
Assert.AreEqual(0, queue.Count);
Assert.IsNull(queue.Peek());
}
private bool CreateNextEnemies(bool atStart)
{
if (_queue.Count == 0)
{
return(false);
}
//TODO намагаємось заспавнити ворогів на поле (Enemies.cs) якщо ділей = 0 і є вільні слоти
bool added = false;
bool continueAdding = true;
// TODO можливо якщо жодного ворога немає - пришвидшуєм чергу, щоб не втикати довго
if (Consts.ADD_ENAMY_ON_NO_ENEMIES_LEFT && _enemies.NoEnemiesLeft())
{
QueueElement element = _queue[0];
element.Delay = 0;
_queue[0] = element;
}
// намагаємось додати
do
{
if (_queue.Count == 0)
{
break;
}
if (_queue[0].Delay <= 0)
{
continueAdding = _queue[0].Delay < 0; // якщо < 0 (-1), то продовжуєм додавати (на старті так треба ставити), якщо 0 - стоп, один новий ворог за хід
if (_enemies.TryToAddEnemy(_queue[0]))
{
// додали вдало
added = true;
_queue.RemoveAt(0);
}
else
{
// не було слота
continueAdding = false;
}
}
else
{
// ще не час додавати
continueAdding = false;
}
} while (continueAdding);
//
if (_queue.Count == 0)
{
HideQueue(atStart);
}
else
{
SetNextEnemy(atStart);
}
//
return(added);
}
private static void EnqueueChild(LinkedList<QueueElement> childrenQueue, QueueElement nextChildNode, int precedents)
{
if (precedents > 1)
{
nextChildNode.PrecedentCount = 1;
childrenQueue.AddLast(nextChildNode);
}
}
private async Task DelayChat(QueueElement element)
{
var limiter = GetChatLimiter(element);
await limiter.Wait();
await DelayBase(element);
}
private async Task DelayGroup(QueueElement element)
{
var limiter = GetGroupLimiter(element);
await limiter.Wait();
await DelayChat(element);
}
private static void EnqueueChild(LinkedList <QueueElement> childrenQueue, QueueElement nextChildNode, int precedents)
{
if (precedents > 1)
{
nextChildNode.PrecedentCount = 1;
childrenQueue.AddLast(nextChildNode);
}
}
private async Task GetPermission(string target)
{
var element = new QueueElement
{
Target = target
};
await Delay(element);
}
internal QueueElement(QueueElement head, AVLNode linkedNode)
{
this.linkedNode = linkedNode;
next = head.next;
head.next.previous = this;
previous = head;
head.next = this;
}
public QueueElement Add(int value)
{
int insertedIdx = _size;
_size++;
_heap[insertedIdx] = new QueueElement(insertedIdx, int.MaxValue);
return(Decrease(insertedIdx, value));
}
/// <summary>
/// Checks if two objects are the same
/// </summary>
/// <param name="obj">Target object to compare</param>
/// <returns></returns>
public override bool Equals(object obj)
{
if (obj is QueueElement)
{
QueueElement el = (QueueElement)obj;
return(el.Url == Url && el.Destination == Destination && el.Completed == Completed && el.Id == Id);
}
return(false);
}
/// <summary>
/// Меняет значение и приоритеты первого со вторым
/// </summary>
public static void SwapValues(QueueElement first, QueueElement second)
{
int temp = first.value;
first.value = second.value;
second.value = temp;
temp = first.prior;
first.prior = second.prior;
second.prior = temp;
}
public void Enqueue(T el, int priority = 0)
{
Array.Resize(ref queue, ++Size);
for (int i = Size - 1; i > 0; i--)
{
queue[i] = queue[i - 1];
}
queue[0] = new QueueElement(priority, el);
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="eos">末尾の形態素ノード</param>
public NBestGenerator(TNode eos)
{
this.eos = new QueueElement()
{
Node = eos,
Next = null,
Fx = 0,
Gx = 0
};
}
public int Dequeue()
{
if (this.tail == null)
{
throw new EmptyQueueException();
}
int result = this.tail.Value;
this.tail = this.tail.Previous;
return result;
}
internal static void Remove(QueueElement element, QueuedAVLTree <TKey, TValue> tree, bool callFromQueue = false)
{
element.next.previous = element.previous;
element.previous.next = element.next;
if (callFromQueue && element.linkedNode != null)
{
AVLNode.RemoveNode(element.linkedNode, tree, true);
}
}
internal void Clear()
{
first = new QueueElement();
last = new QueueElement();
first.next = last;
last.previous = first;
size = 0;
}
internal void AddGreenLightKeys(QueueElement qEle)
{
if (qEle.WasUsedToGreenLightOrDestroy)
{
return;
}
_passedQueue.Add(qEle.Key);
qEle.WasUsedToGreenLightOrDestroy = true;
}
private static QueueElement DequeueFreeChild(LinkedList<QueueElement> childrenQueue, QueueElement parentNode, int precedents)
{
QueueElement freeChild = childrenQueue
.FirstOrDefault(childNode =>
parentNode.Edges.Count(_ => _ == childNode.Node) <= 0);
if (freeChild == null) return null;
if (++freeChild.PrecedentCount == precedents)
childrenQueue.Remove(freeChild);
return freeChild;
}
private static QueueElement GetOrCreateNode(Dictionary <int, QueueElement> dictionary, int key)
{
if (dictionary.ContainsKey(key))
{
return(dictionary[key]);
}
var node = new QueueElement(key, 0, 0);
dictionary.Add(key, node);
return(node);
}
/// <summary>
/// Get value from queue.
/// </summary>
/// <returns></returns>
public int Dequeue()
{
if (this.IsEmpty())
{
throw new Exception("Queue is empty");
}
int value = this.head.Value;
this.head = this.head.Next;
return value;
}
private async Task Delay(QueueElement element)
{
if (IsGroup(element))
{
await DelayGroup(element);
}
else
{
await DelayChat(element);
}
}
public override String ToString()
{
StringBuilder b = new StringBuilder();
QueueElement <IPdfRequest> current = firstElement;
while (current != null)
{
b.Append(current.value.ToString());
current = current.next;
}
return(b.ToString());
}
/// <summary>
/// Deletes element with highest priority
/// </summary>
/// <returns>Value of deleted element</returns>
public TValue Dequeue()
{
if (Empty)
{
throw new EmptyQueueException();
}
size--;
var result = head.Value;
head = head.Next;
return(result);
}
public int CompareTo(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return(0);
}
else
{
QueueElement <TValue> b = (QueueElement <TValue>)obj;
return(priority.CompareTo(b.priority));
}
}
/// <summary>
/// Inser to queue.
/// </summary>
/// <param name="value">Value to be insert.</param>
/// <param name="priority">This priority.</param>
public void Enqueue(int value, int priority)
{
if (this.IsEmpty())
{
this.head = new QueueElement(value, priority);
return;
}
QueueElement tempElement = this.head;
if (tempElement.Next == null)
{
if (priority > this.head.Priority)
{
var element = this.head;
var thisElement = new QueueElement(value, priority);
this.head = thisElement;
this.head.Next = element;
return;
}
else
{
this.head.Next = new QueueElement(value, priority);
return;
}
}
QueueElement tempElementPrevious = this.head;
while (tempElement.Priority >= priority)
{
if (tempElement.Next == null)
{
break;
}
if (tempElement.Next.Priority >= priority)
tempElementPrevious = tempElementPrevious.Next;
tempElement = tempElement.Next;
}
QueueElement newElement = new QueueElement(value, priority);
tempElementPrevious.Next = newElement;
newElement = tempElement.Next;
}
private static void EnqueueParent(Queue<QueueElement> parentQueue, QueueElement nextChildNode)
{
parentQueue.Enqueue(nextChildNode);
}
public QueueElement(int value, int priority, QueueElement previous)
{
this.Value = value;
this.Priority = priority;
this.Previous = previous;
}
public Queue()
{
this.tail = null;
}
private static QueueElement GetOrCreateNode(Dictionary<int, QueueElement> dictionary, int key)
{
if (dictionary.ContainsKey(key))
return dictionary[key];
var node = new QueueElement(key, 0, 0);
dictionary.Add(key, node);
return node;
}
