lots of stuff idk

25 files changed, 2780 insertions, 2780 deletions

diff --git a/NorthstarDLL/include/spdlog/details/backtracer-inl.h b/NorthstarDLL/include/spdlog/details/backtracer-inl.h
index 00a4461e..21553c26 100644
--- a/NorthstarDLL/include/spdlog/details/backtracer-inl.h
+++ b/NorthstarDLL/include/spdlog/details/backtracer-inl.h
@@ -1,69 +1,69 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#ifndef SPDLOG_HEADER_ONLY

-#include <spdlog/details/backtracer.h>

-#endif

-namespace spdlog {

-namespace details {

-SPDLOG_INLINE backtracer::backtracer(const backtracer &other)

-{

-    std::lock_guard<std::mutex> lock(other.mutex_);

-    enabled_ = other.enabled();

-    messages_ = other.messages_;

-}

-

-SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT

-{

-    std::lock_guard<std::mutex> lock(other.mutex_);

-    enabled_ = other.enabled();

-    messages_ = std::move(other.messages_);

-}

-

-SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other)

-{

-    std::lock_guard<std::mutex> lock(mutex_);

-    enabled_ = other.enabled();

-    messages_ = std::move(other.messages_);

-    return *this;

-}

-

-SPDLOG_INLINE void backtracer::enable(size_t size)

-{

-    std::lock_guard<std::mutex> lock{mutex_};

-    enabled_.store(true, std::memory_order_relaxed);

-    messages_ = circular_q<log_msg_buffer>{size};

-}

-

-SPDLOG_INLINE void backtracer::disable()

-{

-    std::lock_guard<std::mutex> lock{mutex_};

-    enabled_.store(false, std::memory_order_relaxed);

-}

-

-SPDLOG_INLINE bool backtracer::enabled() const

-{

-    return enabled_.load(std::memory_order_relaxed);

-}

-

-SPDLOG_INLINE void backtracer::push_back(const log_msg &msg)

-{

-    std::lock_guard<std::mutex> lock{mutex_};

-    messages_.push_back(log_msg_buffer{msg});

-}

-

-// pop all items in the q and apply the given fun on each of them.

-SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun)

