path.inl

Go to the documentation of this file.

// # 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 "at_path.hpp"
#include "path.hpp"
#include "print_to_stream.hpp"
TOML_DISABLE_WARNINGS;
#if TOML_INT_CHARCONV
#include <charconv>
#endif
#include <sstream>
TOML_ENABLE_WARNINGS;
#include "header_start.hpp"
 
// #=====================================================================================================================
// # toml::path_component
// #=====================================================================================================================
 
TOML_NAMESPACE_START {
  TOML_EXTERNAL_LINKAGE
  path_component::path_component()  //
      : type_{path_component_type::key} {
    store_key("", value_storage_);
  }
 
  TOML_EXTERNAL_LINKAGE
  path_component::path_component(size_t index) noexcept  //
      : type_(path_component_type::array_index) {
    store_index(index, value_storage_);
  }
 
  TOML_EXTERNAL_LINKAGE
  path_component::path_component(std::string_view key)  //
      : type_(path_component_type::key) {
    store_key(key, value_storage_);
  }
 
#if TOML_ENABLE_WINDOWS_COMPAT
 
  TOML_EXTERNAL_LINKAGE
  path_component::path_component(std::wstring_view key)  //
      : path_component(impl::narrow(key)) {}
 
#endif
 
  TOML_EXTERNAL_LINKAGE
  path_component::path_component(const path_component& pc)  //
      : type_{pc.type_} {
    if (type_ == path_component_type::array_index)
      store_index(pc.index(), value_storage_);
    else
      store_key(pc.key(), value_storage_);
  }
 
  TOML_EXTERNAL_LINKAGE
  path_component::path_component(path_component && pc) noexcept  //
      : type_{pc.type_} {
    if (type_ == path_component_type::array_index)
      store_index(pc.index_ref(), value_storage_);
    else
      store_key(std::move(pc.key_ref()), value_storage_);
  }
 
  TOML_EXTERNAL_LINKAGE
  path_component& path_component::operator=(const path_component& rhs) {
    if (type_ != rhs.type_) {
      destroy();
 
      type_ = rhs.type_;
      if (type_ == path_component_type::array_index)
        store_index(rhs.index(), value_storage_);
      else
        store_key(rhs.key(), value_storage_);
    } else {
      if (type_ == path_component_type::array_index)
        index_ref() = rhs.index();
      else
        key_ref() = rhs.key();
    }
    return *this;
  }
 
  TOML_EXTERNAL_LINKAGE
  path_component& path_component::operator=(path_component&& rhs) noexcept {
    if (type_ != rhs.type_) {
      destroy();
 
      type_ = rhs.type_;
      if (type_ == path_component_type::array_index)
        store_index(rhs.index(), value_storage_);
      else
        store_key(std::move(rhs.key_ref()), value_storage_);
    } else {
      if (type_ == path_component_type::array_index)
        index_ref() = rhs.index();
      else
        key_ref() = std::move(rhs.key_ref());
    }
    return *this;
  }
 
  TOML_PURE_GETTER
  TOML_EXTERNAL_LINKAGE
  bool TOML_CALLCONV path_component::equal(const path_component& lhs,
                                           const path_component& rhs) noexcept {
    // Different comparison depending on contents
    if (lhs.type_ != rhs.type_) return false;
 
    if (lhs.type_ == path_component_type::array_index)
      return lhs.index() == rhs.index();
    else  // path_component_type::key
      return lhs.key() == rhs.key();
  }
 
  TOML_EXTERNAL_LINKAGE
  path_component& path_component::operator=(size_t new_index) noexcept {
    // If currently a key, string will need to be destroyed regardless
    destroy();
 
    type_ = path_component_type::array_index;
    store_index(new_index, value_storage_);
 
    return *this;
  }
 
  TOML_EXTERNAL_LINKAGE
  path_component& path_component::operator=(std::string_view new_key) {
    if (type_ == path_component_type::key)
      key_ref() = new_key;
    else {
      type_ = path_component_type::key;
      store_key(new_key, value_storage_);
    }
 
    return *this;
  }
 
#if TOML_ENABLE_WINDOWS_COMPAT
 
  TOML_EXTERNAL_LINKAGE
  path_component& path_component::operator=(std::wstring_view new_key) {
    if (type_ == path_component_type::key)
      key_ref() = impl::narrow(new_key);
    else {
      type_ = path_component_type::key;
      store_key(impl::narrow(new_key), value_storage_);
    }
 
    return *this;
  }
 
#endif
}
TOML_NAMESPACE_END;
 
