Merge pull request #3 from nekernel-org/dev

v0.0.3

1 files changed, 307 insertions, 0 deletions

diff --git a/vendor/toml++/impl/array.inl b/vendor/toml++/impl/array.inl
new file mode 100644
index 0000000..7ae8ee1
--- /dev/null
+++ b/vendor/toml++/impl/array.inl
@@ -0,0 +1,307 @@
+// # This file is a part of toml++ and is subject to the the terms of the MIT license.
+// # Copyright (c) Mark Gillard <mark.gillard@outlook.com.au>
+// # See https://github.com/marzer/tomlplusplus/blob/master/LICENSE for the full license text.
+//  SPDX-License-Identifier: MIT
+#pragma once
+
+// # {{
+#include "preprocessor.hpp"
+#if !TOML_IMPLEMENTATION
+#error This is an implementation-only header.
+#endif
+// # }}
+
+#include "array.hpp"
+#include "header_start.hpp"
+
+TOML_NAMESPACE_START {
+  TOML_EXTERNAL_LINKAGE
+  array::array() noexcept {
+#if TOML_LIFETIME_HOOKS
+    TOML_ARRAY_CREATED;
+#endif
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  array::~array() noexcept {
+#if TOML_LIFETIME_HOOKS
+    TOML_ARRAY_DESTROYED;
+#endif
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  array::array(const impl::array_init_elem* b, const impl::array_init_elem* e) {
+#if TOML_LIFETIME_HOOKS
+    TOML_ARRAY_CREATED;
+#endif
+
+    TOML_ASSERT_ASSUME(b);
+    TOML_ASSERT_ASSUME(e);
+    TOML_ASSERT_ASSUME(b <= e);
+
+    if TOML_UNLIKELY (b == e) return;
+
+    size_t cap{};
+    for (auto it = b; it != e; it++) {
+      if (it->value) cap++;
+    }
+    if TOML_UNLIKELY (!cap) return;
+
+    elems_.reserve(cap);
+    for (; b != e; b++) {
+      if (b->value) elems_.push_back(std::move(b->value));
+    }
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  array::array(const array& other)  //
+      : node(other) {
+    elems_.reserve(other.elems_.size());
+    for (const auto& elem : other) elems_.emplace_back(impl::make_node(elem));
+
+#if TOML_LIFETIME_HOOKS
+    TOML_ARRAY_CREATED;
+#endif
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  array::array(array && other) noexcept  //
+      : node(std::move(other)), elems_(std::move(other.elems_)) {
+#if TOML_LIFETIME_HOOKS
+    TOML_ARRAY_CREATED;
+#endif
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  array& array::operator=(const array& rhs) {
+    if (&rhs != this) {
+      node::operator=(rhs);
+      elems_.clear();
+      elems_.reserve(rhs.elems_.size());
+      for (const auto& elem : rhs) elems_.emplace_back(impl::make_node(elem));
+    }
+    return *this;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  array& array::operator=(array&& rhs) noexcept {
+    if (&rhs != this) {
+      node::operator=(std::move(rhs));
+      elems_ = std::move(rhs.elems_);
+    }
+    return *this;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  void array::preinsertion_resize(size_t idx, size_t count) {
+    TOML_ASSERT(idx <= elems_.size());
+    TOML_ASSERT_ASSUME(count >= 1u);
+    const auto old_size         = elems_.size();
+    const auto new_size         = old_size + count;
+    const auto inserting_at_end = idx == old_size;
+    elems_.resize(new_size);
+    if (!inserting_at_end) {
+      for (size_t left = old_size, right = new_size - 1u; left-- > idx; right--)
+        elems_[right] = std::move(elems_[left]);
+    }
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  void array::insert_at_back(impl::node_ptr && elem) {
+    TOML_ASSERT(elem);
+    elems_.push_back(std::move(elem));
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  array::vector_iterator array::insert_at(const_vector_iterator pos, impl::node_ptr && elem) {
+    return elems_.insert(pos, std::move(elem));
+  }
+
+  TOML_PURE_GETTER
+  TOML_EXTERNAL_LINKAGE
+  bool array::is_homogeneous(node_type ntype) const noexcept {
+    if (elems_.empty()) return false;
+
+    if (ntype == node_type::none) ntype = elems_[0]->type();
+
+    for (const auto& val : elems_)
+      if (val->type() != ntype) return false;
+
+    return true;
+  }
+
+  TOML_PURE_GETTER
+  TOML_EXTERNAL_LINKAGE
+  bool array::is_homogeneous(node_type ntype, node * &first_nonmatch) noexcept {
+    if (elems_.empty()) {
+      first_nonmatch = {};
+      return false;
+    }
+    if (ntype == node_type::none) ntype = elems_[0]->type();
+    for (const auto& val : elems_) {
+      if (val->type() != ntype) {
+        first_nonmatch = val.get();
+        return false;
+      }
+    }
+    return true;
+  }
+
+  TOML_PURE_GETTER
+  TOML_EXTERNAL_LINKAGE
+  bool array::is_homogeneous(node_type ntype, const node*& first_nonmatch) const noexcept {
+    node*      fnm    = nullptr;
+    const auto result = const_cast<array&>(*this).is_homogeneous(ntype, fnm);
+    first_nonmatch    = fnm;
+    return result;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  node& array::at(size_t index) {
+#if TOML_COMPILER_HAS_EXCEPTIONS
+
+    return *elems_.at(index);
+
+#else
+
+    auto n = get(index);
+    TOML_ASSERT_ASSUME(n && "element index not found in array!");
+    return *n;
+
+#endif
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  void array::reserve(size_t new_capacity) {
+    elems_.reserve(new_capacity);
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  void array::shrink_to_fit() {
+    elems_.shrink_to_fit();
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  void array::truncate(size_t new_size) {
+    if (new_size < elems_.size()) elems_.resize(new_size);
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  array::iterator array::erase(const_iterator pos) noexcept {
+    return iterator{elems_.erase(const_vector_iterator{pos})};
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  array::iterator array::erase(const_iterator first, const_iterator last) noexcept {
+    return iterator{elems_.erase(const_vector_iterator{first}, const_vector_iterator{last})};
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  size_t array::total_leaf_count() const noexcept {
+    size_t leaves{};
+    for (size_t i = 0, e = elems_.size(); i < e; i++) {
+      auto arr = elems_[i]->as_array();
+      leaves += arr ? arr->total_leaf_count() : size_t{1};
+    }
+    return leaves;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  void array::flatten_child(array && child, size_t & dest_index) noexcept {
+    for (size_t i = 0, e = child.size(); i < e; i++) {
+      auto type = child.elems_[i]->type();
+      if (type == node_type::array) {
+        array& arr = *reinterpret_cast<array*>(child.elems_[i].get());
+        if (!arr.empty()) flatten_child(std::move(arr), dest_index);
+      } else
+        elems_[dest_index++] = std::move(child.elems_[i]);
+    }
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  array& array::flatten()& {
+    if (elems_.empty()) return *this;
+
+    bool   requires_flattening   = false;
+    size_t size_after_flattening = elems_.size();
+    for (size_t i = elems_.size(); i-- > 0u;) {
+      auto arr = elems_[i]->as_array();
+      if (!arr) continue;
+      size_after_flattening--;  // discount the array itself
+      const auto leaf_count = arr->total_leaf_count();
+      if (leaf_count > 0u) {
+        requires_flattening = true;
+        size_after_flattening += leaf_count;
+      } else
+        elems_.erase(elems_.cbegin() + static_cast<ptrdiff_t>(i));
+    }
+
+    if (!requires_flattening) return *this;
+
+    elems_.reserve(size_after_flattening);
+
+    size_t i = 0;
+    while (i < elems_.size()) {
+      auto arr = elems_[i]->as_array();
+      if (!arr) {
+        i++;
+        continue;
+      }
+
+      impl::node_ptr arr_storage = std::move(elems_[i]);
+      const auto     leaf_count  = arr->total_leaf_count();
+      if (leaf_count > 1u) preinsertion_resize(i + 1u, leaf_count - 1u);
+      flatten_child(std::move(*arr), i);  // increments i
+    }
+
+    return *this;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  array& array::prune(bool recursive)& noexcept {
+    if (elems_.empty()) return *this;
+
+    for (size_t i = elems_.size(); i-- > 0u;) {
+      if (auto arr = elems_[i]->as_array()) {
+        if (recursive) arr->prune(true);
+        if (arr->empty()) elems_.erase(elems_.cbegin() + static_cast<ptrdiff_t>(i));
+      } else if (auto tbl = elems_[i]->as_table()) {
+        if (recursive) tbl->prune(true);
+        if (tbl->empty()) elems_.erase(elems_.cbegin() + static_cast<ptrdiff_t>(i));
+      }
+    }
+
+    return *this;
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  void array::pop_back() noexcept {
+    elems_.pop_back();
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  void array::clear() noexcept {
+    elems_.clear();
+  }
+
+  TOML_EXTERNAL_LINKAGE
+  bool TOML_CALLCONV array::equal(const array& lhs, const array& rhs) noexcept {
+    if (&lhs == &rhs) return true;
+    if (lhs.elems_.size() != rhs.elems_.size()) return false;
+    for (size_t i = 0, e = lhs.elems_.size(); i < e; i++) {
+      const auto  lhs_type = lhs.elems_[i]->type();
+      const node& rhs_     = *rhs.elems_[i];
+      const auto  rhs_type = rhs_.type();
+      if (lhs_type != rhs_type) return false;
+
+      const bool equal = lhs.elems_[i]->visit([&](const auto& lhs_) noexcept {
+        return lhs_ == *reinterpret_cast<std::remove_reference_t<decltype(lhs_)>*>(&rhs_);
+      });
+      if (!equal) return false;
+    }
+    return true;
+  }
+}
+TOML_NAMESPACE_END;
+
+#include "header_end.hpp"