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 "shambase/string.hpp"
#include "shamrock/patch/FieldVariant.hpp"
#include "shamsys/legacy/log.hpp"
#include <nlohmann/json.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{});
 
        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 void PatchDataLayerLayout::add_field(
        const std::string &field_name, u32 nvar, SourceLocation loc) {
        bool found = false;
 
        for (var_t &fvar : fields) {
            fvar.visit([&](auto &arg) {
                if (field_name == arg.name) {
                    found = true;
                }
            });
        }
 
        if (found) {
            throw shambase::make_except_with_loc<std::invalid_argument>(
                "add_field -> the name already exists");
        }
 
        shamlog_debug_ln(
            "PatchDataLayerLayout",
            "adding field :",
            field_name,
            nvar,
            "loc :",
            loc.format_one_line());
 
        fields.push_back(var_t{FieldDescriptor<T>(field_name, nvar)});
    }
 
    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 u32 PatchDataLayerLayout::get_field_idx(const std::string &field_name) const {
        for (u32 i = 0; i < fields.size(); i++) {
            if (const FieldDescriptor<T> *pval
                = std::get_if<FieldDescriptor<T>>(&fields[i].value)) {
                if (pval->name == field_name) {
                    return i;
                }
            }
        }
 
        throw shambase::make_except_with_loc<std::invalid_argument>(shambase::format(
            "the requested field does not exists\n    the function : {}\n    the field name : {}\n "
            "   current table : \n{}",
            __PRETTY_FUNCTION__,
            field_name,
            get_description_str()));
    }
 
    template<class T>
    inline u32 PatchDataLayerLayout::get_field_idx(const std::string &field_name, u32 nvar) const {
        for (u32 i = 0; i < fields.size(); i++) {
            if (const FieldDescriptor<T> *pval
                = std::get_if<FieldDescriptor<T>>(&fields[i].value)) {
                if ((pval->name == field_name) && (pval->nvar == nvar)) {
                    return i;
                }
            }
        }
 
        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 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