// #=====================================================================================================================
// # toml::path
// #=====================================================================================================================
 
TOML_ANON_NAMESPACE_START {
  TOML_INTERNAL_LINKAGE
  bool parse_path_into(std::string_view path_str, std::vector<path_component> & components) {
    using components_type = std::remove_reference_t<decltype(components)>;
 
    const auto original_size = components.size();
 
    static constexpr auto on_key = [](void* data, std::string_view key) -> bool {
      auto& comps = *static_cast<components_type*>(data);
      comps.emplace_back(key);
      return true;
    };
 
    static constexpr auto on_index = [](void* data, size_t index) -> bool {
      auto& comps = *static_cast<components_type*>(data);
      comps.emplace_back(index);
      return true;
    };
 
    if (!impl::parse_path(path_str, &components, on_key, on_index)) {
      components.resize(original_size);
      return false;
    }
 
    return true;
  }
}
TOML_ANON_NAMESPACE_END;
 
TOML_NAMESPACE_START {
  TOML_EXTERNAL_LINKAGE
  void path::print_to(std::ostream & os) const {
    bool root = true;
    for (const auto& component : components_) {
      if (component.type() == path_component_type::key)  // key
      {
        if (!root) impl::print_to_stream(os, '.');
        impl::print_to_stream(os, component.key());
      } else if (component.type() == path_component_type::array_index)  // array
      {
        impl::print_to_stream(os, '[');
        impl::print_to_stream(os, component.index());
        impl::print_to_stream(os, ']');
      }
      root = false;
    }
  }
 
  TOML_PURE_GETTER
  TOML_EXTERNAL_LINKAGE
  bool TOML_CALLCONV path::equal(const path& lhs, const path& rhs) noexcept {
    return lhs.components_ == rhs.components_;
  }
 
  // #=== constructors =================================================
 
  TOML_EXTERNAL_LINKAGE
  path::path(std::string_view str)  //
  {
    TOML_ANON_NAMESPACE::parse_path_into(str, components_);
  }
 
#if TOML_ENABLE_WINDOWS_COMPAT
 
  TOML_EXTERNAL_LINKAGE
  path::path(std::wstring_view str)  //
      : path(impl::narrow(str)) {}
 
#endif
 
  // #=== assignment =================================================
 
  TOML_EXTERNAL_LINKAGE
  path& path::operator=(std::string_view rhs) {
    components_.clear();
    TOML_ANON_NAMESPACE::parse_path_into(rhs, components_);
    return *this;
  }
 
#if TOML_ENABLE_WINDOWS_COMPAT
 
  TOML_EXTERNAL_LINKAGE
  path& path::operator=(std::wstring_view rhs) {
    return assign(impl::narrow(rhs));
  }
 
#endif
 
  // #=== appending =================================================
 
  TOML_EXTERNAL_LINKAGE
  path& path::operator+=(const path& rhs) {
    components_.insert(components_.cend(), rhs.begin(), rhs.end());
    return *this;
  }
 
  TOML_EXTERNAL_LINKAGE
  path& path::operator+=(path&& rhs) {
    components_.insert(components_.end(), std::make_move_iterator(rhs.components_.begin()),
                       std::make_move_iterator(rhs.components_.end()));
    return *this;
  }
 
  TOML_EXTERNAL_LINKAGE
  path& path::operator+=(std::string_view str) {
    TOML_ANON_NAMESPACE::parse_path_into(str, components_);
    return *this;
  }
 
#if TOML_ENABLE_WINDOWS_COMPAT
 
  TOML_EXTERNAL_LINKAGE
  path& path::operator+=(std::wstring_view str) {
    return *this += impl::narrow(str);
  }
 
#endif
 
  // #=== prepending =================================================
 
  TOML_EXTERNAL_LINKAGE
  path& path::prepend(const path& source) {
    components_.insert(components_.begin(), source.components_.begin(), source.components_.end());
    return *this;
  }
 
  TOML_EXTERNAL_LINKAGE
  path& path::prepend(path && source) {
    components_.insert(components_.begin(), std::make_move_iterator(source.components_.begin()),
                       std::make_move_iterator(source.components_.end()));
    return *this;
  }
 
  TOML_EXTERNAL_LINKAGE
  path& path::prepend(std::string_view source) {
    return prepend(path{source});
  }
 
#if TOML_ENABLE_WINDOWS_COMPAT
 
  TOML_EXTERNAL_LINKAGE
  path& path::prepend(std::wstring_view source) {
    return prepend(impl::narrow(source));
  }
 
#endif
 
  // #=== string conversion =================================================
 
  TOML_EXTERNAL_LINKAGE
  std::string path::str() const {
    if (empty()) return "";
 
    std::ostringstream ss;
    print_to(ss);
    return std::move(ss).str();
  }
 
#if TOML_ENABLE_WINDOWS_COMPAT
 
  TOML_EXTERNAL_LINKAGE
  std::wstring path::wide_str() const {
    return impl::widen(str());
  }
 
#endif
 
  // #=== equality and comparison =================================================
 
  TOML_EXTERNAL_LINKAGE
  void path::clear() noexcept {
    components_.clear();
  }
 
  TOML_EXTERNAL_LINKAGE
  path& path::truncate(size_t n) {
    n = n > components_.size() ? components_.size() : n;
 
    auto it_end = components_.end();
    components_.erase(it_end - static_cast<int>(n), it_end);
 
    return *this;
  }
 
  TOML_EXTERNAL_LINKAGE
  path path::truncated(size_t n) const {
    path truncated_path{};
 
    n = n > components_.size() ? components_.size() : n;
 
    // Copy all components except one
    // Need at least two path components to have a parent, since if there is
    // only one path component, the parent is the root/null path ""
    truncated_path.components_.insert(truncated_path.components_.begin(), components_.begin(),
                                      components_.end() - static_cast<int>(n));
 
    return truncated_path;
  }
 
  TOML_EXTERNAL_LINKAGE
  path path::parent() const {
    return truncated(1);
  }
 
  TOML_EXTERNAL_LINKAGE
  path path::leaf(size_t n) const {
    path leaf_path{};
 
    n = n > components_.size() ? components_.size() : n;
 
    if (n > 0) {
      leaf_path.components_.insert(leaf_path.components_.begin(),
                                   components_.end() - static_cast<int>(n), components_.end());
    }
 
    return leaf_path;
  }
 
  TOML_EXTERNAL_LINKAGE
  path path::subpath(std::vector<path_component>::const_iterator start,
                     std::vector<path_component>::const_iterator end) const {
    if (start >= end) return {};
 
    path subpath;
    subpath.components_.insert(subpath.components_.begin(), start, end);
    return subpath;
  }
 
  TOML_EXTERNAL_LINKAGE
  path path::subpath(size_t start, size_t length) const {
    return subpath(begin() + static_cast<int>(start), begin() + static_cast<int>(start + length));
  }
}
TOML_NAMESPACE_END;
 