-{

-    std::lock_guard<std::mutex> lock{mutex_};

-    while (!messages_.empty())

-    {

-        auto &front_msg = messages_.front();

-        fun(front_msg);

-        messages_.pop_front();

-    }

-}

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/backtracer.h>
+#endif
+namespace spdlog {
+namespace details {
+SPDLOG_INLINE backtracer::backtracer(const backtracer &other)
+{
+    std::lock_guard<std::mutex> lock(other.mutex_);
+    enabled_ = other.enabled();
+    messages_ = other.messages_;
+}
+
+SPDLOG_INLINE backtracer::backtracer(backtracer &&other) SPDLOG_NOEXCEPT
+{
+    std::lock_guard<std::mutex> lock(other.mutex_);
+    enabled_ = other.enabled();
+    messages_ = std::move(other.messages_);
+}
+
+SPDLOG_INLINE backtracer &backtracer::operator=(backtracer other)
+{
+    std::lock_guard<std::mutex> lock(mutex_);
+    enabled_ = other.enabled();
+    messages_ = std::move(other.messages_);
+    return *this;
+}
+
+SPDLOG_INLINE void backtracer::enable(size_t size)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    enabled_.store(true, std::memory_order_relaxed);
+    messages_ = circular_q<log_msg_buffer>{size};
+}
+
+SPDLOG_INLINE void backtracer::disable()
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    enabled_.store(false, std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE bool backtracer::enabled() const
+{
+    return enabled_.load(std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE void backtracer::push_back(const log_msg &msg)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    messages_.push_back(log_msg_buffer{msg});
+}
+
+// pop all items in the q and apply the given fun on each of them.
+SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const details::log_msg &)> fun)
+{
+    std::lock_guard<std::mutex> lock{mutex_};
+    while (!messages_.empty())
+    {
+        auto &front_msg = messages_.front();
+        fun(front_msg);
+        messages_.pop_front();
+    }
+}
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/backtracer.h b/NorthstarDLL/include/spdlog/details/backtracer.h
index 70a85ea4..1da5d4c7 100644
--- a/NorthstarDLL/include/spdlog/details/backtracer.h
+++ b/NorthstarDLL/include/spdlog/details/backtracer.h
@@ -1,45 +1,45 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#include <spdlog/details/log_msg_buffer.h>

-#include <spdlog/details/circular_q.h>

-

-#include <atomic>

-#include <mutex>

-#include <functional>

-

-// Store log messages in circular buffer.

-// Useful for storing debug data in case of error/warning happens.

-

-namespace spdlog {

-namespace details {

-class SPDLOG_API backtracer

-{

-    mutable std::mutex mutex_;

-    std::atomic<bool> enabled_{false};

-    circular_q<log_msg_buffer> messages_;

-

-public:

-    backtracer() = default;

-    backtracer(const backtracer &other);

-

-    backtracer(backtracer &&other) SPDLOG_NOEXCEPT;

-    backtracer &operator=(backtracer other);

-

-    void enable(size_t size);

-    void disable();

-    bool enabled() const;

-    void push_back(const log_msg &msg);

-

-    // pop all items in the q and apply the given fun on each of them.

-    void foreach_pop(std::function<void(const details::log_msg &)> fun);

-};

-

-} // namespace details

-} // namespace spdlog

-

-#ifdef SPDLOG_HEADER_ONLY

-#include "backtracer-inl.h"

-#endif
\ No newline at end of file
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg_buffer.h>
+#include <spdlog/details/circular_q.h>
+
+#include <atomic>
+#include <mutex>
+#include <functional>
+
+// Store log messages in circular buffer.
+// Useful for storing debug data in case of error/warning happens.
+
+namespace spdlog {
+namespace details {
+class SPDLOG_API backtracer
+{
+    mutable std::mutex mutex_;
+    std::atomic<bool> enabled_{false};
+    circular_q<log_msg_buffer> messages_;
+
+public:
+    backtracer() = default;
+    backtracer(const backtracer &other);
+
+    backtracer(backtracer &&other) SPDLOG_NOEXCEPT;
+    backtracer &operator=(backtracer other);
+
+    void enable(size_t size);
+    void disable();
+    bool enabled() const;
+    void push_back(const log_msg &msg);
+
+    // pop all items in the q and apply the given fun on each of them.
+    void foreach_pop(std::function<void(const details::log_msg &)> fun);
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "backtracer-inl.h"
+#endif
diff --git a/NorthstarDLL/include/spdlog/details/circular_q.h b/NorthstarDLL/include/spdlog/details/circular_q.h
index 6d50e014..1f2712e7 100644
--- a/NorthstarDLL/include/spdlog/details/circular_q.h
+++ b/NorthstarDLL/include/spdlog/details/circular_q.h
@@ -1,141 +1,141 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-// circular q view of std::vector.

-#pragma once

-

-#include <vector>

-#include <cassert>

-

-namespace spdlog {

-namespace details {

-template<typename T>

-class circular_q

-{

-    size_t max_items_ = 0;

-    typename std::vector<T>::size_type head_ = 0;

-    typename std::vector<T>::size_type tail_ = 0;

-    size_t overrun_counter_ = 0;

-    std::vector<T> v_;

-

-public:

-    using value_type = T;

-

-    // empty ctor - create a disabled queue with no elements allocated at all

-    circular_q() = default;

-

-    explicit circular_q(size_t max_items)

-        : max_items_(max_items + 1) // one item is reserved as marker for full q

-        , v_(max_items_)

-    {}

-

-    circular_q(const circular_q &) = default;

-    circular_q &operator=(const circular_q &) = default;

-

-    // move cannot be default,

-    // since we need to reset head_, tail_, etc to zero in the moved object

-    circular_q(circular_q &&other) SPDLOG_NOEXCEPT

-    {

-        copy_moveable(std::move(other));

-    }

-

-    circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT

-    {

-        copy_moveable(std::move(other));

-        return *this;

-    }

-

-    // push back, overrun (oldest) item if no room left

-    void push_back(T &&item)

-    {

-        if (max_items_ > 0)

-        {

-            v_[tail_] = std::move(item);

-            tail_ = (tail_ + 1) % max_items_;

-

-            if (tail_ == head_) // overrun last item if full

-            {

-                head_ = (head_ + 1) % max_items_;

-                ++overrun_counter_;

-            }

-        }

-    }

-

-    // Return reference to the front item.

-    // If there are no elements in the container, the behavior is undefined.

-    const T &front() const

-    {

-        return v_[head_];

-    }

-

-    T &front()

-    {

-        return v_[head_];

-    }

-

-    // Return number of elements actually stored

-    size_t size() const

-    {

-        if (tail_ >= head_)

-        {

-            return tail_ - head_;

-        }

-        else

-        {

-            return max_items_ - (head_ - tail_);

-        }

-    }

-

-    // Return const reference to item by index.

-    // If index is out of range 0…size()-1, the behavior is undefined.

-    const T &at(size_t i) const

-    {

-        assert(i < size());

-        return v_[(head_ + i) % max_items_];

-    }

-

-    // Pop item from front.

-    // If there are no elements in the container, the behavior is undefined.

-    void pop_front()

-    {

-        head_ = (head_ + 1) % max_items_;

-    }

-

-    bool empty() const

-    {

-        return tail_ == head_;

-    }

-

-    bool full() const

-    {

-        // head is ahead of the tail by 1

-        if (max_items_ > 0)

-        {

-            return ((tail_ + 1) % max_items_) == head_;

-        }

-        return false;

-    }

-

-    size_t overrun_counter() const

-    {

-        return overrun_counter_;

-    }

-

-private:

-    // copy from other&& and reset it to disabled state

-    void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT

-    {

-        max_items_ = other.max_items_;

-        head_ = other.head_;

-        tail_ = other.tail_;

-        overrun_counter_ = other.overrun_counter_;

-        v_ = std::move(other.v_);

-

-        // put &&other in disabled, but valid state

-        other.max_items_ = 0;

-        other.head_ = other.tail_ = 0;

-        other.overrun_counter_ = 0;

-    }

-};

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+// circular q view of std::vector.
+#pragma once
+
+#include <vector>
+#include <cassert>
+
+namespace spdlog {
+namespace details {
+template<typename T>
+class circular_q
+{
+    size_t max_items_ = 0;
+    typename std::vector<T>::size_type head_ = 0;
+    typename std::vector<T>::size_type tail_ = 0;
+    size_t overrun_counter_ = 0;
+    std::vector<T> v_;
+
+public:
+    using value_type = T;
+
+    // empty ctor - create a disabled queue with no elements allocated at all
+    circular_q() = default;
+
+    explicit circular_q(size_t max_items)
+        : max_items_(max_items + 1) // one item is reserved as marker for full q
+        , v_(max_items_)
+    {}
+
+    circular_q(const circular_q &) = default;
+    circular_q &operator=(const circular_q &) = default;
+
+    // move cannot be default,
+    // since we need to reset head_, tail_, etc to zero in the moved object
+    circular_q(circular_q &&other) SPDLOG_NOEXCEPT
+    {
+        copy_moveable(std::move(other));
+    }
+
+    circular_q &operator=(circular_q &&other) SPDLOG_NOEXCEPT
+    {
+        copy_moveable(std::move(other));
+        return *this;
+    }
+
+    // push back, overrun (oldest) item if no room left
+    void push_back(T &&item)
+    {
+        if (max_items_ > 0)
+        {
+            v_[tail_] = std::move(item);
+            tail_ = (tail_ + 1) % max_items_;
+
+            if (tail_ == head_) // overrun last item if full
+            {
+                head_ = (head_ + 1) % max_items_;
+                ++overrun_counter_;
+            }
+        }
+    }
+
+    // Return reference to the front item.
+    // If there are no elements in the container, the behavior is undefined.
+    const T &front() const
+    {
+        return v_[head_];
+    }
+
+    T &front()
+    {
+        return v_[head_];
+    }
+
+    // Return number of elements actually stored
+    size_t size() const
+    {
+        if (tail_ >= head_)
+        {
+            return tail_ - head_;
+        }
+        else
+        {
+            return max_items_ - (head_ - tail_);
+        }
+    }
+
+    // Return const reference to item by index.
+    // If index is out of range 0…size()-1, the behavior is undefined.
+    const T &at(size_t i) const
+    {
+        assert(i < size());
+        return v_[(head_ + i) % max_items_];
+    }
+
+    // Pop item from front.
+    // If there are no elements in the container, the behavior is undefined.
+    void pop_front()
+    {
+        head_ = (head_ + 1) % max_items_;
+    }
+
+    bool empty() const
+    {
+        return tail_ == head_;
+    }
+
+    bool full() const
+    {
+        // head is ahead of the tail by 1
+        if (max_items_ > 0)
+        {
+            return ((tail_ + 1) % max_items_) == head_;
+        }
+        return false;
+    }
+
+    size_t overrun_counter() const
+    {
+        return overrun_counter_;
+    }
+
+private:
+    // copy from other&& and reset it to disabled state
+    void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT
+    {
+        max_items_ = other.max_items_;
+        head_ = other.head_;
+        tail_ = other.tail_;
+        overrun_counter_ = other.overrun_counter_;
+        v_ = std::move(other.v_);
+
+        // put &&other in disabled, but valid state
+        other.max_items_ = 0;
+        other.head_ = other.tail_ = 0;
+        other.overrun_counter_ = 0;
+    }
+};
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/console_globals.h b/NorthstarDLL/include/spdlog/details/console_globals.h
index acabacd6..665201dd 100644
--- a/NorthstarDLL/include/spdlog/details/console_globals.h
+++ b/NorthstarDLL/include/spdlog/details/console_globals.h
@@ -1,32 +1,32 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#include <spdlog/details/null_mutex.h>

-#include <mutex>

-

-namespace spdlog {

-namespace details {

-

-struct console_mutex

-{

-    using mutex_t = std::mutex;

-    static mutex_t &mutex()

-    {

-        static mutex_t s_mutex;

-        return s_mutex;

-    }

-};

-

-struct console_nullmutex

-{

-    using mutex_t = null_mutex;

-    static mutex_t &mutex()

-    {

-        static mutex_t s_mutex;

-        return s_mutex;

-    }

-};

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <mutex>
+
+namespace spdlog {
+namespace details {
+
+struct console_mutex
+{
+    using mutex_t = std::mutex;
+    static mutex_t &mutex()
+    {
+        static mutex_t s_mutex;
+        return s_mutex;
+    }
+};
+
+struct console_nullmutex
+{
+    using mutex_t = null_mutex;
+    static mutex_t &mutex()
+    {
+        static mutex_t s_mutex;
+        return s_mutex;
+    }
+};
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/file_helper-inl.h b/NorthstarDLL/include/spdlog/details/file_helper-inl.h
index 18f54596..30f3cf55 100644
--- a/NorthstarDLL/include/spdlog/details/file_helper-inl.h
+++ b/NorthstarDLL/include/spdlog/details/file_helper-inl.h
@@ -1,147 +1,147 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#ifndef SPDLOG_HEADER_ONLY

-#include <spdlog/details/file_helper.h>

-#endif

-

-#include <spdlog/details/os.h>

-#include <spdlog/common.h>

-

-#include <cerrno>

-#include <chrono>

-#include <cstdio>

-#include <string>

-#include <thread>

-#include <tuple>

-

-namespace spdlog {

-namespace details {

-

-SPDLOG_INLINE file_helper::~file_helper()

-{

-    close();

-}

-

-SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate)

-{

-    close();

-    filename_ = fname;

-

-    auto *mode = SPDLOG_FILENAME_T("ab");

-    auto *trunc_mode = SPDLOG_FILENAME_T("wb");

-

-    for (int tries = 0; tries < open_tries_; ++tries)

-    {

-        // create containing folder if not exists already.

-        os::create_dir(os::dir_name(fname));

-        if (truncate)

-        {

-            // Truncate by opening-and-closing a tmp file in "wb" mode, always

-            // opening the actual log-we-write-to in "ab" mode, since that

-            // interacts more politely with eternal processes that might

-            // rotate/truncate the file underneath us.

-            std::FILE *tmp;

-            if (os::fopen_s(&tmp, fname, trunc_mode))

-            {

-                continue;

-            }

-            std::fclose(tmp);

-        }

-        if (!os::fopen_s(&fd_, fname, mode))

-        {

-            return;

-        }

-

-        details::os::sleep_for_millis(open_interval_);

-    }

-

-    throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno);

-}

-

-SPDLOG_INLINE void file_helper::reopen(bool truncate)

-{

-    if (filename_.empty())

-    {

-        throw_spdlog_ex("Failed re opening file - was not opened before");

-    }

-    this->open(filename_, truncate);

-}

-

-SPDLOG_INLINE void file_helper::flush()

-{

-    std::fflush(fd_);

-}

-

-SPDLOG_INLINE void file_helper::close()

-{

-    if (fd_ != nullptr)

-    {

-        std::fclose(fd_);

-        fd_ = nullptr;

-    }

-}

-

-SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf)

-{

-    size_t msg_size = buf.size();

-    auto data = buf.data();

-    if (std::fwrite(data, 1, msg_size, fd_) != msg_size)

-    {

-        throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno);

-    }

-}

-

-SPDLOG_INLINE size_t file_helper::size() const

-{

-    if (fd_ == nullptr)

-    {

-        throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_));

-    }

-    return os::filesize(fd_);

-}

-

-SPDLOG_INLINE const filename_t &file_helper::filename() const

-{

-    return filename_;

-}

-

-//

-// return file path and its extension:

-//

-// "mylog.txt" => ("mylog", ".txt")

-// "mylog" => ("mylog", "")

-// "mylog." => ("mylog.", "")

-// "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")

-//

-// the starting dot in filenames is ignored (hidden files):

-//

-// ".mylog" => (".mylog". "")

-// "my_folder/.mylog" => ("my_folder/.mylog", "")

-// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")

-SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname)

-{

-    auto ext_index = fname.rfind('.');

-

-    // no valid extension found - return whole path and empty string as

-    // extension

-    if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1)

-    {

-        return std::make_tuple(fname, filename_t());

-    }

-

-    // treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"

-    auto folder_index = fname.find_last_of(details::os::folder_seps_filename);

-    if (folder_index != filename_t::npos && folder_index >= ext_index - 1)

-    {

-        return std::make_tuple(fname, filename_t());

-    }

-

-    // finally - return a valid base and extension tuple

-    return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));

-}

-

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/file_helper.h>
+#endif
+
+#include <spdlog/details/os.h>
+#include <spdlog/common.h>
+
+#include <cerrno>
+#include <chrono>
+#include <cstdio>
+#include <string>
+#include <thread>
+#include <tuple>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE file_helper::~file_helper()
+{
+    close();
+}
+
+SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate)
+{
+    close();
+    filename_ = fname;
+
+    auto *mode = SPDLOG_FILENAME_T("ab");
+    auto *trunc_mode = SPDLOG_FILENAME_T("wb");
+
+    for (int tries = 0; tries < open_tries_; ++tries)
+    {
+        // create containing folder if not exists already.
+        os::create_dir(os::dir_name(fname));
+        if (truncate)
+        {
+            // Truncate by opening-and-closing a tmp file in "wb" mode, always
+            // opening the actual log-we-write-to in "ab" mode, since that
+            // interacts more politely with eternal processes that might
+            // rotate/truncate the file underneath us.
+            std::FILE *tmp;
+            if (os::fopen_s(&tmp, fname, trunc_mode))
+            {
+                continue;
+            }
+            std::fclose(tmp);
+        }
+        if (!os::fopen_s(&fd_, fname, mode))
+        {
+            return;
+        }
+
+        details::os::sleep_for_millis(open_interval_);
+    }
+
+    throw_spdlog_ex("Failed opening file " + os::filename_to_str(filename_) + " for writing", errno);
+}
+
+SPDLOG_INLINE void file_helper::reopen(bool truncate)
+{
+    if (filename_.empty())
+    {
+        throw_spdlog_ex("Failed re opening file - was not opened before");
+    }
+    this->open(filename_, truncate);
+}
+
+SPDLOG_INLINE void file_helper::flush()
+{
+    std::fflush(fd_);
+}
+
+SPDLOG_INLINE void file_helper::close()
+{
+    if (fd_ != nullptr)
+    {
+        std::fclose(fd_);
+        fd_ = nullptr;
+    }
+}
+
+SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf)
+{
+    size_t msg_size = buf.size();
+    auto data = buf.data();
+    if (std::fwrite(data, 1, msg_size, fd_) != msg_size)
+    {
+        throw_spdlog_ex("Failed writing to file " + os::filename_to_str(filename_), errno);
+    }
+}
+
+SPDLOG_INLINE size_t file_helper::size() const
+{
+    if (fd_ == nullptr)
+    {
+        throw_spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(filename_));
+    }
+    return os::filesize(fd_);
+}
+
+SPDLOG_INLINE const filename_t &file_helper::filename() const
+{
+    return filename_;
+}
+
+//
+// return file path and its extension:
+//
+// "mylog.txt" => ("mylog", ".txt")
+// "mylog" => ("mylog", "")
+// "mylog." => ("mylog.", "")
+// "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")
+//
+// the starting dot in filenames is ignored (hidden files):
+//
+// ".mylog" => (".mylog". "")
+// "my_folder/.mylog" => ("my_folder/.mylog", "")
+// "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
+SPDLOG_INLINE std::tuple<filename_t, filename_t> file_helper::split_by_extension(const filename_t &fname)
+{
+    auto ext_index = fname.rfind('.');
+
+    // no valid extension found - return whole path and empty string as
+    // extension
+    if (ext_index == filename_t::npos || ext_index == 0 || ext_index == fname.size() - 1)
+    {
+        return std::make_tuple(fname, filename_t());
+    }
+
+    // treat cases like "/etc/rc.d/somelogfile or "/abc/.hiddenfile"
+    auto folder_index = fname.find_last_of(details::os::folder_seps_filename);
+    if (folder_index != filename_t::npos && folder_index >= ext_index - 1)
+    {
+        return std::make_tuple(fname, filename_t());
+    }
+
+    // finally - return a valid base and extension tuple
+    return std::make_tuple(fname.substr(0, ext_index), fname.substr(ext_index));
+}
+
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/file_helper.h b/NorthstarDLL/include/spdlog/details/file_helper.h
index b9e87a84..5395d9cb 100644
--- a/NorthstarDLL/include/spdlog/details/file_helper.h
+++ b/NorthstarDLL/include/spdlog/details/file_helper.h
@@ -1,59 +1,59 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#include <spdlog/common.h>

-#include <tuple>

-

-namespace spdlog {

-namespace details {

-

-// Helper class for file sinks.

-// When failing to open a file, retry several times(5) with a delay interval(10 ms).

-// Throw spdlog_ex exception on errors.

-

-class SPDLOG_API file_helper

-{

-public:

-    explicit file_helper() = default;

-

-    file_helper(const file_helper &) = delete;

-    file_helper &operator=(const file_helper &) = delete;

-    ~file_helper();

-

-    void open(const filename_t &fname, bool truncate = false);

-    void reopen(bool truncate);

-    void flush();

-    void close();

-    void write(const memory_buf_t &buf);

-    size_t size() const;

-    const filename_t &filename() const;

-

-    //

-    // return file path and its extension:

-    //

-    // "mylog.txt" => ("mylog", ".txt")

-    // "mylog" => ("mylog", "")

-    // "mylog." => ("mylog.", "")

-    // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")

-    //

-    // the starting dot in filenames is ignored (hidden files):

-    //

-    // ".mylog" => (".mylog". "")

-    // "my_folder/.mylog" => ("my_folder/.mylog", "")

-    // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")

-    static std::tuple<filename_t, filename_t> split_by_extension(const filename_t &fname);

-

-private:

-    const int open_tries_ = 5;

-    const int open_interval_ = 10;

-    std::FILE *fd_{nullptr};

-    filename_t filename_;

-};

-} // namespace details

-} // namespace spdlog

-

-#ifdef SPDLOG_HEADER_ONLY

-#include "file_helper-inl.h"

-#endif

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <tuple>
+
+namespace spdlog {
+namespace details {
+
+// Helper class for file sinks.
+// When failing to open a file, retry several times(5) with a delay interval(10 ms).
+// Throw spdlog_ex exception on errors.
+
+class SPDLOG_API file_helper
+{
+public:
+    explicit file_helper() = default;
+
+    file_helper(const file_helper &) = delete;
+    file_helper &operator=(const file_helper &) = delete;
+    ~file_helper();
+
+    void open(const filename_t &fname, bool truncate = false);
+    void reopen(bool truncate);
+    void flush();
+    void close();
+    void write(const memory_buf_t &buf);
+    size_t size() const;
+    const filename_t &filename() const;
+
+    //
+    // return file path and its extension:
+    //
+    // "mylog.txt" => ("mylog", ".txt")
+    // "mylog" => ("mylog", "")
+    // "mylog." => ("mylog.", "")
+    // "/dir1/dir2/mylog.txt" => ("/dir1/dir2/mylog", ".txt")
+    //
+    // the starting dot in filenames is ignored (hidden files):
+    //
+    // ".mylog" => (".mylog". "")
+    // "my_folder/.mylog" => ("my_folder/.mylog", "")
+    // "my_folder/.mylog.txt" => ("my_folder/.mylog", ".txt")
+    static std::tuple<filename_t, filename_t> split_by_extension(const filename_t &fname);
+
+private:
+    const int open_tries_ = 5;
+    const int open_interval_ = 10;
+    std::FILE *fd_{nullptr};
+    filename_t filename_;
+};
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "file_helper-inl.h"
+#endif
diff --git a/NorthstarDLL/include/spdlog/details/fmt_helper.h b/NorthstarDLL/include/spdlog/details/fmt_helper.h
index 7ca2c73a..5dc311a0 100644
--- a/NorthstarDLL/include/spdlog/details/fmt_helper.h
+++ b/NorthstarDLL/include/spdlog/details/fmt_helper.h
@@ -1,116 +1,116 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-#pragma once

-

-#include <chrono>

-#include <type_traits>

-#include <spdlog/fmt/fmt.h>

-#include <spdlog/common.h>

-

-// Some fmt helpers to efficiently format and pad ints and strings

-namespace spdlog {

-namespace details {

-namespace fmt_helper {

-

-inline spdlog::string_view_t to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT

-{

-    return spdlog::string_view_t{buf.data(), buf.size()};

-}

-

-inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest)

-{

-    auto *buf_ptr = view.data();

-    dest.append(buf_ptr, buf_ptr + view.size());

-}

-

-template<typename T>

-inline void append_int(T n, memory_buf_t &dest)

-{

-    fmt::format_int i(n);

-    dest.append(i.data(), i.data() + i.size());

-}

-

-template<typename T>

-inline unsigned int count_digits(T n)

-{

-    using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;

-    return static_cast<unsigned int>(fmt::

-// fmt 7.0.0 renamed the internal namespace to detail.

-// See: https://github.com/fmtlib/fmt/issues/1538

-#if FMT_VERSION < 70000

-            internal

-#else

-            detail

-#endif

-        ::count_digits(static_cast<count_type>(n)));

-}

-

-inline void pad2(int n, memory_buf_t &dest)

-{

-    if (n >= 0 && n < 100) // 0-99

-    {

-        dest.push_back(static_cast<char>('0' + n / 10));

-        dest.push_back(static_cast<char>('0' + n % 10));

-    }

-    else // unlikely, but just in case, let fmt deal with it

-    {

-        fmt::format_to(dest, "{:02}", n);

-    }

-}

-

-template<typename T>

-inline void pad_uint(T n, unsigned int width, memory_buf_t &dest)

-{

-    static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");

-    for (auto digits = count_digits(n); digits < width; digits++)

-    {

-        dest.push_back('0');

-    }

-    append_int(n, dest);

-}

-

-template<typename T>

-inline void pad3(T n, memory_buf_t &dest)

-{

-    static_assert(std::is_unsigned<T>::value, "pad3 must get unsigned T");

-    if (n < 1000)

-    {

-        dest.push_back(static_cast<char>(n / 100 + '0'));

-        n = n % 100;

-        dest.push_back(static_cast<char>((n / 10) + '0'));

-        dest.push_back(static_cast<char>((n % 10) + '0'));

-    }

-    else

-    {

-        append_int(n, dest);

-    }

-}

-

-template<typename T>

-inline void pad6(T n, memory_buf_t &dest)

-{

-    pad_uint(n, 6, dest);

-}

-

-template<typename T>

-inline void pad9(T n, memory_buf_t &dest)

-{

-    pad_uint(n, 9, dest);

-}

-

-// return fraction of a second of the given time_point.

-// e.g.

-// fraction<std::milliseconds>(tp) -> will return the millis part of the second

-template<typename ToDuration>

-inline ToDuration time_fraction(log_clock::time_point tp)

-{

-    using std::chrono::duration_cast;

-    using std::chrono::seconds;

-    auto duration = tp.time_since_epoch();

-    auto secs = duration_cast<seconds>(duration);

-    return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);

-}

-

-} // namespace fmt_helper

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+#pragma once
+
+#include <chrono>
+#include <type_traits>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/common.h>
+
+// Some fmt helpers to efficiently format and pad ints and strings
+namespace spdlog {
+namespace details {
+namespace fmt_helper {
+
+inline spdlog::string_view_t to_string_view(const memory_buf_t &buf) SPDLOG_NOEXCEPT
+{
+    return spdlog::string_view_t{buf.data(), buf.size()};
+}
+
+inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest)
+{
+    auto *buf_ptr = view.data();
+    dest.append(buf_ptr, buf_ptr + view.size());
+}
+
+template<typename T>
+inline void append_int(T n, memory_buf_t &dest)
+{
+    fmt::format_int i(n);
+    dest.append(i.data(), i.data() + i.size());
+}
+
+template<typename T>
+inline unsigned int count_digits(T n)
+{
+    using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
+    return static_cast<unsigned int>(fmt::
+// fmt 7.0.0 renamed the internal namespace to detail.
+// See: https://github.com/fmtlib/fmt/issues/1538
+#if FMT_VERSION < 70000
+            internal
+#else
+            detail
+#endif
+        ::count_digits(static_cast<count_type>(n)));
+}
+
+inline void pad2(int n, memory_buf_t &dest)
+{
+    if (n >= 0 && n < 100) // 0-99
+    {
+        dest.push_back(static_cast<char>('0' + n / 10));
+        dest.push_back(static_cast<char>('0' + n % 10));
+    }
+    else // unlikely, but just in case, let fmt deal with it
+    {
+        fmt::format_to(dest, "{:02}", n);
+    }
+}
+
+template<typename T>
+inline void pad_uint(T n, unsigned int width, memory_buf_t &dest)
+{
+    static_assert(std::is_unsigned<T>::value, "pad_uint must get unsigned T");
+    for (auto digits = count_digits(n); digits < width; digits++)
+    {
+        dest.push_back('0');
+    }
+    append_int(n, dest);
+}
+
+template<typename T>
+inline void pad3(T n, memory_buf_t &dest)
+{
+    static_assert(std::is_unsigned<T>::value, "pad3 must get unsigned T");
+    if (n < 1000)
+    {
+        dest.push_back(static_cast<char>(n / 100 + '0'));
+        n = n % 100;
+        dest.push_back(static_cast<char>((n / 10) + '0'));
+        dest.push_back(static_cast<char>((n % 10) + '0'));
+    }
+    else
+    {
+        append_int(n, dest);
+    }
+}
+
+template<typename T>
+inline void pad6(T n, memory_buf_t &dest)
+{
+    pad_uint(n, 6, dest);
+}
+
+template<typename T>
+inline void pad9(T n, memory_buf_t &dest)
+{
+    pad_uint(n, 9, dest);
+}
+
+// return fraction of a second of the given time_point.
+// e.g.
+// fraction<std::milliseconds>(tp) -> will return the millis part of the second
+template<typename ToDuration>
+inline ToDuration time_fraction(log_clock::time_point tp)
+{
+    using std::chrono::duration_cast;
+    using std::chrono::seconds;
+    auto duration = tp.time_since_epoch();
+    auto secs = duration_cast<seconds>(duration);
+    return duration_cast<ToDuration>(duration) - duration_cast<ToDuration>(secs);
+}
+
+} // namespace fmt_helper
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/log_msg-inl.h b/NorthstarDLL/include/spdlog/details/log_msg-inl.h
index 9e898c93..af11e0da 100644
--- a/NorthstarDLL/include/spdlog/details/log_msg-inl.h
+++ b/NorthstarDLL/include/spdlog/details/log_msg-inl.h
@@ -1,37 +1,37 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#ifndef SPDLOG_HEADER_ONLY

-#include <spdlog/details/log_msg.h>

-#endif

-

-#include <spdlog/details/os.h>

-

-namespace spdlog {

-namespace details {

-

-SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name,

-    spdlog::level::level_enum lvl, spdlog::string_view_t msg)

-    : logger_name(a_logger_name)

-    , level(lvl)

-    , time(log_time)

-#ifndef SPDLOG_NO_THREAD_ID

-    , thread_id(os::thread_id())

-#endif

-    , source(loc)

-    , payload(msg)

-{}

-

-SPDLOG_INLINE log_msg::log_msg(

-    spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)

-    : log_msg(os::now(), loc, a_logger_name, lvl, msg)

-{}

-

-SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)

-    : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg)

-{}

-

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/log_msg.h>
+#endif
+
+#include <spdlog/details/os.h>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE log_msg::log_msg(spdlog::log_clock::time_point log_time, spdlog::source_loc loc, string_view_t a_logger_name,
+    spdlog::level::level_enum lvl, spdlog::string_view_t msg)
+    : logger_name(a_logger_name)
+    , level(lvl)
+    , time(log_time)
+#ifndef SPDLOG_NO_THREAD_ID
+    , thread_id(os::thread_id())
+#endif
+    , source(loc)
+    , payload(msg)
+{}
+
+SPDLOG_INLINE log_msg::log_msg(
+    spdlog::source_loc loc, string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
+    : log_msg(os::now(), loc, a_logger_name, lvl, msg)
+{}
+
+SPDLOG_INLINE log_msg::log_msg(string_view_t a_logger_name, spdlog::level::level_enum lvl, spdlog::string_view_t msg)
+    : log_msg(os::now(), source_loc{}, a_logger_name, lvl, msg)
+{}
+
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/log_msg.h b/NorthstarDLL/include/spdlog/details/log_msg.h
index da054c0e..834ca4df 100644
--- a/NorthstarDLL/include/spdlog/details/log_msg.h
+++ b/NorthstarDLL/include/spdlog/details/log_msg.h
@@ -1,36 +1,36 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#include <spdlog/common.h>

-#include <string>

-

-namespace spdlog {

-namespace details {

-struct SPDLOG_API log_msg

-{

-    log_msg() = default;

-    log_msg(log_clock::time_point log_time, source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);

-    log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);

-    log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg);

-    log_msg(const log_msg &other) = default;

-

-    string_view_t logger_name;

-    level::level_enum level{level::off};

-    log_clock::time_point time;

-    size_t thread_id{0};

-

-    // wrapping the formatted text with color (updated by pattern_formatter).

-    mutable size_t color_range_start{0};

-    mutable size_t color_range_end{0};

-

-    source_loc source;

-    string_view_t payload;

-};

-} // namespace details

-} // namespace spdlog

-

-#ifdef SPDLOG_HEADER_ONLY

-#include "log_msg-inl.h"

-#endif

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <string>
+
+namespace spdlog {
+namespace details {
+struct SPDLOG_API log_msg
+{
+    log_msg() = default;
+    log_msg(log_clock::time_point log_time, source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg);
+    log_msg(const log_msg &other) = default;
+
+    string_view_t logger_name;
+    level::level_enum level{level::off};
+    log_clock::time_point time;
+    size_t thread_id{0};
+
+    // wrapping the formatted text with color (updated by pattern_formatter).
+    mutable size_t color_range_start{0};
+    mutable size_t color_range_end{0};
+
+    source_loc source;
+    string_view_t payload;
+};
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "log_msg-inl.h"
+#endif
diff --git a/NorthstarDLL/include/spdlog/details/log_msg_buffer-inl.h b/NorthstarDLL/include/spdlog/details/log_msg_buffer-inl.h
index f6e1a889..ca9429bb 100644
--- a/NorthstarDLL/include/spdlog/details/log_msg_buffer-inl.h
+++ b/NorthstarDLL/include/spdlog/details/log_msg_buffer-inl.h
@@ -1,60 +1,60 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#ifndef SPDLOG_HEADER_ONLY

-#include <spdlog/details/log_msg_buffer.h>

-#endif

-

-namespace spdlog {

-namespace details {

-

-SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg)

-    : log_msg{orig_msg}

-{

-    buffer.append(logger_name.begin(), logger_name.end());

-    buffer.append(payload.begin(), payload.end());

-    update_string_views();

-}

-

-SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)

-    : log_msg{other}

-{

-    buffer.append(logger_name.begin(), logger_name.end());

-    buffer.append(payload.begin(), payload.end());

-    update_string_views();

-}

-

-SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT 

-    : log_msg{other}

-    , buffer{std::move(other.buffer)}

-{

-    update_string_views();

-}

-

-SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other)

-{

-    log_msg::operator=(other);

-    buffer.clear();

-    buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size());

-    update_string_views();

-    return *this;

-}

-

-SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT

-{

-    log_msg::operator=(other);

-    buffer = std::move(other.buffer);

-    update_string_views();

-    return *this;

-}

-

-SPDLOG_INLINE void log_msg_buffer::update_string_views()

-{

-    logger_name = string_view_t{buffer.data(), logger_name.size()};

-    payload = string_view_t{buffer.data() + logger_name.size(), payload.size()};

-}

-

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/log_msg_buffer.h>
+#endif
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg &orig_msg)
+    : log_msg{orig_msg}
+{
+    buffer.append(logger_name.begin(), logger_name.end());
+    buffer.append(payload.begin(), payload.end());
+    update_string_views();
+}
+
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(const log_msg_buffer &other)
+    : log_msg{other}
+{
+    buffer.append(logger_name.begin(), logger_name.end());
+    buffer.append(payload.begin(), payload.end());
+    update_string_views();
+}
+
+SPDLOG_INLINE log_msg_buffer::log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT 
+    : log_msg{other}
+    , buffer{std::move(other.buffer)}
+{
+    update_string_views();
+}
+
+SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(const log_msg_buffer &other)
+{
+    log_msg::operator=(other);
+    buffer.clear();
+    buffer.append(other.buffer.data(), other.buffer.data() + other.buffer.size());
+    update_string_views();
+    return *this;
+}
+
+SPDLOG_INLINE log_msg_buffer &log_msg_buffer::operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT
+{
+    log_msg::operator=(other);
+    buffer = std::move(other.buffer);
+    update_string_views();
+    return *this;
+}
+
+SPDLOG_INLINE void log_msg_buffer::update_string_views()
+{
+    logger_name = string_view_t{buffer.data(), logger_name.size()};
+    payload = string_view_t{buffer.data() + logger_name.size(), payload.size()};
+}
+
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/log_msg_buffer.h b/NorthstarDLL/include/spdlog/details/log_msg_buffer.h
index c7401e9f..4410110f 100644
--- a/NorthstarDLL/include/spdlog/details/log_msg_buffer.h
+++ b/NorthstarDLL/include/spdlog/details/log_msg_buffer.h
@@ -1,33 +1,33 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#include <spdlog/details/log_msg.h>

