nested_map.hpp

Go to the documentation of this file.

/*
Copyright (c) 2025 acrion innovations GmbH
Authors: Stefan Zipproth, s.zipproth@acrion.ch
 
This file is part of Cbeam, see https://github.com/acrion/cbeam and https://cbeam.org
 
Cbeam is offered under a commercial and under the AGPL license.
For commercial licensing, contact us at https://acrion.ch/sales. For AGPL licensing, see below.
 
AGPL licensing:
 
Cbeam is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
Cbeam is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Affero General Public License for more details.
 
You should have received a copy of the GNU Affero General Public License
along with Cbeam. If not, see <https://www.gnu.org/licenses/>.
*/
 
#pragma once
 
// no internal headers except runtime_error.hpp should be included here
#include <cbeam/error/runtime_error.hpp> // for cbeam::error:runtime_error
 
#include <cstddef> // for std::size_t
 
#include <map> // for std::map
#include <memory>
#include <string>      // for std::operator""s, std::string, std::string_literals
#include <type_traits> // for std::enable_if, std::is_same
#include <variant>     // for std::get_if
 
namespace cbeam::container
{
    template <typename Key, typename Value>
    struct nested_map
    {
        using table_of_values = std::map<Key, Value>;                  
        using nested_tables   = std::map<Key, nested_map<Key, Value>>; 
        using key_type        = Key;
        using mapped_type     = Value;
 
        nested_map() = default; 
 
        nested_map(std::initializer_list<std::pair<const Key, Value>> init)
        {
            for (const auto& [key, value] : init)
            {
                data[key] = value;
            }
        }
 
        table_of_values data;       
        nested_tables   sub_tables; 

        nested_map& operator=(const nested_map& other)
        {
            if (this == &other)
            {
                return *this;
            }
 
            clear();
            merge(other);
 
            return *this;
        }

        void merge(const nested_map& other)
        {
            for (const auto& it : other.data)
            {
                data[it.first] = it.second;
            }
 
            for (const auto& it : other.sub_tables)
            {
                sub_tables[it.first] = it.second;
            }
        }
 
        void clear()
        {
            data.clear();
            sub_tables.clear();
        }

        template <typename T>
        typename std::enable_if<std::is_same<T, Value>::value, T>::type
        get_mapped_value_or_default(const Key& key) const
        {
            auto it = data.find(key);
 
            if (it == data.end())
            {
                return {};
            }
            else
            {
                return it->second;
            }
        }

        template <typename T>
        typename std::enable_if<!std::is_same<T, Value>::value, T>::type
        get_mapped_value_or_default(const Key& value) const
        {
            auto it = data.find(value);
 
            if (it == data.end())
            {
                return {};
            }
            else
            {
                return get_value_or_default<T>(it->second);
            }
        }

        template <std::size_t T>
        auto get_mapped_value_or_default(const Key& value) const
        {
            auto it = data.find(value);
 
            if (it == data.end())
            {
                return decltype(get_value_or_default<T>(it->second)){};
            }
            else
            {
                return get_value_or_default<T>(it->second);
            }
        }

        template <typename T>
        typename std::enable_if<std::is_same<T, Value>::value, T>::type
        get_mapped_value_or_throw(const Key& value, const std::string& error_msg = {}) const
        {
            using namespace std::string_literals;
 
            typename table_of_values::iterator it = data.find(value);
 
            if (it != data.end())
            {
                return it->second;
            }
 
            throw cbeam::error::runtime_error(error_msg.empty() ? "get_mapped_value_or_throw: missing value"s : error_msg);
        }

        template <typename T>
        typename std::enable_if<!std::is_same<T, Value>::value, T>::type
        get_mapped_value_or_throw(const Key& value, const std::string& error_msg = {}) const
        {
            using namespace std::string_literals;
 
            nested_map*                        instance = const_cast<nested_map*>(this);
            typename table_of_values::iterator it       = instance->data.find(value);
 
            if (it != instance->data.end())
            {
                T* ptr = std::get_if<T>(&it->second);
 
                if (ptr)
                {
                    return *ptr;
                }
                else
                {
                    throw cbeam::error::runtime_error(error_msg.empty() ? "get_mapped_value_or_throw: wrong type of value"s : error_msg);
                }
            }
 
            throw cbeam::error::runtime_error(error_msg.empty() ? "get_mapped_value_or_throw: missing value"s : error_msg);
        }

        template <std::size_t T>
        auto get_mapped_value_or_throw(const Key& value, const std::string& error_msg = {}) const
        {
            using namespace std::string_literals;
 
            auto it = data.find(value);
 
            if (it != data.end())
            {
                auto* ptr = std::get_if<T>(&it->second);
 
                if (ptr)
                {
                    return *ptr;
                }
                else
                {
                    throw cbeam::error::runtime_error(error_msg.empty() ? "get_mapped_value_or_throw: wrong type of value"s : error_msg);
                }
            }
 
            throw cbeam::error::runtime_error(error_msg.empty() ? "get_mapped_value_or_throw: missing value"s : error_msg);
        }
    };
 
    template <typename Key, typename Value>
    inline bool operator==(const nested_map<Key, Value>& lhs, const nested_map<Key, Value>& rhs)
    {
        return lhs.data == rhs.data && lhs.sub_tables == rhs.sub_tables;
    }
}