// #=====================================================================================================================
// # at_path() overloads for toml::path
// #=====================================================================================================================
 
TOML_NAMESPACE_START {
  TOML_EXTERNAL_LINKAGE
  node_view<node> TOML_CALLCONV at_path(node & root, const toml::path& path) noexcept {
    // early-exit sanity-checks
    if (root.is_value()) return {};
    if (auto tbl = root.as_table(); tbl && tbl->empty()) return {};
    if (auto arr = root.as_array(); arr && arr->empty()) return {};
 
    node* current = &root;
 
    for (const auto& component : path) {
      auto type = component.type();
      if (type == path_component_type::array_index) {
        const auto current_array = current->as<array>();
        if (!current_array) return {};  // not an array, using array index doesn't work
 
        current = current_array->get(component.index());
      } else if (type == path_component_type::key) {
        const auto current_table = current->as<table>();
        if (!current_table) return {};
 
        current = current_table->get(component.key());
      } else {
        // Error: invalid component
        return {};
      }
 
      if (!current) return {};  // not found
    }
 
    return node_view{current};
  }
 
  TOML_EXTERNAL_LINKAGE
  node_view<const node> TOML_CALLCONV at_path(const node& root, const toml::path& path) noexcept {
    return node_view<const node>{at_path(const_cast<node&>(root), path).node()};
  }
}
TOML_NAMESPACE_END;
 
#include "header_end.hpp"