-

-namespace spdlog {

-namespace details {

-

-// Extend log_msg with internal buffer to store its payload.

-// This is needed since log_msg holds string_views that points to stack data.

-

-class SPDLOG_API log_msg_buffer : public log_msg

-{

-    memory_buf_t buffer;

-    void update_string_views();

-

-public:

-    log_msg_buffer() = default;

-    explicit log_msg_buffer(const log_msg &orig_msg);

-    log_msg_buffer(const log_msg_buffer &other);

-    log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT;

-    log_msg_buffer &operator=(const log_msg_buffer &other);

-    log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT;

-};

-

-} // namespace details

-} // namespace spdlog

-

-#ifdef SPDLOG_HEADER_ONLY

-#include "log_msg_buffer-inl.h"

-#endif

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg.h>
+
+namespace spdlog {
+namespace details {
+
+// Extend log_msg with internal buffer to store its payload.
+// This is needed since log_msg holds string_views that points to stack data.
+
+class SPDLOG_API log_msg_buffer : public log_msg
+{
+    memory_buf_t buffer;
+    void update_string_views();
+
+public:
+    log_msg_buffer() = default;
+    explicit log_msg_buffer(const log_msg &orig_msg);
+    log_msg_buffer(const log_msg_buffer &other);
+    log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
+    log_msg_buffer &operator=(const log_msg_buffer &other);
+    log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT;
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "log_msg_buffer-inl.h"
+#endif
diff --git a/NorthstarDLL/include/spdlog/details/mpmc_blocking_q.h b/NorthstarDLL/include/spdlog/details/mpmc_blocking_q.h
index 4d929c16..5c3cca76 100644
--- a/NorthstarDLL/include/spdlog/details/mpmc_blocking_q.h
+++ b/NorthstarDLL/include/spdlog/details/mpmc_blocking_q.h
@@ -1,126 +1,126 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-// multi producer-multi consumer blocking queue.

-// enqueue(..) - will block until room found to put the new message.

-// enqueue_nowait(..) - will return immediately with false if no room left in

-// the queue.

-// dequeue_for(..) - will block until the queue is not empty or timeout have

-// passed.

-

-#include <spdlog/details/circular_q.h>

-

-#include <condition_variable>

-#include <mutex>

-

-namespace spdlog {

-namespace details {

-

-template<typename T>

-class mpmc_blocking_queue

-{

-public:

-    using item_type = T;

-    explicit mpmc_blocking_queue(size_t max_items)

-        : q_(max_items)

-    {}

-

-#ifndef __MINGW32__

-    // try to enqueue and block if no room left

-    void enqueue(T &&item)

-    {

-        {

-            std::unique_lock<std::mutex> lock(queue_mutex_);

-            pop_cv_.wait(lock, [this] { return !this->q_.full(); });

-            q_.push_back(std::move(item));

-        }

-        push_cv_.notify_one();

-    }

-

-    // enqueue immediately. overrun oldest message in the queue if no room left.

-    void enqueue_nowait(T &&item)

-    {

-        {

-            std::unique_lock<std::mutex> lock(queue_mutex_);

-            q_.push_back(std::move(item));

-        }

-        push_cv_.notify_one();

-    }

-

-    // try to dequeue item. if no item found. wait upto timeout and try again

-    // Return true, if succeeded dequeue item, false otherwise

-    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)

-    {

-        {

-            std::unique_lock<std::mutex> lock(queue_mutex_);

-            if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))

-            {

-                return false;

-            }

-            popped_item = std::move(q_.front());

-            q_.pop_front();

-        }

-        pop_cv_.notify_one();

-        return true;

-    }

-

-#else

-    // apparently mingw deadlocks if the mutex is released before cv.notify_one(),

-    // so release the mutex at the very end each function.

-

-    // try to enqueue and block if no room left

-    void enqueue(T &&item)

-    {

-        std::unique_lock<std::mutex> lock(queue_mutex_);

-        pop_cv_.wait(lock, [this] { return !this->q_.full(); });

-        q_.push_back(std::move(item));

-        push_cv_.notify_one();

-    }

-

-    // enqueue immediately. overrun oldest message in the queue if no room left.

-    void enqueue_nowait(T &&item)

-    {

-        std::unique_lock<std::mutex> lock(queue_mutex_);

-        q_.push_back(std::move(item));

-        push_cv_.notify_one();

-    }

-

-    // try to dequeue item. if no item found. wait upto timeout and try again

-    // Return true, if succeeded dequeue item, false otherwise

-    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)

-    {

-        std::unique_lock<std::mutex> lock(queue_mutex_);

-        if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))

-        {

-            return false;

-        }

-        popped_item = std::move(q_.front());

-        q_.pop_front();

-        pop_cv_.notify_one();

-        return true;

-    }

-

-#endif

-

-    size_t overrun_counter()

-    {

-        std::unique_lock<std::mutex> lock(queue_mutex_);

-        return q_.overrun_counter();

-    }

-

-    size_t size()

-    {

-        std::unique_lock<std::mutex> lock(queue_mutex_);

-        return q_.size();

-    }

-

-private:

-    std::mutex queue_mutex_;

-    std::condition_variable push_cv_;

-    std::condition_variable pop_cv_;

-    spdlog::details::circular_q<T> q_;

-};

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// multi producer-multi consumer blocking queue.
+// enqueue(..) - will block until room found to put the new message.
+// enqueue_nowait(..) - will return immediately with false if no room left in
+// the queue.
+// dequeue_for(..) - will block until the queue is not empty or timeout have
+// passed.
+
+#include <spdlog/details/circular_q.h>
+
+#include <condition_variable>
+#include <mutex>
+
+namespace spdlog {
+namespace details {
+
+template<typename T>
+class mpmc_blocking_queue
+{
+public:
+    using item_type = T;
+    explicit mpmc_blocking_queue(size_t max_items)
+        : q_(max_items)
+    {}
+
+#ifndef __MINGW32__
+    // try to enqueue and block if no room left
+    void enqueue(T &&item)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            pop_cv_.wait(lock, [this] { return !this->q_.full(); });
+            q_.push_back(std::move(item));
+        }
+        push_cv_.notify_one();
+    }
+
+    // enqueue immediately. overrun oldest message in the queue if no room left.
+    void enqueue_nowait(T &&item)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            q_.push_back(std::move(item));
+        }
+        push_cv_.notify_one();
+    }
+
+    // try to dequeue item. if no item found. wait upto timeout and try again
+    // Return true, if succeeded dequeue item, false otherwise
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
+            {
+                return false;
+            }
+            popped_item = std::move(q_.front());
+            q_.pop_front();
+        }
+        pop_cv_.notify_one();
+        return true;
+    }
+
+#else
+    // apparently mingw deadlocks if the mutex is released before cv.notify_one(),
+    // so release the mutex at the very end each function.
+
+    // try to enqueue and block if no room left
+    void enqueue(T &&item)
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        pop_cv_.wait(lock, [this] { return !this->q_.full(); });
+        q_.push_back(std::move(item));
+        push_cv_.notify_one();
+    }
+
+    // enqueue immediately. overrun oldest message in the queue if no room left.
+    void enqueue_nowait(T &&item)
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        q_.push_back(std::move(item));
+        push_cv_.notify_one();
+    }
+
+    // try to dequeue item. if no item found. wait upto timeout and try again
+    // Return true, if succeeded dequeue item, false otherwise
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        if (!push_cv_.wait_for(lock, wait_duration, [this] { return !this->q_.empty(); }))
+        {
+            return false;
+        }
+        popped_item = std::move(q_.front());
+        q_.pop_front();
+        pop_cv_.notify_one();
+        return true;
+    }
+
+#endif
+
+    size_t overrun_counter()
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        return q_.overrun_counter();
+    }
+
+    size_t size()
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        return q_.size();
+    }
+
+private:
+    std::mutex queue_mutex_;
+    std::condition_variable push_cv_;
+    std::condition_variable pop_cv_;
+    spdlog::details::circular_q<T> q_;
+};
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/null_mutex.h b/NorthstarDLL/include/spdlog/details/null_mutex.h
index 789dfcbf..83533d4f 100644
--- a/NorthstarDLL/include/spdlog/details/null_mutex.h
+++ b/NorthstarDLL/include/spdlog/details/null_mutex.h
@@ -1,49 +1,49 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#include <atomic>

-#include <utility>

-// null, no cost dummy "mutex" and dummy "atomic" int

-

-namespace spdlog {

-namespace details {

-struct null_mutex

-{

-    void lock() const {}

-    void unlock() const {}

-    bool try_lock() const

-    {

-        return true;

-    }

-};

-

-struct null_atomic_int

-{

-    int value;

-    null_atomic_int() = default;

-

-    explicit null_atomic_int(int new_value)

-        : value(new_value)

-    {}

-

-    int load(std::memory_order = std::memory_order_relaxed) const

-    {

-        return value;

-    }

-

-    void store(int new_value, std::memory_order = std::memory_order_relaxed)

-    {

-        value = new_value;

-    }

-

-    int exchange(int new_value, std::memory_order = std::memory_order_relaxed)

-    {

-        std::swap(new_value, value);

-        return new_value; // return value before the call

-    }

-};

-

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <atomic>
+#include <utility>
+// null, no cost dummy "mutex" and dummy "atomic" int
+
+namespace spdlog {
+namespace details {
+struct null_mutex
+{
+    void lock() const {}
+    void unlock() const {}
+    bool try_lock() const
+    {
+        return true;
+    }
+};
+
+struct null_atomic_int
+{
+    int value;
+    null_atomic_int() = default;
+
+    explicit null_atomic_int(int new_value)
+        : value(new_value)
+    {}
+
+    int load(std::memory_order = std::memory_order_relaxed) const
+    {
+        return value;
+    }
+
+    void store(int new_value, std::memory_order = std::memory_order_relaxed)
+    {
+        value = new_value;
+    }
+
+    int exchange(int new_value, std::memory_order = std::memory_order_relaxed)
+    {
+        std::swap(new_value, value);
+        return new_value; // return value before the call
+    }
+};
+
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/os-inl.h b/NorthstarDLL/include/spdlog/details/os-inl.h
index 56a217ef..a701e13f 100644
--- a/NorthstarDLL/include/spdlog/details/os-inl.h
+++ b/NorthstarDLL/include/spdlog/details/os-inl.h
@@ -1,589 +1,589 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#ifndef SPDLOG_HEADER_ONLY

-#include <spdlog/details/os.h>

-#endif

-

-#include <spdlog/common.h>

-

-#include <algorithm>

-#include <chrono>

-#include <cstdio>

-#include <cstdlib>

-#include <cstring>

-#include <ctime>

-#include <string>

-#include <thread>

-#include <array>

-#include <sys/stat.h>

-#include <sys/types.h>

-

-#ifdef _WIN32

-

-#include <io.h>      // _get_osfhandle and _isatty support

-#include <process.h> //  _get_pid support

-#include <spdlog/details/windows_include.h>

-

-#ifdef __MINGW32__

-#include <share.h>

-#endif

-

-#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)

-#include <limits>

-#endif

-

-#include <direct.h> // for _mkdir/_wmkdir

-

-#else // unix

-

-#include <fcntl.h>

-#include <unistd.h>

-

-#ifdef __linux__

-#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id

-

-#elif defined(_AIX)

-#include <pthread.h> // for pthread_getthreadid_np

-

-#elif defined(__DragonFly__) || defined(__FreeBSD__)

-#include <pthread_np.h> // for pthread_getthreadid_np

-

-#elif defined(__NetBSD__)

-#include <lwp.h> // for _lwp_self

-

-#elif defined(__sun)

-#include <thread.h> // for thr_self

-#endif

-

-#endif // unix

-

-#ifndef __has_feature      // Clang - feature checking macros.

-#define __has_feature(x) 0 // Compatibility with non-clang compilers.

-#endif

-

-namespace spdlog {

-namespace details {

-namespace os {

-

-SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT

-{

-

-#if defined __linux__ && defined SPDLOG_CLOCK_COARSE

-    timespec ts;

-    ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);

-    return std::chrono::time_point<log_clock, typename log_clock::duration>(

-        std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));

-

-#else

-    return log_clock::now();

-#endif

-}

-SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT

-{

-

-#ifdef _WIN32

-    std::tm tm;

-    ::localtime_s(&tm, &time_tt);

-#else

-    std::tm tm;

-    ::localtime_r(&time_tt, &tm);

-#endif

-    return tm;

-}

-

-SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT

-{

-    std::time_t now_t = ::time(nullptr);

-    return localtime(now_t);

-}

-

-SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT

-{

-

-#ifdef _WIN32

-    std::tm tm;

-    ::gmtime_s(&tm, &time_tt);

-#else

-    std::tm tm;

-    ::gmtime_r(&time_tt, &tm);

-#endif

-    return tm;

-}

-

-SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT

-{

-    std::time_t now_t = ::time(nullptr);

-    return gmtime(now_t);

-}

-

-// fopen_s on non windows for writing

-SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)

-{

-#ifdef _WIN32

-#ifdef SPDLOG_WCHAR_FILENAMES

-    *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);

-#else

-    *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);

-#endif

-#if defined(SPDLOG_PREVENT_CHILD_FD)

-    if (*fp != nullptr)

-    {

-        auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp)));

-        if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))

