property_tree.hpp

// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_CONFIG_PROPERTY_TREE_HPP_
#define GKO_PUBLIC_CORE_CONFIG_PROPERTY_TREE_HPP_
 
 
#include <cstdint>
#include <limits>
#include <map>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>
 
 
namespace gko {
namespace config {
 

class pnode final {
public:
    using key_type = std::string;
    using map_type = std::map<key_type, pnode>;
    using array_type = std::vector<pnode>;

    enum class tag_t { empty, array, boolean, real, integer, string, map };

    explicit pnode();

    explicit pnode(bool boolean);

    template <typename T,
              std::enable_if_t<std::is_integral<T>::value>* = nullptr>
    explicit pnode(T integer);

    explicit pnode(const std::string& str);

    explicit pnode(const char* str);

    explicit pnode(double real);

    explicit pnode(const array_type& array);

    explicit pnode(const map_type& map);

    explicit operator bool() const noexcept;

    bool operator==(const pnode& rhs) const;

    bool operator!=(const pnode& rhs) const;

    tag_t get_tag() const;

    const array_type& get_array() const;

    const map_type& get_map() const;

    bool get_boolean() const;

    std::int64_t get_integer() const;

    double get_real() const;

    const std::string& get_string() const;

    const pnode& get(const std::string& key) const;

    const pnode& get(int index) const;
 
private:
    void throw_if_not_contain(tag_t tag) const;
 
    static const pnode& empty_node();
 
    tag_t tag_;
    array_type array_;  // for array
    map_type map_;      // for map
    // value
    std::string str_;
    union {
        std::int64_t integer_;
        double real_;
        bool boolean_;
    } union_data_;
};
 
 
template <typename T, std::enable_if_t<std::is_integral<T>::value>*>
pnode::pnode(T integer) : tag_(tag_t::integer)
{
    if (integer > std::numeric_limits<std::int64_t>::max() ||
        (std::is_signed<T>::value &&
         integer < std::numeric_limits<std::int64_t>::min())) {
        throw std::runtime_error("The input is out of the range of int64_t.");
    }
    union_data_.integer_ = static_cast<std::int64_t>(integer);
}
 
 
}  // namespace config
}  // namespace gko
 
#endif  // GKO_PUBLIC_CORE_CONFIG_PROPERTY_TREE_HPP_