Data.hpp

// Reaktoro is a unified framework for modeling chemically reactive systems.
//
// Copyright © 2014-2024 Allan Leal
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library. If not, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
// Reaktoro includes
#include <Reaktoro/Common/Exception.hpp>
#include <Reaktoro/Common/TraitsUtils.hpp>
#include <Reaktoro/Common/Types.hpp>
 
namespace Reaktoro {
 
class Data
{
public:
    Data();
 
    static auto parse(Chars text) -> Data;
 
    static auto parse(String const& text) -> Data;
 
    static auto parse(std::istream& text) -> Data;
 
    static auto parseYaml(Chars text) -> Data;
 
    static auto parseYaml(String const& text) -> Data;
 
    static auto parseYaml(std::istream& text) -> Data;
 
    static auto parseJson(Chars text) -> Data;
 
    static auto parseJson(String const& text) -> Data;
 
    static auto parseJson(std::istream& text) -> Data;
 
    static auto load(String const& path) -> Data;
 
    static auto loadYaml(String const& path) -> Data;
 
    static auto loadJson(String const& path) -> Data;
 
    auto asBoolean() const -> bool;
 
    auto asString() const -> String const&;
 
    auto asInteger() const -> int;
 
    auto asFloat() const -> double;
 
    auto asDict() const -> Dict<String, Data> const&;
 
    auto asList() const -> Vec<Data> const&;
 
    auto asNull() const -> Nullptr;
 
    auto isBoolean() const -> bool;
 
    auto isString() const -> bool;
 
    auto isInteger() const -> bool;
 
    auto isFloat() const -> bool;
 
    auto isDict() const -> bool;
 
    auto isList() const -> bool;
 
    auto isNull() const -> bool;
 
    auto operator[](String const& key) const -> Data const&;
 
    auto operator[](Index const& index) const -> Data const&;
 
    auto operator[](String const& key) -> Data&;
 
    auto operator[](Index const& index) -> Data&;
 
    auto at(String const& key) const -> Data const&;
 
    auto at(Index const& index) const -> Data const&;
 
    struct Opt
    {
        Data const*const ptrdata = nullptr;
 
        template<typename T>
        auto to(T& obj) const -> void
        {
            if(ptrdata)
                obj = ptrdata->as<T>();
        }
    };
 
    auto optional(String const& key) const -> Opt;
 
    auto required(String const& key) const -> Data const&;
 
    auto with(String const& attribute, String const& value) const -> Data const&;
 
    auto add(Data data) -> void;
 
    auto add(String const& key, Data data) -> void;
 
    auto update(Data const& data) -> void;
 
    auto reset() -> void;
 
    auto exists(String const& key) const -> bool;
 
    auto dump() const -> String;
 
    auto dumpYaml() const -> String;
 
    auto dumpJson() const -> String;
 
    auto save(String const& filepath) const -> void;
 
    auto saveYaml(String const& filepath) const -> void;
 
    auto saveJson(String const& filepath) const -> void;
 
    auto repr() const -> String;
 
    template<typename T>
    struct Encode
    {
        static auto eval(Data& data, T const& obj) -> void
        {
            errorif(true, "Cannot convert an object of type ", typeid(T).name(), " to Data because Encode::eval was not defined for it.");
        }
    };
 
    template<typename T>
    struct Decode
    {
        static auto eval(Data const& data, T& obj) -> void
        {
            errorif(true, "Cannot convert an object a Data object to an object of type ", typeid(T).name(), " because Decode::eval was not defined for it.");
        }
    };
 
    template<typename T>
    auto operator=(T const& obj) -> Data&
    {
        assign(obj);
        return *this;
    }
 
    template<typename T>
    explicit operator T() const
    {
        return as<T>();
    }
 
    template<typename T>
    Data(T const& obj)
    {
        assign(obj);
    }
 
    template<typename T>
    auto assign(T const& obj) -> void
    {
        if constexpr(isOneOf<T, bool, int, double, String, Vec<Data>, Dict<String, Data>, Nullptr>)
            tree = obj;
        else if constexpr(Reaktoro::isInteger<T>)
            tree = static_cast<int>(obj);
        else if constexpr(isFloatingPoint<T> || isSame<T, real>)
            tree = static_cast<double>(obj);
        else {
            reset();
            Encode<T>::eval(*this, obj);
        }
    }
 
    auto assign(char obj) -> void
    {
        tree = String(1, obj);
    }
 
    auto assign(Chars obj) -> void
    {
        tree = String(obj);
    }
 
    template<typename T>
    auto as() const -> T
    {
        if constexpr(isOneOf<T, bool, String, Vec<Data>, Dict<String, Data>>) {
            const bool convertable = std::any_cast<T>(&tree);
            errorif(!convertable, "Could not convert from Data object to an object of type ", typeid(T).name(), " because this is not the type of the data stored nor it is convertible to that type.");
            return std::any_cast<T const&>(tree);
        }
        if constexpr(Reaktoro::isInteger<T>)
            return asInteger();
        if constexpr(isFloatingPoint<T> || isSame<T, real>)
            return asFloat();
        else {
            T obj;
            Decode<T>::eval(*this, obj);
            return obj;
        }
    }
 