-        {

-            ::fclose(*fp);

-            *fp = nullptr;

-        }

-    }

-#endif

-#else // unix

-#if defined(SPDLOG_PREVENT_CHILD_FD)

-    const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;

-    const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));

-    if (fd == -1)

-    {

-        return false;

-    }

-    *fp = ::fdopen(fd, mode.c_str());

-    if (*fp == nullptr)

-    {

-        ::close(fd);

-    }

-#else

-    *fp = ::fopen((filename.c_str()), mode.c_str());

-#endif

-#endif

-

-    return *fp == nullptr;

-}

-

-SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT

-{

-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)

-    return ::_wremove(filename.c_str());

-#else

-    return std::remove(filename.c_str());

-#endif

-}

-

-SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT

-{

-    return path_exists(filename) ? remove(filename) : 0;

-}

-

-SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT

-{

-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)

-    return ::_wrename(filename1.c_str(), filename2.c_str());

-#else

-    return std::rename(filename1.c_str(), filename2.c_str());

-#endif

-}

-

-// Return true if path exists (file or directory)

-SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT

-{

-#ifdef _WIN32

-#ifdef SPDLOG_WCHAR_FILENAMES

-    auto attribs = ::GetFileAttributesW(filename.c_str());

-#else

-    auto attribs = ::GetFileAttributesA(filename.c_str());

-#endif

-    return attribs != INVALID_FILE_ATTRIBUTES;

-#else // common linux/unix all have the stat system call

-    struct stat buffer;

-    return (::stat(filename.c_str(), &buffer) == 0);

-#endif

-}

-

-// Return file size according to open FILE* object

-SPDLOG_INLINE size_t filesize(FILE *f)

-{

-    if (f == nullptr)

-    {

-        throw_spdlog_ex("Failed getting file size. fd is null");

-    }

-#if defined(_WIN32) && !defined(__CYGWIN__)

-    int fd = ::_fileno(f);

-#if _WIN64 // 64 bits

-    __int64 ret = ::_filelengthi64(fd);

-    if (ret >= 0)

-    {

-        return static_cast<size_t>(ret);

-    }

-

-#else // windows 32 bits

-    long ret = ::_filelength(fd);

-    if (ret >= 0)

-    {

-        return static_cast<size_t>(ret);

-    }

-#endif

-

-#else // unix

-// OpenBSD doesn't compile with :: before the fileno(..)

-#if defined(__OpenBSD__)

-    int fd = fileno(f);

-#else

-    int fd = ::fileno(f);

-#endif

-// 64 bits(but not in osx or cygwin, where fstat64 is deprecated)

-#if (defined(__linux__) || defined(__sun) || defined(_AIX)) && (defined(__LP64__) || defined(_LP64))

-    struct stat64 st;

-    if (::fstat64(fd, &st) == 0)

-    {

-        return static_cast<size_t>(st.st_size);

-    }

-#else // other unix or linux 32 bits or cygwin

-    struct stat st;

-    if (::fstat(fd, &st) == 0)

-    {

-        return static_cast<size_t>(st.st_size);

-    }

-#endif

-#endif

-    throw_spdlog_ex("Failed getting file size from fd", errno);

-    return 0; // will not be reached.

-}

-

-// Return utc offset in minutes or throw spdlog_ex on failure

-SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)

-{

-

-#ifdef _WIN32

-#if _WIN32_WINNT < _WIN32_WINNT_WS08

-    TIME_ZONE_INFORMATION tzinfo;

-    auto rv = ::GetTimeZoneInformation(&tzinfo);

-#else

-    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;

-    auto rv = ::GetDynamicTimeZoneInformation(&tzinfo);

-#endif

-    if (rv == TIME_ZONE_ID_INVALID)

-        throw_spdlog_ex("Failed getting timezone info. ", errno);

-

-    int offset = -tzinfo.Bias;

-    if (tm.tm_isdst)

-    {

-        offset -= tzinfo.DaylightBias;

-    }

-    else

-    {

-        offset -= tzinfo.StandardBias;

-    }

-    return offset;

-#else

-

-#if defined(sun) || defined(__sun) || defined(_AIX) || (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE))

-    // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris

-    struct helper

-    {

-        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime())

-        {

-            int local_year = localtm.tm_year + (1900 - 1);

-            int gmt_year = gmtm.tm_year + (1900 - 1);

-

-            long int days = (

-                // difference in day of year

-                localtm.tm_yday -

-                gmtm.tm_yday

-

-                // + intervening leap days

-                + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) +

-                ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))

-

-                // + difference in years * 365 */

-                + (long int)(local_year - gmt_year) * 365);

-

-            long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);

-            long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);

-            long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);

-

-            return secs;

-        }

-    };

-

-    auto offset_seconds = helper::calculate_gmt_offset(tm);

-#else

-    auto offset_seconds = tm.tm_gmtoff;

-#endif

-

-    return static_cast<int>(offset_seconds / 60);

-#endif

-}

-

-// Return current thread id as size_t

-// It exists because the std::this_thread::get_id() is much slower(especially

-// under VS 2013)

-SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT

-{

-#ifdef _WIN32

-    return static_cast<size_t>(::GetCurrentThreadId());

-#elif defined(__linux__)

-#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)

-#define SYS_gettid __NR_gettid

-#endif

-    return static_cast<size_t>(::syscall(SYS_gettid));

-#elif defined(_AIX) || defined(__DragonFly__) || defined(__FreeBSD__)

-    return static_cast<size_t>(::pthread_getthreadid_np());

-#elif defined(__NetBSD__)

-    return static_cast<size_t>(::_lwp_self());

-#elif defined(__OpenBSD__)

-    return static_cast<size_t>(::getthrid());

-#elif defined(__sun)

-    return static_cast<size_t>(::thr_self());

-#elif __APPLE__

-    uint64_t tid;

-    pthread_threadid_np(nullptr, &tid);

-    return static_cast<size_t>(tid);

-#else // Default to standard C++11 (other Unix)

-    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));

-#endif

-}

-

-// Return current thread id as size_t (from thread local storage)

-SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT

-{

-#if defined(SPDLOG_NO_TLS)

-    return _thread_id();

-#else // cache thread id in tls

-    static thread_local const size_t tid = _thread_id();

-    return tid;

-#endif

-}

-

-// This is avoid msvc issue in sleep_for that happens if the clock changes.

-// See https://github.com/gabime/spdlog/issues/609

-SPDLOG_INLINE void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT

-{

-#if defined(_WIN32)

-    ::Sleep(milliseconds);

-#else

-    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));

-#endif

-}

-

-// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)

-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)

-SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)

-{

-    memory_buf_t buf;

-    wstr_to_utf8buf(filename, buf);

-    return fmt::to_string(buf);

-}

-#else

-SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)

-{

-    return filename;

-}

-#endif

-

-SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT

-{

-

-#ifdef _WIN32

-    return static_cast<int>(::GetCurrentProcessId());

-#else

-    return static_cast<int>(::getpid());

-#endif

-}

-

-// Determine if the terminal supports colors

-// Based on: https://github.com/agauniyal/rang/

-SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT

-{

-#ifdef _WIN32

-    return true;

-#else

-

-    static const bool result = []() {

-        const char *env_colorterm_p = std::getenv("COLORTERM");

-        if (env_colorterm_p != nullptr)

-        {

-            return true;

-        }

-

-        static constexpr std::array<const char *, 15> terms = {{"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux",

-            "msys", "putty", "rxvt", "screen", "vt100", "xterm", "alacritty"}};

-

-        const char *env_term_p = std::getenv("TERM");

-        if (env_term_p == nullptr)

-        {

-            return false;

-        }

-

-        return std::any_of(terms.begin(), terms.end(), [&](const char *term) { return std::strstr(env_term_p, term) != nullptr; });

-    }();

-

-    return result;

-#endif

-}

-

-// Determine if the terminal attached

-// Source: https://github.com/agauniyal/rang/

-SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT

-{

-

-#ifdef _WIN32

-    return ::_isatty(_fileno(file)) != 0;

-#else

-    return ::isatty(fileno(file)) != 0;

-#endif

-}

-

-#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)

-SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target)

-{

-    if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 2 - 1)

-    {

-        throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8");

-    }

-

-    int wstr_size = static_cast<int>(wstr.size());

-    if (wstr_size == 0)

-    {

-        target.resize(0);

-        return;

-    }

-

-    int result_size = static_cast<int>(target.capacity());

-    if ((wstr_size + 1) * 2 > result_size)

-    {

-        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);

-    }

-

-    if (result_size > 0)

-    {

-        target.resize(result_size);

-        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL);

-

-        if (result_size > 0)

-        {

-            target.resize(result_size);

-            return;

-        }

-    }

-

-    throw_spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));

-}

-

-SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target)

-{

-    if (str.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) - 1)

-    {

-        throw_spdlog_ex("UTF-8 string is too big to be converted to UTF-16");

-    }

-

-    int str_size = static_cast<int>(str.size());

-    if (str_size == 0)

-    {

-        target.resize(0);

-        return;

-    }

-

-    int result_size = static_cast<int>(target.capacity());

-    if (str_size + 1 > result_size)

-    {

-        result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0);

-    }

-

-    if (result_size > 0)

-    {

-        target.resize(result_size);

-        result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, target.data(), result_size);

-

-        if (result_size > 0)

-        {

-            target.resize(result_size);

-            return;

-        }

-    }

-

-    throw_spdlog_ex(fmt::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));

-}

-#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)

-

-// return true on success

-static SPDLOG_INLINE bool mkdir_(const filename_t &path)

-{

-#ifdef _WIN32

-#ifdef SPDLOG_WCHAR_FILENAMES

-    return ::_wmkdir(path.c_str()) == 0;

-#else

-    return ::_mkdir(path.c_str()) == 0;

-#endif

-#else

-    return ::mkdir(path.c_str(), mode_t(0755)) == 0;

-#endif

-}

-

-// create the given directory - and all directories leading to it

-// return true on success or if the directory already exists

-SPDLOG_INLINE bool create_dir(filename_t path)

-{

-    if (path_exists(path))

-    {

-        return true;

-    }

-

-    if (path.empty())

-    {

-        return false;

-    }

-

-    size_t search_offset = 0;

-    do

-    {

-        auto token_pos = path.find_first_of(folder_seps_filename, search_offset);

-        // treat the entire path as a folder if no folder separator not found

-        if (token_pos == filename_t::npos)

-        {

-            token_pos = path.size();

-        }

-

-        auto subdir = path.substr(0, token_pos);

-

-        if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir))

-        {

-            return false; // return error if failed creating dir

-        }

-        search_offset = token_pos + 1;

-    } while (search_offset < path.size());

-

-    return true;

-}

-

-// Return directory name from given path or empty string

-// "abc/file" => "abc"

-// "abc/" => "abc"

-// "abc" => ""

-// "abc///" => "abc//"

-SPDLOG_INLINE filename_t dir_name(filename_t path)

-{

-    auto pos = path.find_last_of(folder_seps_filename);

-    return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};

-}

-

-std::string SPDLOG_INLINE getenv(const char *field)

-{

-

-#if defined(_MSC_VER)

-#if defined(__cplusplus_winrt)

-    return std::string{}; // not supported under uwp

-#else

-    size_t len = 0;

-    char buf[128];

-    bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0;

-    return ok ? buf : std::string{};

-#endif

-#else // revert to getenv

-    char *buf = ::getenv(field);

-    return buf ? buf : std::string{};

-#endif

-}

-

