dictionary.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 - 2026 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <unordered_map>
#include <any>
#include <string>
#include <vector>
 
#include "NeoN/core/demangle.hpp"
#include "NeoN/core/visibility.hpp"
 
namespace NeoN
{
 
void logOutRange(
    const std::out_of_range& e,
    const std::string& key,
    const std::unordered_map<std::string, std::any>& data
);
 
namespace detail
{
 
template<typename HoldType>
struct RefHolder
{
    const HoldType& c;
};
 
}
 
class NEON_TYPE_VISIBLE Dictionary
{
public:
 
    Dictionary() = default;
 
    Dictionary(const std::unordered_map<std::string, std::any>& keyValuePairs);
 
    Dictionary(const std::initializer_list<std::pair<std::string, std::any>>& initList);
 
    void insert(const std::string& key, const std::any& value);
 
    [[nodiscard]] bool contains(const std::string& key) const;
 
    void remove(const std::string& key);
 
    [[nodiscard]] std::any& operator[](const std::string& key);
 
    [[nodiscard]] const std::any& operator[](const std::string& key) const;
 
    template<typename T>
    [[nodiscard]] T& get(const std::string& key)
    {
        try
        {
            return std::any_cast<T&>(operator[](key));
        }
        catch (const std::bad_any_cast& e)
        {
            logBadAnyCast<T>(e, key, data_);
            throw;
        }
    }
 
    template<typename T>
    [[nodiscard]] const T& get(const std::string& key) const
    {
        try
        {
            return std::any_cast<const T&>(operator[](key));
        }
        catch (const std::bad_any_cast& e)
        {
            logBadAnyCast<T>(e, key, data_);
            throw;
        }
    }
 
    template<typename T>
    [[nodiscard]] const T get(const std::string& key, T defaultValue) const
    {
        if (contains(key))
        {
            return T(get<T>(key));
        }
        return defaultValue;
    }
 
    template<typename T>
    [[nodiscard]] bool isType(const std::string& key) const
    {
        return contains(key) && std::any_cast<T>(&data_.at(key));
    }
 
    [[nodiscard]] bool isDict(const std::string& key) const;
 
 
    Dictionary& subDict(const std::string& key);
 
    const Dictionary& subDict(const std::string& key) const;
 
    std::vector<std::string> keys() const;
 
    std::unordered_map<std::string, std::any>& getMap();
 
    const std::unordered_map<std::string, std::any>& getMap() const;
 
    bool empty() const { return data_.empty(); }
 
private:
 
    std::unordered_map<std::string, std::any> data_;
};
 
std::ostream& operator<<(std::ostream& os, const Dictionary& in);
 
} // namespace NeoN