PatchDataLayerLayout.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once

 
#include "shambase/SourceLocation.hpp"
#include "shambase/exception.hpp"
#include "nlohmann/json_fwd.hpp"
#include "shamrock/patch/FieldVariant.hpp"
#include <sstream>
#include <variant>
#include <vector>
 
namespace shamrock::patch {

    template<class T>
    class FieldDescriptor {
        public:
        using field_T = T;

        std::string name;

        u32 nvar;

        inline FieldDescriptor() : name(""), nvar(1) {};

        inline FieldDescriptor(std::string name, u32 nvar) : nvar(nvar), name(name) {}
    };
 
    class PatchDataLayerLayout {
 
        template<class T>
        using FieldDescriptor = shamrock::patch::FieldDescriptor<T>;
 
        // using var_t = var_t_template<FieldDescriptor>;
        using var_t = FieldVariant<FieldDescriptor>;
 
        std::vector<var_t> fields;
 
        public:
        template<class T>
        void add_field(
            const std::string &field_name, u32 nvar, SourceLocation loc = SourceLocation{});

        [[nodiscard]] bool has_field_name(const std::string &field_name) const;

        template<class T>
        FieldDescriptor<T> get_field(const std::string &field_name);

        template<class T>
        FieldDescriptor<T> get_field(u32 idx);

        template<class T>
        u32 get_field_idx(const std::string &field_name) const;

        template<class T>
        u32 get_field_idx(const std::string &field_name, u32 nvar) const;

        template<class T>
        bool check_field_type(u32 idx);

        template<class T>
        inline bool check_main_field_type() {
            return check_field_type<T>(0);
        }

        [[nodiscard]] inline const var_t &get_main_field_any() const { return fields[0]; }

        std::string get_description_str() const;

        std::vector<std::string> get_field_names();

        template<class Functor>
        inline void for_each_field_any(Functor &&func) const {
            for (auto &f : fields) {
                f.visit([&](auto &arg) {
                    func(arg);
                });
            }
        }

        inline void add_field_t(std::string fname, u32 nvar, std::string type) {
            if (type == "f32") {
                add_field<f32>(fname, nvar);
            } else if (type == "f32_2") {
                add_field<f32_2>(fname, nvar);
            } else if (type == "f32_3") {
                add_field<f32_3>(fname, nvar);
            } else if (type == "f32_4") {
                add_field<f32_4>(fname, nvar);
            } else if (type == "f32_8") {
                add_field<f32_8>(fname, nvar);
            } else if (type == "f32_16") {
                add_field<f32_16>(fname, nvar);
            } else if (type == "f64") {
                add_field<f64>(fname, nvar);
            } else if (type == "f64_2") {
                add_field<f64_2>(fname, nvar);
            } else if (type == "f64_3") {
                add_field<f64_3>(fname, nvar);
            } else if (type == "f64_4") {
                add_field<f64_4>(fname, nvar);
            } else if (type == "f64_8") {
                add_field<f64_8>(fname, nvar);
            } else if (type == "f64_16") {
                add_field<f64_16>(fname, nvar);
            } else if (type == "u32") {
                add_field<u32>(fname, nvar);
            } else if (type == "u64") {
                add_field<u64>(fname, nvar);
            } else if (type == "u32_3") {
                add_field<u32_3>(fname, nvar);
            } else if (type == "u64_3") {
                add_field<u64_3>(fname, nvar);
            } else if (type == "i64_3") {
                add_field<i64_3>(fname, nvar);
            } else {
                throw shambase::make_except_with_loc<std::invalid_argument>(
                    "the select type is not recognized");
            }
        }

        friend bool operator==(const PatchDataLayerLayout &lhs, const PatchDataLayerLayout &rhs);
    };

    void to_json(nlohmann::json &j, const PatchDataLayerLayout &p);

    void from_json(const nlohmann::json &j, PatchDataLayerLayout &p);

    bool operator==(const PatchDataLayerLayout &lhs, const PatchDataLayerLayout &rhs);

    // out of line implementation of the PatchDataLayerLayout
 
    template<class T>
    inline PatchDataLayerLayout::FieldDescriptor<T> PatchDataLayerLayout::get_field(
        const std::string &field_name) {
 
        for (var_t &fvar : fields) {
            if (FieldDescriptor<T> *pval = std::get_if<FieldDescriptor<T>>(&fvar.value)) {
                if (pval->name == field_name) {
                    return *pval;
                }
            }
        }
 
        throw shambase::make_except_with_loc<std::invalid_argument>(
            "the requested field does not exists\n    current table : " + get_description_str());
    }
 
    template<class T>
    inline PatchDataLayerLayout::FieldDescriptor<T> PatchDataLayerLayout::get_field(u32 idx) {
 
        if (FieldDescriptor<T> *pval = std::get_if<FieldDescriptor<T>>(&fields[idx].value)) {
            return *pval;
        }
 
        throw shambase::make_except_with_loc<std::invalid_argument>(
            "the required type does no match at index " + std::to_string(idx)
            + "\n    current table : " + get_description_str());
    }
 
    template<class T>
    inline bool PatchDataLayerLayout::check_field_type(u32 idx) {
        var_t &tmp = fields[idx];
 
        FieldDescriptor<T> *pval = std::get_if<FieldDescriptor<T>>(&tmp.value);
 
        if (pval) {
            return true;
        } else {
            return false;
        }
    }
 
} // namespace shamrock::patch