-} // namespace os

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/os.h>
+#endif
+
+#include <spdlog/common.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <string>
+#include <thread>
+#include <array>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef _WIN32
+
+#include <io.h>      // _get_osfhandle and _isatty support
+#include <process.h> //  _get_pid support
+#include <spdlog/details/windows_include.h>
+
+#ifdef __MINGW32__
+#include <share.h>
+#endif
+
+#if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)
+#include <limits>
+#endif
+
+#include <direct.h> // for _mkdir/_wmkdir
+
+#else // unix
+
+#include <fcntl.h>
+#include <unistd.h>
+
+#ifdef __linux__
+#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
+
+#elif defined(_AIX)
+#include <pthread.h> // for pthread_getthreadid_np
+
+#elif defined(__DragonFly__) || defined(__FreeBSD__)
+#include <pthread_np.h> // for pthread_getthreadid_np
+
+#elif defined(__NetBSD__)
+#include <lwp.h> // for _lwp_self
+
+#elif defined(__sun)
+#include <thread.h> // for thr_self
+#endif
+
+#endif // unix
+
+#ifndef __has_feature      // Clang - feature checking macros.
+#define __has_feature(x) 0 // Compatibility with non-clang compilers.
+#endif
+
+namespace spdlog {
+namespace details {
+namespace os {
+
+SPDLOG_INLINE spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT
+{
+
+#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
+    timespec ts;
+    ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
+    return std::chrono::time_point<log_clock, typename log_clock::duration>(
+        std::chrono::duration_cast<typename log_clock::duration>(std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
+
+#else
+    return log_clock::now();
+#endif
+}
+SPDLOG_INLINE std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    std::tm tm;
+    ::localtime_s(&tm, &time_tt);
+#else
+    std::tm tm;
+    ::localtime_r(&time_tt, &tm);
+#endif
+    return tm;
+}
+
+SPDLOG_INLINE std::tm localtime() SPDLOG_NOEXCEPT
+{
+    std::time_t now_t = ::time(nullptr);
+    return localtime(now_t);
+}
+
+SPDLOG_INLINE std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    std::tm tm;
+    ::gmtime_s(&tm, &time_tt);
+#else
+    std::tm tm;
+    ::gmtime_r(&time_tt, &tm);
+#endif
+    return tm;
+}
+
+SPDLOG_INLINE std::tm gmtime() SPDLOG_NOEXCEPT
+{
+    std::time_t now_t = ::time(nullptr);
+    return gmtime(now_t);
+}
+
+// fopen_s on non windows for writing
+SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode)
+{
+#ifdef _WIN32
+#ifdef SPDLOG_WCHAR_FILENAMES
+    *fp = ::_wfsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
+#else
+    *fp = ::_fsopen((filename.c_str()), mode.c_str(), _SH_DENYNO);
+#endif
+#if defined(SPDLOG_PREVENT_CHILD_FD)
+    if (*fp != nullptr)
+    {
+        auto file_handle = reinterpret_cast<HANDLE>(_get_osfhandle(::_fileno(*fp)));
+        if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
+        {
+            ::fclose(*fp);
+            *fp = nullptr;
+        }
+    }
+#endif
+#else // unix
+#if defined(SPDLOG_PREVENT_CHILD_FD)
+    const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC;
+    const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
+    if (fd == -1)
+    {
+        return false;
+    }
+    *fp = ::fdopen(fd, mode.c_str());
+    if (*fp == nullptr)
+    {
+        ::close(fd);
+    }
+#else
+    *fp = ::fopen((filename.c_str()), mode.c_str());
+#endif
+#endif
+
+    return *fp == nullptr;
+}
+
+SPDLOG_INLINE int remove(const filename_t &filename) SPDLOG_NOEXCEPT
+{
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+    return ::_wremove(filename.c_str());
+#else
+    return std::remove(filename.c_str());
+#endif
+}
+
+SPDLOG_INLINE int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT
+{
+    return path_exists(filename) ? remove(filename) : 0;
+}
+
+SPDLOG_INLINE int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT
+{
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+    return ::_wrename(filename1.c_str(), filename2.c_str());
+#else
+    return std::rename(filename1.c_str(), filename2.c_str());
+#endif
+}
+
+// Return true if path exists (file or directory)
+SPDLOG_INLINE bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT
+{
+#ifdef _WIN32
+#ifdef SPDLOG_WCHAR_FILENAMES
+    auto attribs = ::GetFileAttributesW(filename.c_str());
+#else
+    auto attribs = ::GetFileAttributesA(filename.c_str());
+#endif
+    return attribs != INVALID_FILE_ATTRIBUTES;
+#else // common linux/unix all have the stat system call
+    struct stat buffer;
+    return (::stat(filename.c_str(), &buffer) == 0);
+#endif
+}
+
+// Return file size according to open FILE* object
+SPDLOG_INLINE size_t filesize(FILE *f)
+{
+    if (f == nullptr)
+    {
+        throw_spdlog_ex("Failed getting file size. fd is null");
+    }
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    int fd = ::_fileno(f);
+#if _WIN64 // 64 bits
+    __int64 ret = ::_filelengthi64(fd);
+    if (ret >= 0)
+    {
+        return static_cast<size_t>(ret);
+    }
+
+#else // windows 32 bits
+    long ret = ::_filelength(fd);
+    if (ret >= 0)
+    {
+        return static_cast<size_t>(ret);
+    }
+#endif
+
+#else // unix
+// OpenBSD doesn't compile with :: before the fileno(..)
+#if defined(__OpenBSD__)
+    int fd = fileno(f);
+#else
+    int fd = ::fileno(f);
+#endif
+// 64 bits(but not in osx or cygwin, where fstat64 is deprecated)
+#if (defined(__linux__) || defined(__sun) || defined(_AIX)) && (defined(__LP64__) || defined(_LP64))
+    struct stat64 st;
+    if (::fstat64(fd, &st) == 0)
+    {
+        return static_cast<size_t>(st.st_size);
+    }
+#else // other unix or linux 32 bits or cygwin
+    struct stat st;
+    if (::fstat(fd, &st) == 0)
+    {
+        return static_cast<size_t>(st.st_size);
+    }
+#endif
+#endif
+    throw_spdlog_ex("Failed getting file size from fd", errno);
+    return 0; // will not be reached.
+}
+
+// Return utc offset in minutes or throw spdlog_ex on failure
+SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
+{
+
+#ifdef _WIN32
+#if _WIN32_WINNT < _WIN32_WINNT_WS08
+    TIME_ZONE_INFORMATION tzinfo;
+    auto rv = ::GetTimeZoneInformation(&tzinfo);
+#else
+    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
+    auto rv = ::GetDynamicTimeZoneInformation(&tzinfo);
+#endif
+    if (rv == TIME_ZONE_ID_INVALID)
+        throw_spdlog_ex("Failed getting timezone info. ", errno);
+
+    int offset = -tzinfo.Bias;
+    if (tm.tm_isdst)
+    {
+        offset -= tzinfo.DaylightBias;
+    }
+    else
+    {
+        offset -= tzinfo.StandardBias;
+    }
+    return offset;
+#else
+
+#if defined(sun) || defined(__sun) || defined(_AIX) || (!defined(_BSD_SOURCE) && !defined(_GNU_SOURCE))
+    // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
+    struct helper
+    {
+        static long int calculate_gmt_offset(const std::tm &localtm = details::os::localtime(), const std::tm &gmtm = details::os::gmtime())
+        {
+            int local_year = localtm.tm_year + (1900 - 1);
+            int gmt_year = gmtm.tm_year + (1900 - 1);
+
+            long int days = (
+                // difference in day of year
+                localtm.tm_yday -
+                gmtm.tm_yday
+
+                // + intervening leap days
+                + ((local_year >> 2) - (gmt_year >> 2)) - (local_year / 100 - gmt_year / 100) +
+                ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
+
+                // + difference in years * 365 */
+                + (long int)(local_year - gmt_year) * 365);
+
+            long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
+            long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
+            long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
+
+            return secs;
+        }
+    };
+
+    auto offset_seconds = helper::calculate_gmt_offset(tm);
+#else
+    auto offset_seconds = tm.tm_gmtoff;
+#endif
+
+    return static_cast<int>(offset_seconds / 60);
+#endif
+}
+
+// Return current thread id as size_t
+// It exists because the std::this_thread::get_id() is much slower(especially
+// under VS 2013)
+SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT
+{
+#ifdef _WIN32
+    return static_cast<size_t>(::GetCurrentThreadId());
+#elif defined(__linux__)
+#if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
+#define SYS_gettid __NR_gettid
+#endif
+    return static_cast<size_t>(::syscall(SYS_gettid));
+#elif defined(_AIX) || defined(__DragonFly__) || defined(__FreeBSD__)
+    return static_cast<size_t>(::pthread_getthreadid_np());
+#elif defined(__NetBSD__)
+    return static_cast<size_t>(::_lwp_self());
+#elif defined(__OpenBSD__)
+    return static_cast<size_t>(::getthrid());
+#elif defined(__sun)
+    return static_cast<size_t>(::thr_self());
+#elif __APPLE__
+    uint64_t tid;
+    pthread_threadid_np(nullptr, &tid);
+    return static_cast<size_t>(tid);
+#else // Default to standard C++11 (other Unix)
+    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
+#endif
+}
+
+// Return current thread id as size_t (from thread local storage)
+SPDLOG_INLINE size_t thread_id() SPDLOG_NOEXCEPT
+{
+#if defined(SPDLOG_NO_TLS)
+    return _thread_id();
+#else // cache thread id in tls
+    static thread_local const size_t tid = _thread_id();
+    return tid;
+#endif
+}
+
+// This is avoid msvc issue in sleep_for that happens if the clock changes.
+// See https://github.com/gabime/spdlog/issues/609
+SPDLOG_INLINE void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT
+{
+#if defined(_WIN32)
+    ::Sleep(milliseconds);
+#else
+    std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
+#endif
+}
+
+// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
+{
+    memory_buf_t buf;
+    wstr_to_utf8buf(filename, buf);
+    return fmt::to_string(buf);
+}
+#else
+SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
+{
+    return filename;
+}
+#endif
+
+SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    return static_cast<int>(::GetCurrentProcessId());
+#else
+    return static_cast<int>(::getpid());
+#endif
+}
+
+// Determine if the terminal supports colors
+// Based on: https://github.com/agauniyal/rang/
+SPDLOG_INLINE bool is_color_terminal() SPDLOG_NOEXCEPT
+{
+#ifdef _WIN32
+    return true;
+#else
+
+    static const bool result = []() {
+        const char *env_colorterm_p = std::getenv("COLORTERM");
+        if (env_colorterm_p != nullptr)
+        {
+            return true;
+        }
+
+        static constexpr std::array<const char *, 15> terms = {{"ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm", "linux",
+            "msys", "putty", "rxvt", "screen", "vt100", "xterm", "alacritty"}};
+
+        const char *env_term_p = std::getenv("TERM");
+        if (env_term_p == nullptr)
+        {
+            return false;
+        }
+
+        return std::any_of(terms.begin(), terms.end(), [&](const char *term) { return std::strstr(env_term_p, term) != nullptr; });
+    }();
+
+    return result;
+#endif
+}
+
+// Determine if the terminal attached
+// Source: https://github.com/agauniyal/rang/
+SPDLOG_INLINE bool in_terminal(FILE *file) SPDLOG_NOEXCEPT
+{
+
+#ifdef _WIN32
+    return ::_isatty(_fileno(file)) != 0;
+#else
+    return ::isatty(fileno(file)) != 0;
+#endif
+}
+
+#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target)
+{
+    if (wstr.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) / 2 - 1)
+    {
+        throw_spdlog_ex("UTF-16 string is too big to be converted to UTF-8");
+    }
+
+    int wstr_size = static_cast<int>(wstr.size());
+    if (wstr_size == 0)
+    {
+        target.resize(0);
+        return;
+    }
+
+    int result_size = static_cast<int>(target.capacity());
+    if ((wstr_size + 1) * 2 > result_size)
+    {
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, NULL, 0, NULL, NULL);
+    }
+
+    if (result_size > 0)
+    {
+        target.resize(result_size);
+        result_size = ::WideCharToMultiByte(CP_UTF8, 0, wstr.data(), wstr_size, target.data(), result_size, NULL, NULL);
+
+        if (result_size > 0)
+        {
+            target.resize(result_size);
+            return;
+        }
+    }
+
+    throw_spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
+}
+
+SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target)
+{
+    if (str.size() > static_cast<size_t>((std::numeric_limits<int>::max)()) - 1)
+    {
+        throw_spdlog_ex("UTF-8 string is too big to be converted to UTF-16");
+    }
+
+    int str_size = static_cast<int>(str.size());
+    if (str_size == 0)
+    {
+        target.resize(0);
+        return;
+    }
+
+    int result_size = static_cast<int>(target.capacity());
+    if (str_size + 1 > result_size)
+    {
+        result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, NULL, 0);
+    }
+
+    if (result_size > 0)
+    {
+        target.resize(result_size);
+        result_size = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.data(), str_size, target.data(), result_size);
+
+        if (result_size > 0)
+        {
+            target.resize(result_size);
+            return;
+        }
+    }
+
+    throw_spdlog_ex(fmt::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
+}
+#endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+
+// return true on success
+static SPDLOG_INLINE bool mkdir_(const filename_t &path)
+{
+#ifdef _WIN32
+#ifdef SPDLOG_WCHAR_FILENAMES
+    return ::_wmkdir(path.c_str()) == 0;
+#else
+    return ::_mkdir(path.c_str()) == 0;
+#endif
+#else
+    return ::mkdir(path.c_str(), mode_t(0755)) == 0;
+#endif
+}
+
+// create the given directory - and all directories leading to it
+// return true on success or if the directory already exists
+SPDLOG_INLINE bool create_dir(filename_t path)
+{
+    if (path_exists(path))
+    {
+        return true;
+    }
+
+    if (path.empty())
+    {
+        return false;
+    }
+
+    size_t search_offset = 0;
+    do
+    {
+        auto token_pos = path.find_first_of(folder_seps_filename, search_offset);
+        // treat the entire path as a folder if no folder separator not found
+        if (token_pos == filename_t::npos)
+        {
+            token_pos = path.size();
+        }
+
+        auto subdir = path.substr(0, token_pos);
+
+        if (!subdir.empty() && !path_exists(subdir) && !mkdir_(subdir))
+        {
+            return false; // return error if failed creating dir
+        }
+        search_offset = token_pos + 1;
+    } while (search_offset < path.size());
+
+    return true;
+}
+
+// Return directory name from given path or empty string
+// "abc/file" => "abc"
+// "abc/" => "abc"
+// "abc" => ""
+// "abc///" => "abc//"
+SPDLOG_INLINE filename_t dir_name(filename_t path)
+{
+    auto pos = path.find_last_of(folder_seps_filename);
+    return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};
+}
+
+std::string SPDLOG_INLINE getenv(const char *field)
+{
+
+#if defined(_MSC_VER)
+#if defined(__cplusplus_winrt)
+    return std::string{}; // not supported under uwp
+#else
+    size_t len = 0;
+    char buf[128];
+    bool ok = ::getenv_s(&len, buf, sizeof(buf), field) == 0;
+    return ok ? buf : std::string{};
+#endif
+#else // revert to getenv
+    char *buf = ::getenv(field);
+    return buf ? buf : std::string{};
+#endif
+}
+
+} // namespace os
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/os.h b/NorthstarDLL/include/spdlog/details/os.h
index 7df8cbfc..9fda1447 100644
--- a/NorthstarDLL/include/spdlog/details/os.h
+++ b/NorthstarDLL/include/spdlog/details/os.h
@@ -1,118 +1,118 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#include <spdlog/common.h>

-#include <ctime> // std::time_t

-

-namespace spdlog {

-namespace details {

-namespace os {

-

-SPDLOG_API spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT;

-

-SPDLOG_API std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;

-

-SPDLOG_API std::tm localtime() SPDLOG_NOEXCEPT;

-

-SPDLOG_API std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;

-

-SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT;

-

-// eol definition

-#if !defined(SPDLOG_EOL)

-#ifdef _WIN32

-#define SPDLOG_EOL "\r\n"

-#else

-#define SPDLOG_EOL "\n"

-#endif

-#endif

-

-SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL;

-

-// folder separator

-#if !defined(SPDLOG_FOLDER_SEPS)

-#ifdef _WIN32

-#define SPDLOG_FOLDER_SEPS "\\/"

-#else

-#define SPDLOG_FOLDER_SEPS "/"

-#endif

-#endif

-

-SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS;

-SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] = SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS);

-

-// fopen_s on non windows for writing

-SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode);

-

-// Remove filename. return 0 on success

-SPDLOG_API int remove(const filename_t &filename) SPDLOG_NOEXCEPT;

-

-// Remove file if exists. return 0 on success

-// Note: Non atomic (might return failure to delete if concurrently deleted by other process/thread)

-SPDLOG_API int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT;

-

-SPDLOG_API int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT;

-

-// Return if file exists.

-SPDLOG_API bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT;

-

-// Return file size according to open FILE* object

-SPDLOG_API size_t filesize(FILE *f);

-

-// Return utc offset in minutes or throw spdlog_ex on failure

-SPDLOG_API int utc_minutes_offset(const std::tm &tm = details::os::localtime());

-

-// Return current thread id as size_t

-// It exists because the std::this_thread::get_id() is much slower(especially

-// under VS 2013)

-SPDLOG_API size_t _thread_id() SPDLOG_NOEXCEPT;

-

-// Return current thread id as size_t (from thread local storage)

-SPDLOG_API size_t thread_id() SPDLOG_NOEXCEPT;

-

-// This is avoid msvc issue in sleep_for that happens if the clock changes.

-// See https://github.com/gabime/spdlog/issues/609

-SPDLOG_API void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT;

-

-SPDLOG_API std::string filename_to_str(const filename_t &filename);

-

-SPDLOG_API int pid() SPDLOG_NOEXCEPT;

-

-// Determine if the terminal supports colors

-// Source: https://github.com/agauniyal/rang/

-SPDLOG_API bool is_color_terminal() SPDLOG_NOEXCEPT;

-

-// Determine if the terminal attached

-// Source: https://github.com/agauniyal/rang/

-SPDLOG_API bool in_terminal(FILE *file) SPDLOG_NOEXCEPT;

-

-#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)

-SPDLOG_API void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target);

-

-SPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target);

-#endif

-

-// Return directory name from given path or empty string

-// "abc/file" => "abc"

-// "abc/" => "abc"

-// "abc" => ""

-// "abc///" => "abc//"

-SPDLOG_API filename_t dir_name(filename_t path);

-

-// Create a dir from the given path.

-// Return true if succeeded or if this dir already exists.

-SPDLOG_API bool create_dir(filename_t path);

-

-// non thread safe, cross platform getenv/getenv_s

-// return empty string if field not found

-SPDLOG_API std::string getenv(const char *field);

-

-} // namespace os

-} // namespace details

-} // namespace spdlog

-

-#ifdef SPDLOG_HEADER_ONLY

-#include "os-inl.h"

-#endif

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <ctime> // std::time_t
+
+namespace spdlog {
+namespace details {
+namespace os {
+
+SPDLOG_API spdlog::log_clock::time_point now() SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::tm localtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::tm localtime() SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::tm gmtime(const std::time_t &time_tt) SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::tm gmtime() SPDLOG_NOEXCEPT;
+
+// eol definition
+#if !defined(SPDLOG_EOL)
+#ifdef _WIN32
+#define SPDLOG_EOL "\r\n"
+#else
+#define SPDLOG_EOL "\n"
+#endif
+#endif
+
+SPDLOG_CONSTEXPR static const char *default_eol = SPDLOG_EOL;
+
+// folder separator
+#if !defined(SPDLOG_FOLDER_SEPS)
+#ifdef _WIN32
+#define SPDLOG_FOLDER_SEPS "\\/"
+#else
+#define SPDLOG_FOLDER_SEPS "/"
+#endif
+#endif
+
+SPDLOG_CONSTEXPR static const char folder_seps[] = SPDLOG_FOLDER_SEPS;
+SPDLOG_CONSTEXPR static const filename_t::value_type folder_seps_filename[] = SPDLOG_FILENAME_T(SPDLOG_FOLDER_SEPS);
+
+// fopen_s on non windows for writing
+SPDLOG_API bool fopen_s(FILE **fp, const filename_t &filename, const filename_t &mode);
+
+// Remove filename. return 0 on success
+SPDLOG_API int remove(const filename_t &filename) SPDLOG_NOEXCEPT;
+
+// Remove file if exists. return 0 on success
+// Note: Non atomic (might return failure to delete if concurrently deleted by other process/thread)
+SPDLOG_API int remove_if_exists(const filename_t &filename) SPDLOG_NOEXCEPT;
+
+SPDLOG_API int rename(const filename_t &filename1, const filename_t &filename2) SPDLOG_NOEXCEPT;
+
+// Return if file exists.
+SPDLOG_API bool path_exists(const filename_t &filename) SPDLOG_NOEXCEPT;
+
+// Return file size according to open FILE* object
+SPDLOG_API size_t filesize(FILE *f);
+
+// Return utc offset in minutes or throw spdlog_ex on failure
+SPDLOG_API int utc_minutes_offset(const std::tm &tm = details::os::localtime());
+
+// Return current thread id as size_t
+// It exists because the std::this_thread::get_id() is much slower(especially
+// under VS 2013)
+SPDLOG_API size_t _thread_id() SPDLOG_NOEXCEPT;
+
+// Return current thread id as size_t (from thread local storage)
+SPDLOG_API size_t thread_id() SPDLOG_NOEXCEPT;
+
+// This is avoid msvc issue in sleep_for that happens if the clock changes.
+// See https://github.com/gabime/spdlog/issues/609
+SPDLOG_API void sleep_for_millis(int milliseconds) SPDLOG_NOEXCEPT;
+
+SPDLOG_API std::string filename_to_str(const filename_t &filename);
+
+SPDLOG_API int pid() SPDLOG_NOEXCEPT;
+
+// Determine if the terminal supports colors
+// Source: https://github.com/agauniyal/rang/
+SPDLOG_API bool is_color_terminal() SPDLOG_NOEXCEPT;
+
+// Determine if the terminal attached
+// Source: https://github.com/agauniyal/rang/
+SPDLOG_API bool in_terminal(FILE *file) SPDLOG_NOEXCEPT;
+
+#if (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
+SPDLOG_API void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target);
+
+SPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target);
+#endif
+
+// Return directory name from given path or empty string
+// "abc/file" => "abc"
+// "abc/" => "abc"
+// "abc" => ""
+// "abc///" => "abc//"
+SPDLOG_API filename_t dir_name(filename_t path);
+
+// Create a dir from the given path.
+// Return true if succeeded or if this dir already exists.
+SPDLOG_API bool create_dir(filename_t path);
+
+// non thread safe, cross platform getenv/getenv_s
+// return empty string if field not found
+SPDLOG_API std::string getenv(const char *field);
+
+} // namespace os
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "os-inl.h"
+#endif
diff --git a/NorthstarDLL/include/spdlog/details/periodic_worker-inl.h b/NorthstarDLL/include/spdlog/details/periodic_worker-inl.h
index 91815356..1d794994 100644
--- a/NorthstarDLL/include/spdlog/details/periodic_worker-inl.h
+++ b/NorthstarDLL/include/spdlog/details/periodic_worker-inl.h
@@ -1,49 +1,49 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#ifndef SPDLOG_HEADER_ONLY

-#include <spdlog/details/periodic_worker.h>

-#endif

-

-namespace spdlog {

-namespace details {

-

-SPDLOG_INLINE periodic_worker::periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)

-{

-    active_ = (interval > std::chrono::seconds::zero());

-    if (!active_)

-    {

-        return;

-    }

-

-    worker_thread_ = std::thread([this, callback_fun, interval]() {

-        for (;;)

-        {

-            std::unique_lock<std::mutex> lock(this->mutex_);

-            if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))

-            {

-                return; // active_ == false, so exit this thread

-            }

-            callback_fun();

-        }

-    });

