//-------------------------------------------------------------------------------------------------------

// Copyright (C) Microsoft. All rights reserved.

// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.

//-------------------------------------------------------------------------------------------------------

#pragma once

class MessageBase

{

private:

unsigned int m_time;

unsigned int m_id;

static unsigned int s_messageCount;

MessageBase(const MessageBase&);

public:

MessageBase(unsigned int time) : m_time(time), m_id(s_messageCount++) { }

virtual ~MessageBase() { }

void BeginTimer() { m_time += GetTickCount(); };

unsigned int GetTime() { return m_time; };

unsigned int GetId() { return m_id; };

virtual HRESULT Call(LPCSTR fileName) = 0;

};

template <typename T>

class SortedList

{

template <typename T>

struct DListNode

{

T data;

DListNode<T>* prev;

DListNode<T>* next;

public:

DListNode(const T& data) :

data(data),

prev(nullptr),

next(nullptr)

{ }

};

public:

SortedList():

head(nullptr)

{

}

~SortedList()

{

while (head != nullptr)

{

Remove(head);

}

}

// Scan through the sorted list

// Insert before the first node that satisfies the LessThan function

// This function maintains the invariant that the list is always sorted

void Insert(const T& data)

{

DListNode<T>* curr = head;

DListNode<T>* node = new DListNode<T>(data);

DListNode<T>* prev = nullptr;

// Now, if we have to insert, we have to insert *after* some node

while (curr != nullptr)

{

if (T::LessThan(data, curr->data))

{

break;

}

prev = curr;

curr = curr->next;

}

InsertAfter(node, prev);

}

T Pop()

{

T data = head->data;

Remove(head);

return data;

}

template <typename PredicateFn>

void Remove(PredicateFn fn)

{

DListNode<T>* node = head;

while (node != nullptr)

{

if (fn(node->data))

{

Remove(node);

return;

}

}

}

bool IsEmpty()

{

return head == nullptr;

}

private:

void Remove(DListNode<T>* node)

{

if (node->prev == nullptr)

{

head = node->next;

}

else

{

node->prev->next = node->next;

}

if (node->next != nullptr)

{

node->next->prev = node->prev;

}

delete node;

}

void InsertAfter(DListNode<T>* newNode, DListNode<T>* node)

{

// If the list is empty, just set head to newNode

if (head == nullptr)

{

Assert(node == nullptr);

head = newNode;

return;

}

// If node is null here, we must be trying to insert before head

if (node == nullptr)

{

newNode->next = head;

head->prev = newNode;

head = newNode;

return;

}

Assert(node);

newNode->next = node->next;

newNode->prev = node;

if (node->next)

{

node->next->prev = newNode;

}

node->next = newNode;

}

DListNode<T>* head;

};

class MessageQueue

{

struct ListEntry

{

unsigned int time;

MessageBase* message;

ListEntry(unsigned int time, MessageBase* message):

time(time),

message(message)

{ }

static bool LessThan(const ListEntry& first, const ListEntry& second)

{

return first.time < second.time;

}

};

SortedList<ListEntry> m_queue;

public:

void InsertSorted(MessageBase *message)

{

message->BeginTimer();

unsigned int time = message->GetTime();

m_queue.Insert(ListEntry(time, message));

}

MessageBase* PopAndWait()

{

Assert(!m_queue.IsEmpty());

ListEntry entry = m_queue.Pop();

MessageBase *tmp = entry.message;

int waitTime = tmp->GetTime() - GetTickCount();

if(waitTime > 0)

{

Sleep(waitTime);

}

return tmp;

}

bool IsEmpty()

{

return m_queue.IsEmpty();

}

void RemoveById(unsigned int id)

{

// Search for the message with the correct id, and delete it. Can be updated

// to a hash to improve speed, if necessary.

m_queue.Remove([id](const ListEntry& entry)

{

MessageBase *msg = entry.message;

if(msg->GetId() == id)

{

delete msg;

return true;

}

return false;

});

}

void RemoveAll()

{

m_queue.Remove([](const ListEntry& entry) {

MessageBase* msg = entry.message;

delete msg;

return true;

});

}

HRESULT ProcessAll(LPCSTR fileName)

{

while(!IsEmpty())

{

MessageBase *msg = PopAndWait();

// Omit checking return value for async function, since it shouldn't affect others.

msg->Call(fileName);

delete msg;

ChakraRTInterface::JsTTDNotifyYield();

}

return S_OK;

}

};

//

// A custom message helper class to assist defining messages handled by callback functions.

//

template <class Func, class CustomBase>

class CustomMessage : public CustomBase

{

private:

Func m_func;

public:

CustomMessage(unsigned int time, JsValueRef customArg, const Func& func) :

CustomBase(time, customArg), m_func(func)

{}

virtual HRESULT Call(LPCSTR fileName) override

{

return m_func(*this);

}

};