    template<typename T>
    auto to(T& obj) const -> void
    {
        obj = as<T>();
    }
 
private:
    Any tree;
};
 
#define REAKTORO_DATA_ENCODE_DECLARE(T, ...)                                      \
   \
    template<__VA_ARGS__> struct Data::Encode<T> { static auto eval(Data& data, const T& obj) -> void; };
 
#define REAKTORO_DATA_ENCODE_DEFINE(T, ...)                                       \
           \
    auto Data::Encode<T>::eval(Data& data, const T& obj) -> void
 
#define REAKTORO_DATA_DECODE_DECLARE(T, ...)                                      \
 \
    template<__VA_ARGS__> struct Data::Decode<T> { static auto eval(const Data& data, T& obj) -> void; };
 
#define REAKTORO_DATA_DECODE_DEFINE(T, ...)                                       \
         \
    auto Data::Decode<T>::eval(const Data& data, T& obj) -> void
 
#define REAKTORO_COMMA ,
 
REAKTORO_DATA_ENCODE_DECLARE(Vec<T>, typename T);
REAKTORO_DATA_DECODE_DECLARE(Vec<T>, typename T);
 
REAKTORO_DATA_ENCODE_DECLARE(Array<T REAKTORO_COMMA N>, typename T, std::size_t N);
REAKTORO_DATA_DECODE_DECLARE(Array<T REAKTORO_COMMA N>, typename T, std::size_t N);
 
REAKTORO_DATA_ENCODE_DECLARE(Pair<A REAKTORO_COMMA B>, typename A, typename B);
REAKTORO_DATA_DECODE_DECLARE(Pair<A REAKTORO_COMMA B>, typename A, typename B);
 
REAKTORO_DATA_ENCODE_DECLARE(Map<K REAKTORO_COMMA T>, typename K, typename T);
REAKTORO_DATA_DECODE_DECLARE(Map<K REAKTORO_COMMA T>, typename K, typename T);
 
REAKTORO_DATA_ENCODE_DECLARE(Dict<K REAKTORO_COMMA T>, typename K, typename T);
REAKTORO_DATA_DECODE_DECLARE(Dict<K REAKTORO_COMMA T>, typename K, typename T);
 
template<typename T>
REAKTORO_DATA_ENCODE_DEFINE(Vec<T>, typename T)
{
    for(auto const& x : obj)
        data.add(x);
}
 
template<typename T>
REAKTORO_DATA_DECODE_DEFINE(Vec<T>, typename T)
{
    for(auto const& x : data.asList())
        obj.push_back(x.as<T>());
}
 
template<typename T, std::size_t N>
REAKTORO_DATA_ENCODE_DEFINE(Array<T REAKTORO_COMMA N>, typename T, std::size_t N)
{
    for(auto const& x : obj)
        data.add(x);
}
 
template<typename T, std::size_t N>
REAKTORO_DATA_DECODE_DEFINE(Array<T REAKTORO_COMMA N>, typename T, std::size_t N)
{
    auto i = 0;
    for(auto const& x : data.asList())
        obj[i++] = x.as<T>();
}
 
template<typename A, typename B>
REAKTORO_DATA_ENCODE_DEFINE(Pair<A REAKTORO_COMMA B>, typename A, typename B)
{
    data.add(obj.first);
    data.add(obj.second);
}
 
template<typename A, typename B>
REAKTORO_DATA_DECODE_DEFINE(Pair<A REAKTORO_COMMA B>, typename A, typename B)
{
    auto const& l = data.asList();
    errorif(l.size() != 2, "Converting from Data to Pair requires the Data object to be a list with two entries.");
    obj.first = l[0].as<A>();
    obj.second = l[1].as<B>();
}
 
template<typename K, typename T>
REAKTORO_DATA_ENCODE_DEFINE(Map<K REAKTORO_COMMA T>, typename K, typename T)
{
    for(auto const& [k, v] : obj)
        data.add(k, v);
}
 
template<typename K, typename T>
REAKTORO_DATA_DECODE_DEFINE(Map<K REAKTORO_COMMA T>, typename K, typename T)
{
    for(auto const& [k, v] : data.asDict())
        obj[k] = v.template as<T>();
}
 
template<typename K, typename T>
REAKTORO_DATA_ENCODE_DEFINE(Dict<K REAKTORO_COMMA T>, typename K, typename T)
{
    for(auto const& [k, v] : obj)
        data.add(k, v);
}
 
template<typename K, typename T>
REAKTORO_DATA_DECODE_DEFINE(Dict<K REAKTORO_COMMA T>, typename K, typename T)
{
    for(auto const& [k, v] : data.asDict())
        obj[k] = v.template as<T>();
}
 
} // namespace Reaktoro