Restructure dependencies and update to C++20

- Nuked static_assert from almost everywhere in the project
- Nuked binary dependency support. Might add one later though
- Separated dependency headers into a separate include subdirectory
- Grafted a thirdpartylegalnotices.txt generator from RITEG
- Pushed development snapshot version to 2126 (26th week of 2025)

1 files changed, 0 insertions, 228 deletions

diff --git a/deps/include/spdlog/fmt/bundled/args.h b/deps/include/spdlog/fmt/bundled/args.h
deleted file mode 100644
index ddbe013..0000000
--- a/deps/include/spdlog/fmt/bundled/args.h
+++ /dev/null
@@ -1,228 +0,0 @@
-// Formatting library for C++ - dynamic argument lists

-//

-// Copyright (c) 2012 - present, Victor Zverovich

-// All rights reserved.

-//

-// For the license information refer to format.h.

-

-#ifndef FMT_ARGS_H_

-#define FMT_ARGS_H_

-

-#ifndef FMT_MODULE

-#  include <functional>  // std::reference_wrapper

-#  include <memory>      // std::unique_ptr

-#  include <vector>

-#endif

-

-#include "format.h"  // std_string_view

-

-FMT_BEGIN_NAMESPACE

-

-namespace detail {

-

-template <typename T> struct is_reference_wrapper : std::false_type {};

-template <typename T>

-struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};

-

-template <typename T> auto unwrap(const T& v) -> const T& { return v; }

-template <typename T>

-auto unwrap(const std::reference_wrapper<T>& v) -> const T& {

-  return static_cast<const T&>(v);

-}

-

-// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC

-// 2022 (v17.10.0).

-//

-// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for

-// templates it doesn't complain about inability to deduce single translation

-// unit for placing vtable. So node is made a fake template.

-template <typename = void> struct node {

-  virtual ~node() = default;

-  std::unique_ptr<node<>> next;

-};

-

-class dynamic_arg_list {

-  template <typename T> struct typed_node : node<> {

-    T value;

-

-    template <typename Arg>

-    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}

-

-    template <typename Char>

-    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)

-        : value(arg.data(), arg.size()) {}

-  };

-

-  std::unique_ptr<node<>> head_;

-

- public:

-  template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {

-    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));

-    auto& value = new_node->value;

-    new_node->next = std::move(head_);

-    head_ = std::move(new_node);

-    return value;

-  }

-};

-}  // namespace detail

-

-/**

- * A dynamic list of formatting arguments with storage.

- *

- * It can be implicitly converted into `fmt::basic_format_args` for passing

- * into type-erased formatting functions such as `fmt::vformat`.

- */

-template <typename Context>

-class dynamic_format_arg_store

-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409

-    // Workaround a GCC template argument substitution bug.

-    : public basic_format_args<Context>

-#endif

-{

- private:

-  using char_type = typename Context::char_type;

-

-  template <typename T> struct need_copy {

-    static constexpr detail::type mapped_type =

-        detail::mapped_type_constant<T, Context>::value;

-

-    enum {

-      value = !(detail::is_reference_wrapper<T>::value ||

-                std::is_same<T, basic_string_view<char_type>>::value ||

-                std::is_same<T, detail::std_string_view<char_type>>::value ||

-                (mapped_type != detail::type::cstring_type &&

-                 mapped_type != detail::type::string_type &&

-                 mapped_type != detail::type::custom_type))

-    };

-  };

-

-  template <typename T>

-  using stored_type = conditional_t<

-      std::is_convertible<T, std::basic_string<char_type>>::value &&

-          !detail::is_reference_wrapper<T>::value,

-      std::basic_string<char_type>, T>;

-

-  // Storage of basic_format_arg must be contiguous.

-  std::vector<basic_format_arg<Context>> data_;

-  std::vector<detail::named_arg_info<char_type>> named_info_;

-

-  // Storage of arguments not fitting into basic_format_arg must grow

-  // without relocation because items in data_ refer to it.

-  detail::dynamic_arg_list dynamic_args_;

-

-  friend class basic_format_args<Context>;

-

-  auto get_types() const -> unsigned long long {

-    return detail::is_unpacked_bit | data_.size() |

-           (named_info_.empty()

-                ? 0ULL

-                : static_cast<unsigned long long>(detail::has_named_args_bit));

-  }

-

-  auto data() const -> const basic_format_arg<Context>* {

-    return named_info_.empty() ? data_.data() : data_.data() + 1;

-  }

-

-  template <typename T> void emplace_arg(const T& arg) {

-    data_.emplace_back(detail::make_arg<Context>(arg));

-  }

-

-  template <typename T>

-  void emplace_arg(const detail::named_arg<char_type, T>& arg) {

-    if (named_info_.empty()) {

-      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};

-      data_.insert(data_.begin(), {zero_ptr, 0});

-    }

-    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));

