882d9d1c34
also: - renamed header files to .hpp - updated conformance tests - minor documentation fixes
319 lines
6.1 KiB
C++
319 lines
6.1 KiB
C++
//# 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 "table.hpp"
|
|
#include "node_view.hpp"
|
|
#include "header_start.hpp"
|
|
|
|
TOML_NAMESPACE_START
|
|
{
|
|
TOML_EXTERNAL_LINKAGE
|
|
table::table() noexcept
|
|
{
|
|
#if TOML_LIFETIME_HOOKS
|
|
TOML_TABLE_CREATED;
|
|
#endif
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
table::~table() noexcept
|
|
{
|
|
#if TOML_LIFETIME_HOOKS
|
|
TOML_TABLE_DESTROYED;
|
|
#endif
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
table::table(const impl::table_init_pair* b, const impl::table_init_pair* e)
|
|
{
|
|
#if TOML_LIFETIME_HOOKS
|
|
TOML_TABLE_CREATED;
|
|
#endif
|
|
|
|
TOML_ASSERT_ASSUME(b);
|
|
TOML_ASSERT_ASSUME(e);
|
|
TOML_ASSERT_ASSUME(b <= e);
|
|
|
|
if TOML_UNLIKELY(b == e)
|
|
return;
|
|
|
|
for (; b != e; b++)
|
|
{
|
|
if (!b->value) // empty node_views
|
|
continue;
|
|
|
|
map_.insert_or_assign(std::move(b->key), std::move(b->value));
|
|
}
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
table::table(const table& other) //
|
|
: node(other),
|
|
inline_{ other.inline_ }
|
|
{
|
|
for (auto&& [k, v] : other.map_)
|
|
map_.emplace_hint(map_.end(), k, impl::make_node(*v));
|
|
|
|
#if TOML_LIFETIME_HOOKS
|
|
TOML_TABLE_CREATED;
|
|
#endif
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
table::table(table && other) noexcept //
|
|
: node(std::move(other)),
|
|
map_{ std::move(other.map_) },
|
|
inline_{ other.inline_ }
|
|
{
|
|
#if TOML_LIFETIME_HOOKS
|
|
TOML_TABLE_CREATED;
|
|
#endif
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
table& table::operator=(const table& rhs)
|
|
{
|
|
if (&rhs != this)
|
|
{
|
|
node::operator=(rhs);
|
|
map_.clear();
|
|
for (auto&& [k, v] : rhs.map_)
|
|
map_.emplace_hint(map_.end(), k, impl::make_node(*v));
|
|
inline_ = rhs.inline_;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
table& table::operator=(table&& rhs) noexcept
|
|
{
|
|
if (&rhs != this)
|
|
{
|
|
node::operator=(std::move(rhs));
|
|
map_ = std::move(rhs.map_);
|
|
inline_ = rhs.inline_;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
TOML_PURE_GETTER
|
|
TOML_EXTERNAL_LINKAGE
|
|
bool table::is_homogeneous(node_type ntype) const noexcept
|
|
{
|
|
if (map_.empty())
|
|
return false;
|
|
|
|
if (ntype == node_type::none)
|
|
ntype = map_.cbegin()->second->type();
|
|
|
|
for (auto&& [k, v] : map_)
|
|
{
|
|
TOML_UNUSED(k);
|
|
if (v->type() != ntype)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
TOML_PURE_GETTER
|
|
TOML_EXTERNAL_LINKAGE
|
|
bool table::is_homogeneous(node_type ntype, node * &first_nonmatch) noexcept
|
|
{
|
|
if (map_.empty())
|
|
{
|
|
first_nonmatch = {};
|
|
return false;
|
|
}
|
|
if (ntype == node_type::none)
|
|
ntype = map_.cbegin()->second->type();
|
|
for (const auto& [k, v] : map_)
|
|
{
|
|
TOML_UNUSED(k);
|
|
if (v->type() != ntype)
|
|
{
|
|
first_nonmatch = v.get();
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
TOML_PURE_GETTER
|
|
TOML_EXTERNAL_LINKAGE
|
|
bool table::is_homogeneous(node_type ntype, const node*& first_nonmatch) const noexcept
|
|
{
|
|
node* fnm = nullptr;
|
|
const auto result = const_cast<table&>(*this).is_homogeneous(ntype, fnm);
|
|
first_nonmatch = fnm;
|
|
return result;
|
|
}
|
|
|
|
TOML_PURE_GETTER
|
|
TOML_EXTERNAL_LINKAGE
|
|
node* table::get(std::string_view key) noexcept
|
|
{
|
|
if (auto it = map_.find(key); it != map_.end())
|
|
return it->second.get();
|
|
return nullptr;
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
node& table::at(std::string_view key)
|
|
{
|
|
auto n = get(key);
|
|
|
|
#if TOML_COMPILER_HAS_EXCEPTIONS
|
|
|
|
if (!n)
|
|
{
|
|
auto err = "key '"s;
|
|
err.append(key);
|
|
err.append("' not found in table"sv);
|
|
throw std::out_of_range{ err };
|
|
}
|
|
|
|
#else
|
|
|
|
TOML_ASSERT_ASSUME(n && "key not found in table!");
|
|
|
|
#endif
|
|
|
|
return *n;
|
|
}
|
|
|
|
TOML_PURE_GETTER
|
|
TOML_EXTERNAL_LINKAGE
|
|
table::map_iterator table::get_lower_bound(std::string_view key) noexcept
|
|
{
|
|
return map_.lower_bound(key);
|
|
}
|
|
|
|
TOML_PURE_GETTER
|
|
TOML_EXTERNAL_LINKAGE
|
|
table::iterator table::find(std::string_view key) noexcept
|
|
{
|
|
return iterator{ map_.find(key) };
|
|
}
|
|
|
|
TOML_PURE_GETTER
|
|
TOML_EXTERNAL_LINKAGE
|
|
table::const_iterator table::find(std::string_view key) const noexcept
|
|
{
|
|
return const_iterator{ map_.find(key) };
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
table::map_iterator table::erase(const_map_iterator pos) noexcept
|
|
{
|
|
return map_.erase(pos);
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
table::map_iterator table::erase(const_map_iterator begin, const_map_iterator end) noexcept
|
|
{
|
|
return map_.erase(begin, end);
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
size_t table::erase(std::string_view key) noexcept
|
|
{
|
|
if (auto it = map_.find(key); it != map_.end())
|
|
{
|
|
map_.erase(it);
|
|
return size_t{ 1 };
|
|
}
|
|
return size_t{};
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
table& table::prune(bool recursive)& noexcept
|
|
{
|
|
if (map_.empty())
|
|
return *this;
|
|
|
|
for (auto it = map_.begin(); it != map_.end();)
|
|
{
|
|
if (auto arr = it->second->as_array())
|
|
{
|
|
if (recursive)
|
|
arr->prune(true);
|
|
|
|
if (arr->empty())
|
|
{
|
|
it = map_.erase(it);
|
|
continue;
|
|
}
|
|
}
|
|
else if (auto tbl = it->second->as_table())
|
|
{
|
|
if (recursive)
|
|
tbl->prune(true);
|
|
|
|
if (tbl->empty())
|
|
{
|
|
it = map_.erase(it);
|
|
continue;
|
|
}
|
|
}
|
|
it++;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
void table::clear() noexcept
|
|
{
|
|
map_.clear();
|
|
}
|
|
|
|
TOML_EXTERNAL_LINKAGE
|
|
table::map_iterator table::insert_with_hint(const_iterator hint, key && k, impl::node_ptr && v)
|
|
{
|
|
return map_.emplace_hint(const_map_iterator{ hint }, std::move(k), std::move(v));
|
|
}
|
|
|
|
TOML_PURE_GETTER
|
|
TOML_EXTERNAL_LINKAGE
|
|
bool TOML_CALLCONV table::equal(const table& lhs, const table& rhs) noexcept
|
|
{
|
|
if (&lhs == &rhs)
|
|
return true;
|
|
if (lhs.map_.size() != rhs.map_.size())
|
|
return false;
|
|
|
|
for (auto l = lhs.map_.begin(), r = rhs.map_.begin(), e = lhs.map_.end(); l != e; l++, r++)
|
|
{
|
|
if (l->first != r->first)
|
|
return false;
|
|
|
|
const auto lhs_type = l->second->type();
|
|
const node& rhs_ = *r->second;
|
|
const auto rhs_type = rhs_.type();
|
|
if (lhs_type != rhs_type)
|
|
return false;
|
|
|
|
const bool equal = l->second->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"
|