Core/BuildSystem: Merge collision, debugging, threading, utilities and configuration into "common" which does not depend on shared anymore and moved database out of shared library

These changes enables to build tools only without even having MySQL installed

1 files changed, 0 insertions, 229 deletions

diff --git a/src/server/shared/Utilities/TaskScheduler.cpp b/src/server/shared/Utilities/TaskScheduler.cpp
deleted file mode 100644
index 801cc96cf77..00000000000
--- a/src/server/shared/Utilities/TaskScheduler.cpp
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
- * Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "TaskScheduler.h"
-
-TaskScheduler& TaskScheduler::ClearValidator()
-{
-    _predicate = EmptyValidator;
-    return *this;
-}
-
-TaskScheduler& TaskScheduler::Update(success_t const& callback)
-{
-    _now = clock_t::now();
-    Dispatch(callback);
-    return *this;
-}
-
-TaskScheduler& TaskScheduler::Update(size_t const milliseconds, success_t const& callback)
-{
-    return Update(std::chrono::milliseconds(milliseconds), callback);
-}
-
-TaskScheduler& TaskScheduler::Async(std::function<void()> const& callable)
-{
-    _asyncHolder.push(callable);
-    return *this;
-}
-
-TaskScheduler& TaskScheduler::CancelAll()
-{
-    /// Clear the task holder
-    _task_holder.Clear();
-    _asyncHolder = AsyncHolder();
-    return *this;
-}
-
-TaskScheduler& TaskScheduler::CancelGroup(group_t const group)
-{
-    _task_holder.RemoveIf([group](TaskContainer const& task) -> bool
-    {
-        return task->IsInGroup(group);
-    });
-    return *this;
-}
-
-TaskScheduler& TaskScheduler::CancelGroupsOf(std::vector<group_t> const& groups)
-{
-    std::for_each(groups.begin(), groups.end(),
-        std::bind(&TaskScheduler::CancelGroup, this, std::placeholders::_1));
-
-    return *this;
-}
-
-TaskScheduler& TaskScheduler::InsertTask(TaskContainer task)
-{
-    _task_holder.Push(std::move(task));
-    return *this;
-}
-
-void TaskScheduler::Dispatch(success_t const& callback)
-{
-    // If the validation failed abort the dispatching here.
-    if (!_predicate())
-        return;
-
-    // Process all asyncs
-    while (!_asyncHolder.empty())
-    {
-        _asyncHolder.front()();
-        _asyncHolder.pop();
-
-        // If the validation failed abort the dispatching here.
-        if (!_predicate())
-            return;
-    }
-
-    while (!_task_holder.IsEmpty())
-    {
-        if (_task_holder.First()->_end > _now)
-            break;
-
-        // Perfect forward the context to the handler
-        // Use weak references to catch destruction before callbacks.
-        TaskContext context(_task_holder.Pop(), std::weak_ptr<TaskScheduler>(self_reference));
-
-        // Invoke the context
-        context.Invoke();
-
-        // If the validation failed abort the dispatching here.
-        if (!_predicate())
-            return;
-    }
-
-    // On finish call the final callback
-    callback();
-}
-
-void TaskScheduler::TaskQueue::Push(TaskContainer&& task)
-{
-    container.insert(task);
-}
-
-auto TaskScheduler::TaskQueue::Pop() -> TaskContainer
-{
-    TaskContainer result = *container.begin();
-    container.erase(container.begin());
-    return result;
-}
-
-auto TaskScheduler::TaskQueue::First() const -> TaskContainer const&
-{
-    return *container.begin();
-}
-
-void TaskScheduler::TaskQueue::Clear()
-{
-    container.clear();
-}
-
-void TaskScheduler::TaskQueue::RemoveIf(std::function<bool(TaskContainer const&)> const& filter)
-{
-    for (auto itr = container.begin(); itr != container.end();)
-        if (filter(*itr))
-            itr = container.erase(itr);
-        else
-            ++itr;
-}
-
-void TaskScheduler::TaskQueue::ModifyIf(std::function<bool(TaskContainer const&)> const& filter)
-{
-    std::vector<TaskContainer> cache;
-    for (auto itr = container.begin(); itr != container.end();)
-        if (filter(*itr))
-        {
-            cache.push_back(*itr);
-            itr = container.erase(itr);
-        }
-        else
-            ++itr;
-
-    container.insert(cache.begin(), cache.end());
-}
-
-bool TaskScheduler::TaskQueue::IsEmpty() const
-{
-    return container.empty();
-}
-
-TaskContext& TaskContext::Dispatch(std::function<TaskScheduler&(TaskScheduler&)> const& apply)
-{
-    if (auto const owner = _owner.lock())
-        apply(*owner);
-
-    return *this;
-}
-
-bool TaskContext::IsExpired() const
-{
-    return _owner.expired();
-}
-
-bool TaskContext::IsInGroup(TaskScheduler::group_t const group) const
-{
-    return _task->IsInGroup(group);
-}
-
-TaskContext& TaskContext::SetGroup(TaskScheduler::group_t const group)
-{
-    _task->_group = group;
-    return *this;
-}
-
-TaskContext& TaskContext::ClearGroup()
-{
-    _task->_group = boost::none;
-    return *this;
-}
-
-TaskScheduler::repeated_t TaskContext::GetRepeatCounter() const
-{
-    return _task->_repeated;
-}
-
-TaskContext& TaskContext::Async(std::function<void()> const& callable)
-{
-    return Dispatch(std::bind(&TaskScheduler::Async, std::placeholders::_1, callable));
-}
-
-TaskContext& TaskContext::CancelAll()
-{
-    return Dispatch(std::mem_fn(&TaskScheduler::CancelAll));
-}
-
-TaskContext& TaskContext::CancelGroup(TaskScheduler::group_t const group)
-{
-    return Dispatch(std::bind(&TaskScheduler::CancelGroup, std::placeholders::_1, group));
-}
-
-TaskContext& TaskContext::CancelGroupsOf(std::vector<TaskScheduler::group_t> const& groups)
-{
-    return Dispatch(std::bind(&TaskScheduler::CancelGroupsOf, std::placeholders::_1, std::cref(groups)));
-}
-
-void TaskContext::AssertOnConsumed() const
-{
-    // This was adapted to TC to prevent static analysis tools from complaining.
-    // If you encounter this assertion check if you repeat a TaskContext more then 1 time!
-    ASSERT(!(*_consumed) && "Bad task logic, task context was consumed already!");
-}
-
-void TaskContext::Invoke()
-{
-    _task->_task(*this);
-}