-    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {

-      data->pop_back();

-    };

-    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>

-        guard{&data_, pop_one};

-    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});

-    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};

-    guard.release();

-  }

-

- public:

-  constexpr dynamic_format_arg_store() = default;

-

-  /**

-   * Adds an argument into the dynamic store for later passing to a formatting

-   * function.

-   *

-   * Note that custom types and string types (but not string views) are copied

-   * into the store dynamically allocating memory if necessary.

-   *

-   * **Example**:

-   *

-   *     fmt::dynamic_format_arg_store<fmt::format_context> store;

-   *     store.push_back(42);

-   *     store.push_back("abc");

-   *     store.push_back(1.5f);

-   *     std::string result = fmt::vformat("{} and {} and {}", store);

-   */

-  template <typename T> void push_back(const T& arg) {

-    if (detail::const_check(need_copy<T>::value))

-      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));

-    else

-      emplace_arg(detail::unwrap(arg));

-  }

-

-  /**

-   * Adds a reference to the argument into the dynamic store for later passing

-   * to a formatting function.

-   *

-   * **Example**:

-   *

-   *     fmt::dynamic_format_arg_store<fmt::format_context> store;

-   *     char band[] = "Rolling Stones";

-   *     store.push_back(std::cref(band));

-   *     band[9] = 'c'; // Changing str affects the output.

-   *     std::string result = fmt::vformat("{}", store);

-   *     // result == "Rolling Scones"

-   */

-  template <typename T> void push_back(std::reference_wrapper<T> arg) {

-    static_assert(

-        need_copy<T>::value,

-        "objects of built-in types and string views are always copied");

-    emplace_arg(arg.get());

-  }

-

-  /**

-   * Adds named argument into the dynamic store for later passing to a

-   * formatting function. `std::reference_wrapper` is supported to avoid

-   * copying of the argument. The name is always copied into the store.

-   */

-  template <typename T>

-  void push_back(const detail::named_arg<char_type, T>& arg) {

-    const char_type* arg_name =

-        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();

-    if (detail::const_check(need_copy<T>::value)) {

-      emplace_arg(

-          fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));

-    } else {

-      emplace_arg(fmt::arg(arg_name, arg.value));

-    }

-  }

-

-  /// Erase all elements from the store.

-  void clear() {

-    data_.clear();

-    named_info_.clear();

-    dynamic_args_ = detail::dynamic_arg_list();

-  }

-

-  /// Reserves space to store at least `new_cap` arguments including

-  /// `new_cap_named` named arguments.

-  void reserve(size_t new_cap, size_t new_cap_named) {

-    FMT_ASSERT(new_cap >= new_cap_named,

-               "Set of arguments includes set of named arguments");

-    data_.reserve(new_cap);

-    named_info_.reserve(new_cap_named);

-  }

-};

-

-FMT_END_NAMESPACE

-

-#endif  // FMT_ARGS_H_