-}

-

-// stop the worker thread and join it

-SPDLOG_INLINE periodic_worker::~periodic_worker()

-{

-    if (worker_thread_.joinable())

-    {

-        {

-            std::lock_guard<std::mutex> lock(mutex_);

-            active_ = false;

-        }

-        cv_.notify_one();

-        worker_thread_.join();

-    }

-}

-

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/periodic_worker.h>
+#endif
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE periodic_worker::periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
+{
+    active_ = (interval > std::chrono::seconds::zero());
+    if (!active_)
+    {
+        return;
+    }
+
+    worker_thread_ = std::thread([this, callback_fun, interval]() {
+        for (;;)
+        {
+            std::unique_lock<std::mutex> lock(this->mutex_);
+            if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
+            {
+                return; // active_ == false, so exit this thread
+            }
+            callback_fun();
+        }
+    });
+}
+
+// stop the worker thread and join it
+SPDLOG_INLINE periodic_worker::~periodic_worker()
+{
+    if (worker_thread_.joinable())
+    {
+        {
+            std::lock_guard<std::mutex> lock(mutex_);
+            active_ = false;
+        }
+        cv_.notify_one();
+        worker_thread_.join();
+    }
+}
+
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/periodic_worker.h b/NorthstarDLL/include/spdlog/details/periodic_worker.h
index efc35f00..42373665 100644
--- a/NorthstarDLL/include/spdlog/details/periodic_worker.h
+++ b/NorthstarDLL/include/spdlog/details/periodic_worker.h
@@ -1,40 +1,40 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-// periodic worker thread - periodically executes the given callback function.

-//

-// RAII over the owned thread:

-//    creates the thread on construction.

-//    stops and joins the thread on destruction (if the thread is executing a callback, wait for it to finish first).

-

-#include <chrono>

-#include <condition_variable>

-#include <functional>

-#include <mutex>

-#include <thread>

-namespace spdlog {

-namespace details {

-

-class SPDLOG_API periodic_worker

-{

-public:

-    periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval);

-    periodic_worker(const periodic_worker &) = delete;

-    periodic_worker &operator=(const periodic_worker &) = delete;

-    // stop the worker thread and join it

-    ~periodic_worker();

-

-private:

-    bool active_;

-    std::thread worker_thread_;

-    std::mutex mutex_;

-    std::condition_variable cv_;

-};

-} // namespace details

-} // namespace spdlog

-

-#ifdef SPDLOG_HEADER_ONLY

-#include "periodic_worker-inl.h"

-#endif

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// periodic worker thread - periodically executes the given callback function.
+//
+// RAII over the owned thread:
+//    creates the thread on construction.
+//    stops and joins the thread on destruction (if the thread is executing a callback, wait for it to finish first).
+
+#include <chrono>
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+#include <thread>
+namespace spdlog {
+namespace details {
+
+class SPDLOG_API periodic_worker
+{
+public:
+    periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval);
+    periodic_worker(const periodic_worker &) = delete;
+    periodic_worker &operator=(const periodic_worker &) = delete;
+    // stop the worker thread and join it
+    ~periodic_worker();
+
+private:
+    bool active_;
+    std::thread worker_thread_;
+    std::mutex mutex_;
+    std::condition_variable cv_;
+};
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "periodic_worker-inl.h"
+#endif
diff --git a/NorthstarDLL/include/spdlog/details/registry-inl.h b/NorthstarDLL/include/spdlog/details/registry-inl.h
index 3c6e378b..a60faabc 100644
--- a/NorthstarDLL/include/spdlog/details/registry-inl.h
+++ b/NorthstarDLL/include/spdlog/details/registry-inl.h
@@ -1,313 +1,313 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#ifndef SPDLOG_HEADER_ONLY

-#include <spdlog/details/registry.h>

-#endif

-

-#include <spdlog/common.h>

-#include <spdlog/details/periodic_worker.h>

-#include <spdlog/logger.h>

-#include <spdlog/pattern_formatter.h>

-

-#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER

-// support for the default stdout color logger

-#ifdef _WIN32

-#include <spdlog/sinks/wincolor_sink.h>

-#else

-#include <spdlog/sinks/ansicolor_sink.h>

-#endif

-#endif // SPDLOG_DISABLE_DEFAULT_LOGGER

-

-#include <chrono>

-#include <functional>

-#include <memory>

-#include <string>

-#include <unordered_map>

-

-namespace spdlog {

-namespace details {

-

-SPDLOG_INLINE registry::registry()

-    : formatter_(new pattern_formatter())

-{

-

-#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER

-    // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).

-#ifdef _WIN32

-    auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();

-#else

-    auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();

-#endif

-

-    const char *default_logger_name = "";

-    default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));

-    loggers_[default_logger_name] = default_logger_;

-

-#endif // SPDLOG_DISABLE_DEFAULT_LOGGER

-}

-

-SPDLOG_INLINE registry::~registry() = default;

-

-SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger)

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    register_logger_(std::move(new_logger));

-}

-

-SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger)

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    new_logger->set_formatter(formatter_->clone());

-

-    if (err_handler_)

-    {

-        new_logger->set_error_handler(err_handler_);

-    }

-

-    // set new level according to previously configured level or default level

-    auto it = log_levels_.find(new_logger->name());

-    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;

-    new_logger->set_level(new_level);

-

-    new_logger->flush_on(flush_level_);

-

-    if (backtrace_n_messages_ > 0)

-    {

-        new_logger->enable_backtrace(backtrace_n_messages_);

-    }

-

-    if (automatic_registration_)

-    {

-        register_logger_(std::move(new_logger));

-    }

-}

-

-SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name)

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    auto found = loggers_.find(logger_name);

-    return found == loggers_.end() ? nullptr : found->second;

-}

-

-SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    return default_logger_;

-}

-

-// Return raw ptr to the default logger.

-// To be used directly by the spdlog default api (e.g. spdlog::info)

-// This make the default API faster, but cannot be used concurrently with set_default_logger().

-// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.

-SPDLOG_INLINE logger *registry::get_default_raw()

-{

-    return default_logger_.get();

-}

-

-// set default logger.

-// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.

-SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    // remove previous default logger from the map

-    if (default_logger_ != nullptr)

-    {

-        loggers_.erase(default_logger_->name());

-    }

-    if (new_default_logger != nullptr)

-    {

-        loggers_[new_default_logger->name()] = new_default_logger;

-    }

-    default_logger_ = std::move(new_default_logger);

-}

-

-SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp)

-{

-    std::lock_guard<std::recursive_mutex> lock(tp_mutex_);

-    tp_ = std::move(tp);

-}

-

-SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp()

-{

-    std::lock_guard<std::recursive_mutex> lock(tp_mutex_);

-    return tp_;

-}

-

-// Set global formatter. Each sink in each logger will get a clone of this object

-SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    formatter_ = std::move(formatter);

-    for (auto &l : loggers_)

-    {

-        l.second->set_formatter(formatter_->clone());

-    }

-}

-

-SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages)

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    backtrace_n_messages_ = n_messages;

-

-    for (auto &l : loggers_)

-    {

-        l.second->enable_backtrace(n_messages);

-    }

-}

-

-SPDLOG_INLINE void registry::disable_backtrace()

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    backtrace_n_messages_ = 0;

-    for (auto &l : loggers_)

-    {

-        l.second->disable_backtrace();

-    }

-}

-

-SPDLOG_INLINE void registry::set_level(level::level_enum log_level)

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    for (auto &l : loggers_)

-    {

-        l.second->set_level(log_level);

-    }

-    global_log_level_ = log_level;

-}

-

-SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    for (auto &l : loggers_)

-    {

-        l.second->flush_on(log_level);

-    }

-    flush_level_ = log_level;

-}

-

-SPDLOG_INLINE void registry::flush_every(std::chrono::seconds interval)

-{

-    std::lock_guard<std::mutex> lock(flusher_mutex_);

-    auto clbk = [this]() { this->flush_all(); };

-    periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);

-}

-

-SPDLOG_INLINE void registry::set_error_handler(void (*handler)(const std::string &msg))

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    for (auto &l : loggers_)

-    {

-        l.second->set_error_handler(handler);

-    }

-    err_handler_ = handler;

-}

-

-SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    for (auto &l : loggers_)

-    {

-        fun(l.second);

-    }

-}

-

-SPDLOG_INLINE void registry::flush_all()

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    for (auto &l : loggers_)

-    {

-        l.second->flush();

-    }

-}

-

-SPDLOG_INLINE void registry::drop(const std::string &logger_name)

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    loggers_.erase(logger_name);

-    if (default_logger_ && default_logger_->name() == logger_name)

-    {

-        default_logger_.reset();

-    }

-}

-

-SPDLOG_INLINE void registry::drop_all()

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    loggers_.clear();

-    default_logger_.reset();

-}

-

-// clean all resources and threads started by the registry

-SPDLOG_INLINE void registry::shutdown()

-{

-    {

-        std::lock_guard<std::mutex> lock(flusher_mutex_);

-        periodic_flusher_.reset();

-    }

-

-    drop_all();

-

-    {

-        std::lock_guard<std::recursive_mutex> lock(tp_mutex_);

-        tp_.reset();

-    }

-}

-

-SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex()

-{

-    return tp_mutex_;

-}

-

-SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration)

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    automatic_registration_ = automatic_registration;

-}

-

-SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level)

-{

-    std::lock_guard<std::mutex> lock(logger_map_mutex_);

-    log_levels_ = std::move(levels);

-    auto global_level_requested = global_level != nullptr;

-    global_log_level_ = global_level_requested ? *global_level : global_log_level_;

-

-    for (auto &logger : loggers_)

-    {

-        auto logger_entry = log_levels_.find(logger.first);

-        if (logger_entry != log_levels_.end())

-        {

-            logger.second->set_level(logger_entry->second);

-        }

-        else if (global_level_requested)

-        {

-            logger.second->set_level(*global_level);

-        }

-    }

-}

-

-SPDLOG_INLINE registry &registry::instance()

-{

-    static registry s_instance;

-    return s_instance;

-}

-

-SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)

-{

-    if (loggers_.find(logger_name) != loggers_.end())

-    {

-        throw_spdlog_ex("logger with name '" + logger_name + "' already exists");

-    }

-}

-

-SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger)

-{

-    auto logger_name = new_logger->name();

-    throw_if_exists_(logger_name);

-    loggers_[logger_name] = std::move(new_logger);

-}

-

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/registry.h>
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/details/periodic_worker.h>
+#include <spdlog/logger.h>
+#include <spdlog/pattern_formatter.h>
+
+#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
+// support for the default stdout color logger
+#ifdef _WIN32
+#include <spdlog/sinks/wincolor_sink.h>
+#else
+#include <spdlog/sinks/ansicolor_sink.h>
+#endif
+#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE registry::registry()
+    : formatter_(new pattern_formatter())
+{
+
+#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
+    // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
+#ifdef _WIN32
+    auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
+#else
+    auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
+#endif
+
+    const char *default_logger_name = "";
+    default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
+    loggers_[default_logger_name] = default_logger_;
+
+#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
+}
+
+SPDLOG_INLINE registry::~registry() = default;
+
+SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    register_logger_(std::move(new_logger));
+}
+
+SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    new_logger->set_formatter(formatter_->clone());
+
+    if (err_handler_)
+    {
+        new_logger->set_error_handler(err_handler_);
+    }
+
+    // set new level according to previously configured level or default level
+    auto it = log_levels_.find(new_logger->name());
+    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
+    new_logger->set_level(new_level);
+
+    new_logger->flush_on(flush_level_);
+
+    if (backtrace_n_messages_ > 0)
+    {
+        new_logger->enable_backtrace(backtrace_n_messages_);
+    }
+
+    if (automatic_registration_)
+    {
+        register_logger_(std::move(new_logger));
+    }
+}
+
+SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    auto found = loggers_.find(logger_name);
+    return found == loggers_.end() ? nullptr : found->second;
+}
+
+SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    return default_logger_;
+}
+
+// Return raw ptr to the default logger.
+// To be used directly by the spdlog default api (e.g. spdlog::info)
+// This make the default API faster, but cannot be used concurrently with set_default_logger().
+// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+SPDLOG_INLINE logger *registry::get_default_raw()
+{
+    return default_logger_.get();
+}
+
+// set default logger.
+// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
+SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    // remove previous default logger from the map
+    if (default_logger_ != nullptr)
+    {
+        loggers_.erase(default_logger_->name());
+    }
+    if (new_default_logger != nullptr)
+    {
+        loggers_[new_default_logger->name()] = new_default_logger;
+    }
+    default_logger_ = std::move(new_default_logger);
+}
+
+SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp)
+{
+    std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+    tp_ = std::move(tp);
+}
+
+SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp()
+{
+    std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+    return tp_;
+}
+
+// Set global formatter. Each sink in each logger will get a clone of this object
+SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    formatter_ = std::move(formatter);
+    for (auto &l : loggers_)
+    {
+        l.second->set_formatter(formatter_->clone());
+    }
+}
+
+SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    backtrace_n_messages_ = n_messages;
+
+    for (auto &l : loggers_)
+    {
+        l.second->enable_backtrace(n_messages);
+    }
+}
+
+SPDLOG_INLINE void registry::disable_backtrace()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    backtrace_n_messages_ = 0;
+    for (auto &l : loggers_)
+    {
+        l.second->disable_backtrace();
+    }
+}
+
+SPDLOG_INLINE void registry::set_level(level::level_enum log_level)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->set_level(log_level);
+    }
+    global_log_level_ = log_level;
+}
+
+SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->flush_on(log_level);
+    }
+    flush_level_ = log_level;
+}
+
+SPDLOG_INLINE void registry::flush_every(std::chrono::seconds interval)
+{
+    std::lock_guard<std::mutex> lock(flusher_mutex_);
+    auto clbk = [this]() { this->flush_all(); };
+    periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
+}
+
+SPDLOG_INLINE void registry::set_error_handler(void (*handler)(const std::string &msg))
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->set_error_handler(handler);
+    }
+    err_handler_ = handler;
+}
+
+SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        fun(l.second);
+    }
+}
+
+SPDLOG_INLINE void registry::flush_all()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    for (auto &l : loggers_)
+    {
+        l.second->flush();
+    }
+}
+
+SPDLOG_INLINE void registry::drop(const std::string &logger_name)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    loggers_.erase(logger_name);
+    if (default_logger_ && default_logger_->name() == logger_name)
+    {
+        default_logger_.reset();
+    }
+}
+
+SPDLOG_INLINE void registry::drop_all()
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    loggers_.clear();
+    default_logger_.reset();
+}
+
+// clean all resources and threads started by the registry
+SPDLOG_INLINE void registry::shutdown()
+{
+    {
+        std::lock_guard<std::mutex> lock(flusher_mutex_);
+        periodic_flusher_.reset();
+    }
+
+    drop_all();
+
+    {
+        std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+        tp_.reset();
+    }
+}
+
+SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex()
+{
+    return tp_mutex_;
+}
+
+SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    automatic_registration_ = automatic_registration;
+}
+
+SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level)
+{
+    std::lock_guard<std::mutex> lock(logger_map_mutex_);
+    log_levels_ = std::move(levels);
+    auto global_level_requested = global_level != nullptr;
+    global_log_level_ = global_level_requested ? *global_level : global_log_level_;
+
+    for (auto &logger : loggers_)
+    {
+        auto logger_entry = log_levels_.find(logger.first);
+        if (logger_entry != log_levels_.end())
+        {
+            logger.second->set_level(logger_entry->second);
+        }
+        else if (global_level_requested)
+        {
+            logger.second->set_level(*global_level);
+        }
+    }
+}
+
+SPDLOG_INLINE registry &registry::instance()
+{
+    static registry s_instance;
+    return s_instance;
+}
+
+SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)
+{
+    if (loggers_.find(logger_name) != loggers_.end())
+    {
+        throw_spdlog_ex("logger with name '" + logger_name + "' already exists");
+    }
+}
+
+SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger)
+{
+    auto logger_name = new_logger->name();
+    throw_if_exists_(logger_name);
+    loggers_[logger_name] = std::move(new_logger);
+}
+
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/registry.h b/NorthstarDLL/include/spdlog/details/registry.h
index 404ba02a..b069c3f5 100644
--- a/NorthstarDLL/include/spdlog/details/registry.h
+++ b/NorthstarDLL/include/spdlog/details/registry.h
@@ -1,115 +1,115 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-// Loggers registry of unique name->logger pointer

-// An attempt to create a logger with an already existing name will result with spdlog_ex exception.

-// If user requests a non existing logger, nullptr will be returned

-// This class is thread safe

-

-#include <spdlog/common.h>

-

-#include <chrono>

-#include <functional>

-#include <memory>

-#include <string>

-#include <unordered_map>

-#include <mutex>

-

-namespace spdlog {

-class logger;

-

-namespace details {

-class thread_pool;

-class periodic_worker;

-

-class SPDLOG_API registry

-{

-public:

-    using log_levels = std::unordered_map<std::string, level::level_enum>;

-    registry(const registry &) = delete;

-    registry &operator=(const registry &) = delete;

-

-    void register_logger(std::shared_ptr<logger> new_logger);

-    void initialize_logger(std::shared_ptr<logger> new_logger);

-    std::shared_ptr<logger> get(const std::string &logger_name);

-    std::shared_ptr<logger> default_logger();

-

-    // Return raw ptr to the default logger.

-    // To be used directly by the spdlog default api (e.g. spdlog::info)

-    // This make the default API faster, but cannot be used concurrently with set_default_logger().

-    // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.

-    logger *get_default_raw();

-

-    // set default logger.

-    // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.

-    void set_default_logger(std::shared_ptr<logger> new_default_logger);

-

-    void set_tp(std::shared_ptr<thread_pool> tp);

-

-    std::shared_ptr<thread_pool> get_tp();

-

-    // Set global formatter. Each sink in each logger will get a clone of this object

-    void set_formatter(std::unique_ptr<formatter> formatter);

-

-    void enable_backtrace(size_t n_messages);

-

-    void disable_backtrace();

-

-    void set_level(level::level_enum log_level);

-

-    void flush_on(level::level_enum log_level);

-

-    void flush_every(std::chrono::seconds interval);

-

-    void set_error_handler(void (*handler)(const std::string &msg));

-

-    void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);

-

-    void flush_all();

-

-    void drop(const std::string &logger_name);

-

-    void drop_all();

-

-    // clean all resources and threads started by the registry

-    void shutdown();

-

-    std::recursive_mutex &tp_mutex();

-

-    void set_automatic_registration(bool automatic_registration);

-

-    // set levels for all existing/future loggers. global_level can be null if should not set.

-    void set_levels(log_levels levels, level::level_enum *global_level);

-

-    static registry &instance();

-

-private:

-    registry();

-    ~registry();

-

-    void throw_if_exists_(const std::string &logger_name);

-    void register_logger_(std::shared_ptr<logger> new_logger);

-    bool set_level_from_cfg_(logger *logger);

-    std::mutex logger_map_mutex_, flusher_mutex_;

-    std::recursive_mutex tp_mutex_;

-    std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;

-    log_levels log_levels_;

-    std::unique_ptr<formatter> formatter_;

-    spdlog::level::level_enum global_log_level_ = level::info;

-    level::level_enum flush_level_ = level::off;

-    void (*err_handler_)(const std::string &msg) = nullptr;

-    std::shared_ptr<thread_pool> tp_;

-    std::unique_ptr<periodic_worker> periodic_flusher_;

-    std::shared_ptr<logger> default_logger_;

-    bool automatic_registration_ = true;

-    size_t backtrace_n_messages_ = 0;

-};

-

-} // namespace details

-} // namespace spdlog

-

-#ifdef SPDLOG_HEADER_ONLY

-#include "registry-inl.h"

-#endif

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// Loggers registry of unique name->logger pointer
+// An attempt to create a logger with an already existing name will result with spdlog_ex exception.
+// If user requests a non existing logger, nullptr will be returned
+// This class is thread safe
+
+#include <spdlog/common.h>
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <mutex>
+
+namespace spdlog {
+class logger;
+
+namespace details {
+class thread_pool;
+class periodic_worker;
+
+class SPDLOG_API registry
+{
+public:
+    using log_levels = std::unordered_map<std::string, level::level_enum>;
+    registry(const registry &) = delete;
+    registry &operator=(const registry &) = delete;
+
+    void register_logger(std::shared_ptr<logger> new_logger);
+    void initialize_logger(std::shared_ptr<logger> new_logger);
+    std::shared_ptr<logger> get(const std::string &logger_name);
+    std::shared_ptr<logger> default_logger();
+
+    // Return raw ptr to the default logger.
+    // To be used directly by the spdlog default api (e.g. spdlog::info)
+    // This make the default API faster, but cannot be used concurrently with set_default_logger().
+    // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+    logger *get_default_raw();
+
+    // set default logger.
+    // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
+    void set_default_logger(std::shared_ptr<logger> new_default_logger);
+
+    void set_tp(std::shared_ptr<thread_pool> tp);
+
+    std::shared_ptr<thread_pool> get_tp();
+
+    // Set global formatter. Each sink in each logger will get a clone of this object
+    void set_formatter(std::unique_ptr<formatter> formatter);
+
+    void enable_backtrace(size_t n_messages);
+
+    void disable_backtrace();
+
+    void set_level(level::level_enum log_level);
+
+    void flush_on(level::level_enum log_level);
+
+    void flush_every(std::chrono::seconds interval);
+
+    void set_error_handler(void (*handler)(const std::string &msg));
+
+    void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);
+
+    void flush_all();
+
+    void drop(const std::string &logger_name);
+
+    void drop_all();
+
+    // clean all resources and threads started by the registry
+    void shutdown();
+
+    std::recursive_mutex &tp_mutex();
+
+    void set_automatic_registration(bool automatic_registration);
+
+    // set levels for all existing/future loggers. global_level can be null if should not set.
+    void set_levels(log_levels levels, level::level_enum *global_level);
+
+    static registry &instance();
+
+private:
+    registry();
+    ~registry();
+
+    void throw_if_exists_(const std::string &logger_name);
+    void register_logger_(std::shared_ptr<logger> new_logger);
+    bool set_level_from_cfg_(logger *logger);
+    std::mutex logger_map_mutex_, flusher_mutex_;
+    std::recursive_mutex tp_mutex_;
+    std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
+    log_levels log_levels_;
+    std::unique_ptr<formatter> formatter_;
+    spdlog::level::level_enum global_log_level_ = level::info;
+    level::level_enum flush_level_ = level::off;
+    void (*err_handler_)(const std::string &msg) = nullptr;
+    std::shared_ptr<thread_pool> tp_;
+    std::unique_ptr<periodic_worker> periodic_flusher_;
+    std::shared_ptr<logger> default_logger_;
+    bool automatic_registration_ = true;
+    size_t backtrace_n_messages_ = 0;
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "registry-inl.h"
+#endif
diff --git a/NorthstarDLL/include/spdlog/details/synchronous_factory.h b/NorthstarDLL/include/spdlog/details/synchronous_factory.h
index 1047261e..e1e42268 100644
--- a/NorthstarDLL/include/spdlog/details/synchronous_factory.h
+++ b/NorthstarDLL/include/spdlog/details/synchronous_factory.h
@@ -1,24 +1,24 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#include "registry.h"

-

-namespace spdlog {

-

-// Default logger factory-  creates synchronous loggers

-class logger;

-

-struct synchronous_factory

-{

-    template<typename Sink, typename... SinkArgs>

-    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args)

-    {

-        auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);

-        auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));

-        details::registry::instance().initialize_logger(new_logger);

-        return new_logger;

-    }

-};

-} // namespace spdlog
\ No newline at end of file
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include "registry.h"
+
+namespace spdlog {
+
+// Default logger factory-  creates synchronous loggers
+class logger;
+
+struct synchronous_factory
+{
+    template<typename Sink, typename... SinkArgs>
+    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args)
+    {
+        auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
+        auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));
+        details::registry::instance().initialize_logger(new_logger);
+        return new_logger;
+    }
+};
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/tcp_client-windows.h b/NorthstarDLL/include/spdlog/details/tcp_client-windows.h
index 8085da32..7ee72927 100644
--- a/NorthstarDLL/include/spdlog/details/tcp_client-windows.h
+++ b/NorthstarDLL/include/spdlog/details/tcp_client-windows.h
@@ -1,175 +1,175 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#define WIN32_LEAN_AND_MEAN

-// tcp client helper

-#include <spdlog/common.h>

-#include <spdlog/details/os.h>

-

-#include <winsock2.h>

-#include <windows.h>

-#include <ws2tcpip.h>

-#include <stdlib.h>

-#include <stdio.h>

-#include <string>

-

-#pragma comment(lib, "Ws2_32.lib")

-#pragma comment(lib, "Mswsock.lib")

-#pragma comment(lib, "AdvApi32.lib")

-

-namespace spdlog {

-namespace details {

-class tcp_client

-{

-    SOCKET socket_ = INVALID_SOCKET;

-

-    static bool winsock_initialized_()

-    {

-        SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

-        if (s == INVALID_SOCKET)

-        {

-            return false;

-        }

-        else

-        {

-            closesocket(s);

-            return true;

-        }

-    }

-

-    static void init_winsock_()

-    {

-        WSADATA wsaData;

-        auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData);

-        if (rv != 0)

-        {

-            throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());

-        }

-    }

-

-    static void throw_winsock_error_(const std::string &msg, int last_error)

-    {

-        char buf[512];

-        ::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,

-            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);

-

-        throw_spdlog_ex(fmt::format("tcp_sink - {}: {}", msg, buf));

-    }

-

-public:

-    bool is_connected() const

-    {

-        return socket_ != INVALID_SOCKET;

-    }

-

-    void close()

-    {

-        ::closesocket(socket_);

-        socket_ = INVALID_SOCKET;

-        WSACleanup();

-    }

-

-    SOCKET fd() const

-    {

-        return socket_;

-    }

-

-    ~tcp_client()

-    {

-        close();

-    }

-

-    // try to connect or throw on failure

-    void connect(const std::string &host, int port)

-    {

-        // initialize winsock if needed

-        if (!winsock_initialized_())

-        {

-            init_winsock_();

-        }

-

-        if (is_connected())

-        {

-            close();

-        }

-        struct addrinfo hints

-        {};

-        ZeroMemory(&hints, sizeof(hints));

-

-        hints.ai_family = AF_INET;       // IPv4

-        hints.ai_socktype = SOCK_STREAM; // TCP

-        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value

-        hints.ai_protocol = 0;

-

-        auto port_str = std::to_string(port);

-        struct addrinfo *addrinfo_result;

-        auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);

-        int last_error = 0;

-        if (rv != 0)

-        {

-            last_error = ::WSAGetLastError();

-            WSACleanup();

-            throw_winsock_error_("getaddrinfo failed", last_error);

-        }

-

-        // Try each address until we successfully connect(2).

-

-        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)

-        {

-            socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);

-            if (socket_ == INVALID_SOCKET)

-            {

-                last_error = ::WSAGetLastError();

-                WSACleanup();

-                continue;

-            }

-            if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0)

-            {

-                break;

-            }

-            else

-            {

-                last_error = ::WSAGetLastError();

-                close();

-            }

-        }

-        ::freeaddrinfo(addrinfo_result);

-        if (socket_ == INVALID_SOCKET)

-        {

-            WSACleanup();

-            throw_winsock_error_("connect failed", last_error);

-        }

-

-        // set TCP_NODELAY

-        int enable_flag = 1;

-        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, (char *)&enable_flag, sizeof(enable_flag));

-    }

-

-    // Send exactly n_bytes of the given data.

-    // On error close the connection and throw.

-    void send(const char *data, size_t n_bytes)

-    {

-        size_t bytes_sent = 0;

-        while (bytes_sent < n_bytes)

-        {

-            const int send_flags = 0;

-            auto write_result = ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);

-            if (write_result == SOCKET_ERROR)

-            {

-                int last_error = ::WSAGetLastError();

-                close();

-                throw_winsock_error_("send failed", last_error);

-            }

-

-            if (write_result == 0) // (probably should not happen but in any case..)

-            {

-                break;

-            }

-            bytes_sent += static_cast<size_t>(write_result);

-        }

-    }

-};

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#define WIN32_LEAN_AND_MEAN
+// tcp client helper
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+
+#include <winsock2.h>
+#include <windows.h>
+#include <ws2tcpip.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string>
+
+#pragma comment(lib, "Ws2_32.lib")
+#pragma comment(lib, "Mswsock.lib")
+#pragma comment(lib, "AdvApi32.lib")
+
+namespace spdlog {
+namespace details {
+class tcp_client
+{
+    SOCKET socket_ = INVALID_SOCKET;
+
+    static bool winsock_initialized_()
+    {
+        SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+        if (s == INVALID_SOCKET)
+        {
+            return false;
+        }
+        else
+        {
+            closesocket(s);
+            return true;
+        }
+    }
+
+    static void init_winsock_()
+    {
+        WSADATA wsaData;
+        auto rv = WSAStartup(MAKEWORD(2, 2), &wsaData);
+        if (rv != 0)
+        {
+            throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
+        }
+    }
+
+    static void throw_winsock_error_(const std::string &msg, int last_error)
+    {
+        char buf[512];
+        ::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);
+
+        throw_spdlog_ex(fmt::format("tcp_sink - {}: {}", msg, buf));
+    }
+
+public:
+    bool is_connected() const
+    {
+        return socket_ != INVALID_SOCKET;
+    }
+
+    void close()
+    {
+        ::closesocket(socket_);
+        socket_ = INVALID_SOCKET;
+        WSACleanup();
+    }
+
+    SOCKET fd() const
+    {
+        return socket_;
+    }
+
+    ~tcp_client()
+    {
+        close();
+    }
+
+    // try to connect or throw on failure
+    void connect(const std::string &host, int port)
+    {
+        // initialize winsock if needed
+        if (!winsock_initialized_())
+        {
+            init_winsock_();
+        }
+
+        if (is_connected())
+        {
+            close();
+        }
+        struct addrinfo hints
+        {};
+        ZeroMemory(&hints, sizeof(hints));
+
+        hints.ai_family = AF_INET;       // IPv4
+        hints.ai_socktype = SOCK_STREAM; // TCP
+        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
+        hints.ai_protocol = 0;
+
+        auto port_str = std::to_string(port);
+        struct addrinfo *addrinfo_result;
+        auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
+        int last_error = 0;
+        if (rv != 0)
+        {
+            last_error = ::WSAGetLastError();
+            WSACleanup();
+            throw_winsock_error_("getaddrinfo failed", last_error);
+        }
+
+        // Try each address until we successfully connect(2).
+
+        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)
+        {
+            socket_ = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+            if (socket_ == INVALID_SOCKET)
+            {
+                last_error = ::WSAGetLastError();
+                WSACleanup();
+                continue;
+            }
+            if (::connect(socket_, rp->ai_addr, (int)rp->ai_addrlen) == 0)
+            {
+                break;
+            }
+            else
+            {
+                last_error = ::WSAGetLastError();
+                close();
+            }
+        }
+        ::freeaddrinfo(addrinfo_result);
+        if (socket_ == INVALID_SOCKET)
+        {
+            WSACleanup();
+            throw_winsock_error_("connect failed", last_error);
+        }
+
+        // set TCP_NODELAY
+        int enable_flag = 1;
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, (char *)&enable_flag, sizeof(enable_flag));
+    }
+
+    // Send exactly n_bytes of the given data.
+    // On error close the connection and throw.
+    void send(const char *data, size_t n_bytes)
+    {
+        size_t bytes_sent = 0;
+        while (bytes_sent < n_bytes)
+        {
+            const int send_flags = 0;
+            auto write_result = ::send(socket_, data + bytes_sent, (int)(n_bytes - bytes_sent), send_flags);
+            if (write_result == SOCKET_ERROR)
+            {
+                int last_error = ::WSAGetLastError();
+                close();
+                throw_winsock_error_("send failed", last_error);
+            }
+
+            if (write_result == 0) // (probably should not happen but in any case..)
+            {
+                break;
+            }
+            bytes_sent += static_cast<size_t>(write_result);
+        }
+    }
+};
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/tcp_client.h b/NorthstarDLL/include/spdlog/details/tcp_client.h
index 2fae27fe..9f3bb99e 100644
--- a/NorthstarDLL/include/spdlog/details/tcp_client.h
+++ b/NorthstarDLL/include/spdlog/details/tcp_client.h
@@ -1,146 +1,146 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#ifdef _WIN32

-#error include tcp_client-windows.h instead

-#endif

-

-// tcp client helper

-#include <spdlog/common.h>

-#include <spdlog/details/os.h>

-

-#include <sys/socket.h>

-#include <arpa/inet.h>

-#include <unistd.h>

-#include <netdb.h>

-#include <netinet/tcp.h>

-

-#include <string>

-

-namespace spdlog {

-namespace details {

-class tcp_client

-{

-    int socket_ = -1;

-

-public:

-    bool is_connected() const

-    {

-        return socket_ != -1;

-    }

-

-    void close()

-    {

-        if (is_connected())

-        {

-            ::close(socket_);

-            socket_ = -1;

-        }

-    }

-

-    int fd() const

-    {

-        return socket_;

-    }

-

-    ~tcp_client()

-    {

-        close();

-    }

-

-    // try to connect or throw on failure

-    void connect(const std::string &host, int port)

-    {

-        close();

-        struct addrinfo hints

-        {};

-        memset(&hints, 0, sizeof(struct addrinfo));

-        hints.ai_family = AF_INET;       // IPv4

-        hints.ai_socktype = SOCK_STREAM; // TCP

-        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value

-        hints.ai_protocol = 0;

-

-        auto port_str = std::to_string(port);

-        struct addrinfo *addrinfo_result;

-        auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);

-        if (rv != 0)

-        {

-            auto msg = fmt::format("::getaddrinfo failed: {}", gai_strerror(rv));

-            throw_spdlog_ex(msg);

-        }

-

-        // Try each address until we successfully connect(2).

-        int last_errno = 0;

-        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)

-        {

-#if defined(SOCK_CLOEXEC)

-            const int flags = SOCK_CLOEXEC;

-#else

-            const int flags = 0;

-#endif

-            socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol);

-            if (socket_ == -1)

-            {

-                last_errno = errno;

-                continue;

-            }

-            rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen);

-            if (rv == 0)

-            {

-                break;

-            }

-            last_errno = errno;

-            ::close(socket_);

-            socket_ = -1;

-        }

-        ::freeaddrinfo(addrinfo_result);

-        if (socket_ == -1)

-        {

-            throw_spdlog_ex("::connect failed", last_errno);

-        }

-

-        // set TCP_NODELAY

-        int enable_flag = 1;

-        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, (char *)&enable_flag, sizeof(enable_flag));

-

-        // prevent sigpipe on systems where MSG_NOSIGNAL is not available

-#if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)

-        ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, (char *)&enable_flag, sizeof(enable_flag));

-#endif

-

-#if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)

-#error "tcp_sink would raise SIGPIPE since niether SO_NOSIGPIPE nor MSG_NOSIGNAL are available"

-#endif

-    }

-

-    // Send exactly n_bytes of the given data.

-    // On error close the connection and throw.

-    void send(const char *data, size_t n_bytes)

-    {

-        size_t bytes_sent = 0;

-        while (bytes_sent < n_bytes)

-        {

-#if defined(MSG_NOSIGNAL)

-            const int send_flags = MSG_NOSIGNAL;

-#else

-            const int send_flags = 0;

-#endif

-            auto write_result = ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);

-            if (write_result < 0)

-            {

-                close();

-                throw_spdlog_ex("write(2) failed", errno);

-            }

-

-            if (write_result == 0) // (probably should not happen but in any case..)

-            {

-                break;

-            }

-            bytes_sent += static_cast<size_t>(write_result);

-        }

-    }

-};

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifdef _WIN32
+#error include tcp_client-windows.h instead
+#endif
+
+// tcp client helper
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <netinet/tcp.h>
+
+#include <string>
+
+namespace spdlog {
+namespace details {
+class tcp_client
+{
+    int socket_ = -1;
+
+public:
+    bool is_connected() const
+    {
+        return socket_ != -1;
+    }
+
+    void close()
+    {
+        if (is_connected())
+        {
+            ::close(socket_);
+            socket_ = -1;
+        }
+    }
+
+    int fd() const
+    {
+        return socket_;
+    }
+
+    ~tcp_client()
+    {
+        close();
+    }
+
+    // try to connect or throw on failure
+    void connect(const std::string &host, int port)
+    {
+        close();
+        struct addrinfo hints
+        {};
+        memset(&hints, 0, sizeof(struct addrinfo));
+        hints.ai_family = AF_INET;       // IPv4
+        hints.ai_socktype = SOCK_STREAM; // TCP
+        hints.ai_flags = AI_NUMERICSERV; // port passed as as numeric value
+        hints.ai_protocol = 0;
+
+        auto port_str = std::to_string(port);
+        struct addrinfo *addrinfo_result;
+        auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
+        if (rv != 0)
+        {
+            auto msg = fmt::format("::getaddrinfo failed: {}", gai_strerror(rv));
+            throw_spdlog_ex(msg);
+        }
+
+        // Try each address until we successfully connect(2).
+        int last_errno = 0;
+        for (auto *rp = addrinfo_result; rp != nullptr; rp = rp->ai_next)
+        {
+#if defined(SOCK_CLOEXEC)
+            const int flags = SOCK_CLOEXEC;
+#else
+            const int flags = 0;
+#endif
+            socket_ = ::socket(rp->ai_family, rp->ai_socktype | flags, rp->ai_protocol);
+            if (socket_ == -1)
+            {
+                last_errno = errno;
+                continue;
+            }
+            rv = ::connect(socket_, rp->ai_addr, rp->ai_addrlen);
+            if (rv == 0)
+            {
+                break;
+            }
+            last_errno = errno;
+            ::close(socket_);
+            socket_ = -1;
+        }
+        ::freeaddrinfo(addrinfo_result);
+        if (socket_ == -1)
+        {
+            throw_spdlog_ex("::connect failed", last_errno);
+        }
+
+        // set TCP_NODELAY
+        int enable_flag = 1;
+        ::setsockopt(socket_, IPPROTO_TCP, TCP_NODELAY, (char *)&enable_flag, sizeof(enable_flag));
+
+        // prevent sigpipe on systems where MSG_NOSIGNAL is not available
+#if defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
+        ::setsockopt(socket_, SOL_SOCKET, SO_NOSIGPIPE, (char *)&enable_flag, sizeof(enable_flag));
+#endif
+
+#if !defined(SO_NOSIGPIPE) && !defined(MSG_NOSIGNAL)
+#error "tcp_sink would raise SIGPIPE since niether SO_NOSIGPIPE nor MSG_NOSIGNAL are available"
+#endif
+    }
+
+    // Send exactly n_bytes of the given data.
+    // On error close the connection and throw.
+    void send(const char *data, size_t n_bytes)
+    {
+        size_t bytes_sent = 0;
+        while (bytes_sent < n_bytes)
+        {
+#if defined(MSG_NOSIGNAL)
+            const int send_flags = MSG_NOSIGNAL;
+#else
+            const int send_flags = 0;
+#endif
+            auto write_result = ::send(socket_, data + bytes_sent, n_bytes - bytes_sent, send_flags);
+            if (write_result < 0)
+            {
+                close();
+                throw_spdlog_ex("write(2) failed", errno);
+            }
+
+            if (write_result == 0) // (probably should not happen but in any case..)
+            {
+                break;
+            }
+            bytes_sent += static_cast<size_t>(write_result);
+        }
+    }
+};
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/thread_pool-inl.h b/NorthstarDLL/include/spdlog/details/thread_pool-inl.h
index d70f1135..c1df4361 100644
--- a/NorthstarDLL/include/spdlog/details/thread_pool-inl.h
+++ b/NorthstarDLL/include/spdlog/details/thread_pool-inl.h
@@ -1,129 +1,129 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#ifndef SPDLOG_HEADER_ONLY

-#include <spdlog/details/thread_pool.h>

-#endif

-

-#include <spdlog/common.h>

-#include <cassert>

-

-namespace spdlog {

-namespace details {

-

-SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)

-    : q_(q_max_items)

-{

-    if (threads_n == 0 || threads_n > 1000)

-    {

-        throw_spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "

-                        "range is 1-1000)");

-    }

-    for (size_t i = 0; i < threads_n; i++)

-    {

-        threads_.emplace_back([this, on_thread_start] {

-            on_thread_start();

-            this->thread_pool::worker_loop_();

-        });

-    }

-}

-

-SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)

-    : thread_pool(q_max_items, threads_n, [] {})

-{}

-

-// message all threads to terminate gracefully join them

-SPDLOG_INLINE thread_pool::~thread_pool()

-{

-    SPDLOG_TRY

-    {

-        for (size_t i = 0; i < threads_.size(); i++)

-        {

-            post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);

-        }

-

-        for (auto &t : threads_)

-        {

-            t.join();

-        }

-    }

-    SPDLOG_CATCH_ALL() {}

-}

-

-void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy)

-{

-    async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);

-    post_async_msg_(std::move(async_m), overflow_policy);

-}

-

-void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)

-{

-    post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);

-}

-

-size_t SPDLOG_INLINE thread_pool::overrun_counter()

-{

-    return q_.overrun_counter();

-}

-

-size_t SPDLOG_INLINE thread_pool::queue_size()

-{

-    return q_.size();

-}

-

-void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)

-{

-    if (overflow_policy == async_overflow_policy::block)

-    {

-        q_.enqueue(std::move(new_msg));

-    }

-    else

-    {

-        q_.enqueue_nowait(std::move(new_msg));

-    }

-}

-

-void SPDLOG_INLINE thread_pool::worker_loop_()

-{

-    while (process_next_msg_()) {}

-}

-

-// process next message in the queue

-// return true if this thread should still be active (while no terminate msg

-// was received)

-bool SPDLOG_INLINE thread_pool::process_next_msg_()

-{

-    async_msg incoming_async_msg;

-    bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));

-    if (!dequeued)

-    {

-        return true;

-    }

-

-    switch (incoming_async_msg.msg_type)

-    {

-    case async_msg_type::log: {

-        incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);

-        return true;

-    }

-    case async_msg_type::flush: {

-        incoming_async_msg.worker_ptr->backend_flush_();

-        return true;

-    }

-

-    case async_msg_type::terminate: {

-        return false;

-    }

-

-    default: {

-        assert(false);

-    }

-    }

-

-    return true;

-}

-

-} // namespace details

-} // namespace spdlog

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/thread_pool.h>
+#endif
+
+#include <spdlog/common.h>
+#include <cassert>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
+    : q_(q_max_items)
+{
+    if (threads_n == 0 || threads_n > 1000)
+    {
+        throw_spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
+                        "range is 1-1000)");
+    }
+    for (size_t i = 0; i < threads_n; i++)
+    {
+        threads_.emplace_back([this, on_thread_start] {
+            on_thread_start();
+            this->thread_pool::worker_loop_();
+        });
+    }
+}
+
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
+    : thread_pool(q_max_items, threads_n, [] {})
+{}
+
+// message all threads to terminate gracefully join them
+SPDLOG_INLINE thread_pool::~thread_pool()
+{
+    SPDLOG_TRY
+    {
+        for (size_t i = 0; i < threads_.size(); i++)
+        {
+            post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
+        }
+
+        for (auto &t : threads_)
+        {
+            t.join();
+        }
+    }
+    SPDLOG_CATCH_ALL() {}
+}
+
+void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy)
+{
+    async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
+    post_async_msg_(std::move(async_m), overflow_policy);
+}
+
+void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
+{
+    post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
+}
+
+size_t SPDLOG_INLINE thread_pool::overrun_counter()
+{
+    return q_.overrun_counter();
+}
+
+size_t SPDLOG_INLINE thread_pool::queue_size()
+{
+    return q_.size();
+}
+
+void SPDLOG_INLINE thread_pool::post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
+{
+    if (overflow_policy == async_overflow_policy::block)
+    {
+        q_.enqueue(std::move(new_msg));
+    }
+    else
+    {
+        q_.enqueue_nowait(std::move(new_msg));
+    }
+}
+
+void SPDLOG_INLINE thread_pool::worker_loop_()
+{
+    while (process_next_msg_()) {}
+}
+
+// process next message in the queue
+// return true if this thread should still be active (while no terminate msg
+// was received)
+bool SPDLOG_INLINE thread_pool::process_next_msg_()
+{
+    async_msg incoming_async_msg;
+    bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
+    if (!dequeued)
+    {
+        return true;
+    }
+
+    switch (incoming_async_msg.msg_type)
+    {
+    case async_msg_type::log: {
+        incoming_async_msg.worker_ptr->backend_sink_it_(incoming_async_msg);
+        return true;
+    }
+    case async_msg_type::flush: {
+        incoming_async_msg.worker_ptr->backend_flush_();
+        return true;
+    }
+
+    case async_msg_type::terminate: {
+        return false;
+    }
+
+    default: {
+        assert(false);
+    }
+    }
+
+    return true;
+}
+
+} // namespace details
+} // namespace spdlog
diff --git a/NorthstarDLL/include/spdlog/details/thread_pool.h b/NorthstarDLL/include/spdlog/details/thread_pool.h
index 09ede7ec..61e25252 100644
--- a/NorthstarDLL/include/spdlog/details/thread_pool.h
+++ b/NorthstarDLL/include/spdlog/details/thread_pool.h
@@ -1,121 +1,121 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

-// Distributed under the MIT License (http://opensource.org/licenses/MIT)

-

-#pragma once

-

-#include <spdlog/details/log_msg_buffer.h>

-#include <spdlog/details/mpmc_blocking_q.h>

-#include <spdlog/details/os.h>

-

-#include <chrono>

-#include <memory>

-#include <thread>

-#include <vector>

-#include <functional>

-

-namespace spdlog {

-class async_logger;

-

-namespace details {

-

-using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;

-

-enum class async_msg_type

-{

-    log,

-    flush,

-    terminate

-};

-

-#include <spdlog/details/log_msg_buffer.h>

-// Async msg to move to/from the queue

-// Movable only. should never be copied

-struct async_msg : log_msg_buffer

-{

-    async_msg_type msg_type{async_msg_type::log};

-    async_logger_ptr worker_ptr;

-

-    async_msg() = default;

-    ~async_msg() = default;

-

-    // should only be moved in or out of the queue..

-    async_msg(const async_msg &) = delete;

-

-// support for vs2013 move

-#if defined(_MSC_VER) && _MSC_VER <= 1800

-    async_msg(async_msg &&other)

-        : log_msg_buffer(std::move(other))

-        , msg_type(other.msg_type)

-        , worker_ptr(std::move(other.worker_ptr))

-    {}

-

-    async_msg &operator=(async_msg &&other)

-    {

-        *static_cast<log_msg_buffer *>(this) = std::move(other);

-        msg_type = other.msg_type;

-        worker_ptr = std::move(other.worker_ptr);

-        return *this;

-    }

-#else // (_MSC_VER) && _MSC_VER <= 1800

-    async_msg(async_msg &&) = default;

-    async_msg &operator=(async_msg &&) = default;

-#endif

-

-    // construct from log_msg with given type

-    async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m)

-        : log_msg_buffer{m}

-        , msg_type{the_type}

-        , worker_ptr{std::move(worker)}

-    {}

-

-    async_msg(async_logger_ptr &&worker, async_msg_type the_type)

-        : log_msg_buffer{}

-        , msg_type{the_type}

-        , worker_ptr{std::move(worker)}

-    {}

-

-    explicit async_msg(async_msg_type the_type)

-        : async_msg{nullptr, the_type}

-    {}

-};

-

-class SPDLOG_API thread_pool

-{

-public:

-    using item_type = async_msg;

-    using q_type = details::mpmc_blocking_queue<item_type>;

-

-    thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start);

-    thread_pool(size_t q_max_items, size_t threads_n);

-

-    // message all threads to terminate gracefully join them

-    ~thread_pool();

-

-    thread_pool(const thread_pool &) = delete;

-    thread_pool &operator=(thread_pool &&) = delete;

-

-    void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy);

-    void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);

-    size_t overrun_counter();

-    size_t queue_size();

-

-private:

-    q_type q_;

-

-    std::vector<std::thread> threads_;

-

-    void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy);

-    void worker_loop_();

-

-    // process next message in the queue

-    // return true if this thread should still be active (while no terminate msg

-    // was received)

-    bool process_next_msg_();

-};

-

-} // namespace details

-} // namespace spdlog

-

-#ifdef SPDLOG_HEADER_ONLY

-#include "thread_pool-inl.h"

-#endif

+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg_buffer.h>
+#include <spdlog/details/mpmc_blocking_q.h>
+#include <spdlog/details/os.h>
+
+#include <chrono>
+#include <memory>
+#include <thread>
+#include <vector>
+#include <functional>
+
+namespace spdlog {
+class async_logger;
+
+namespace details {
+
+using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
+
+enum class async_msg_type
+{
+    log,
+    flush,
+    terminate
+};
+
+#include <spdlog/details/log_msg_buffer.h>
+// Async msg to move to/from the queue
+// Movable only. should never be copied
+struct async_msg : log_msg_buffer
+{
+    async_msg_type msg_type{async_msg_type::log};
+    async_logger_ptr worker_ptr;
+
+    async_msg() = default;
+    ~async_msg() = default;
+
+    // should only be moved in or out of the queue..
+    async_msg(const async_msg &) = delete;
+
+// support for vs2013 move
+#if defined(_MSC_VER) && _MSC_VER <= 1800
+    async_msg(async_msg &&other)
+        : log_msg_buffer(std::move(other))
+        , msg_type(other.msg_type)
+        , worker_ptr(std::move(other.worker_ptr))
+    {}
+
+    async_msg &operator=(async_msg &&other)
+    {
+        *static_cast<log_msg_buffer *>(this) = std::move(other);
+        msg_type = other.msg_type;
+        worker_ptr = std::move(other.worker_ptr);
+        return *this;
+    }
+#else // (_MSC_VER) && _MSC_VER <= 1800
+    async_msg(async_msg &&) = default;
+    async_msg &operator=(async_msg &&) = default;
+#endif
+
+    // construct from log_msg with given type
+    async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m)
+        : log_msg_buffer{m}
+        , msg_type{the_type}
+        , worker_ptr{std::move(worker)}
+    {}
+
+    async_msg(async_logger_ptr &&worker, async_msg_type the_type)
+        : log_msg_buffer{}
+        , msg_type{the_type}
+        , worker_ptr{std::move(worker)}
+    {}
+
+    explicit async_msg(async_msg_type the_type)
+        : async_msg{nullptr, the_type}
+    {}
+};
+
+class SPDLOG_API thread_pool
+{
+public:
+    using item_type = async_msg;
+    using q_type = details::mpmc_blocking_queue<item_type>;
+
+    thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start);
+    thread_pool(size_t q_max_items, size_t threads_n);
+
+    // message all threads to terminate gracefully join them
+    ~thread_pool();
+
+    thread_pool(const thread_pool &) = delete;
+    thread_pool &operator=(thread_pool &&) = delete;
+
+    void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy);
+    void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
+    size_t overrun_counter();
+    size_t queue_size();
+
+private:
+    q_type q_;
+
+    std::vector<std::thread> threads_;
+
+    void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy);
+    void worker_loop_();
+
+    // process next message in the queue
+    // return true if this thread should still be active (while no terminate msg
+    // was received)
+    bool process_next_msg_();
+};
+
+} // namespace details
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+#include "thread_pool-inl.h"
+#endif
diff --git a/NorthstarDLL/include/spdlog/details/windows_include.h b/NorthstarDLL/include/spdlog/details/windows_include.h
index ed3c1306..6a2f14f9 100644
--- a/NorthstarDLL/include/spdlog/details/windows_include.h
+++ b/NorthstarDLL/include/spdlog/details/windows_include.h
@@ -1,11 +1,11 @@
-#pragma once

-

-#ifndef NOMINMAX

-#define NOMINMAX // prevent windows redefining min/max

-#endif

-

-#ifndef WIN32_LEAN_AND_MEAN

-#define WIN32_LEAN_AND_MEAN

-#endif

-

-#include <windows.h>

+#pragma once
+
+#ifndef NOMINMAX
+#define NOMINMAX // prevent windows redefining min/max
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>