INode.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/memory.hpp"
#include "shambase/stacktrace.hpp"
#include "shambase/string.hpp"
#include "shamsolvergraph/LifetimeTracker.hpp"
#include "shamsolvergraph/edge/IEdge.hpp"
#include "shamsolvergraph/edge/INullOptEdge.hpp"
#include <memory>
#include <vector>
 
namespace shamrock::solvergraph {

    class INode : public std::enable_shared_from_this<INode> {

        std::vector<std::shared_ptr<IEdge>> ro_edges;
        std::vector<std::shared_ptr<IEdge>> rw_edges;

        LifetimeTracker<INode> tracker;
 
        public:
        INode() = default;
 
        INode(const INode &)            = delete; 
        INode &operator=(const INode &) = delete; 

        INode(INode &&) noexcept = default;

        INode &operator=(INode &&) noexcept = default;

        inline u64 get_uuid() const { return tracker.get_uuid(); }

        inline std::shared_ptr<INode> getptr_shared() { return shared_from_this(); }
        inline std::weak_ptr<INode> getptr_weak() { return weak_from_this(); }

        inline std::vector<std::shared_ptr<IEdge>> &get_ro_edges() { return ro_edges; }
        inline std::vector<std::shared_ptr<IEdge>> &get_rw_edges() { return rw_edges; }

        inline void __internal_set_ro_edges(std::vector<std::shared_ptr<IEdge>> new_ro_edges);
        inline void __internal_set_rw_edges(std::vector<std::shared_ptr<IEdge>> new_rw_edges);

        template<class Func>
        void on_edge_ro_edges(Func &&f);

        template<class Func>
        void on_edge_rw_edges(Func &&f);

        virtual ~INode() {
            tracker.trace_destroy();
            __internal_set_ro_edges({});
            __internal_set_rw_edges({});
        }

        template<class T>
        inline const T &get_ro_edge(int slot) {
            return shambase::get_check_ref(std::dynamic_pointer_cast<T>(ro_edges.at(slot)));
        }

        template<class T>
        inline T &get_rw_edge(int slot) {
            return shambase::get_check_ref(std::dynamic_pointer_cast<T>(rw_edges.at(slot)));
        }

        template<class T>
        inline std::optional<std::reference_wrapper<const T>> get_ro_edge_optional(int slot) {
            auto &edge = ro_edges.at(slot);
 
            auto ptr = std::dynamic_pointer_cast<T>(edge);
            if (ptr) {
                return std::cref(*ptr);
            }
 
            if (is_null_opt_edge(edge)) {
                return std::nullopt;
            }
 
            throw shambase::make_except_with_loc<std::invalid_argument>(
                sham::format("Edge is not from the requested type: {}", slot));
        }

        template<class T>
        inline std::optional<std::reference_wrapper<T>> get_rw_edge_optional(int slot) {
            auto &edge = rw_edges.at(slot);
 
            auto ptr = std::dynamic_pointer_cast<T>(edge);
            if (ptr) {
                return std::cref(*ptr);
            }
 
            if (is_null_opt_edge(edge)) {
                return std::nullopt;
            }
 
            throw shambase::make_except_with_loc<std::invalid_argument>(
                sham::format("Edge is not from the requested type: {}", slot));
        }

        inline const IEdge &get_ro_edge_base(int slot) {
            return shambase::get_check_ref(ro_edges.at(slot));
        }
 
        inline const IEdge &get_ro_edge_base(int slot) const {
            return shambase::get_check_ref(ro_edges.at(slot));
        }

        inline IEdge &get_rw_edge_base(int slot) {
            return shambase::get_check_ref(rw_edges.at(slot));
        }
 
        inline const IEdge &get_rw_edge_base(int slot) const {
            return shambase::get_check_ref(rw_edges.at(slot));
        }

        inline void evaluate() {
            // if solvergraph tracing is not enabled the .trace_event has the perf of a if statement
            tracker.trace_event([]() {
                return "evaluate_begin";
            });
            _impl_evaluate_internal();
            tracker.trace_event([]() {
                return "evaluate_end";
            });
        }

        inline std::string get_dot_graph() { return get_dot_graph_partial(); };

        inline std::string get_dot_graph_partial() { return _impl_get_dot_graph_partial(); };

        inline std::string get_dot_graph_node_start() { return _impl_get_dot_graph_node_start(); };
        inline std::string get_dot_graph_node_end() { return _impl_get_dot_graph_node_end(); };

        inline std::string get_tex() { return _impl_get_tex(); };
        inline std::string get_tex_partial() { return _impl_get_tex(); };
        inline std::string get_label() const { return _impl_get_label(); };

        inline virtual std::string print_node_info() const {
            std::string node_info = sham::format("Node info :\n");
            node_info += sham::format(" - Node type : {}\n", typeid(*this).name());
            node_info += sham::format(" - Node UUID : {}\n", get_uuid());
            node_info += sham::format(" - Node label : {}\n", _impl_get_label());
 
            auto append_edges_info = [&](const char *title, const auto &edges) {
                node_info += sham::format(" - {}: {}\n", title, edges.size());
                for (const auto &edge : edges) {
                    const auto &e = *edge; // necessary to avoid -Wpotentially-evaluated-expression
                    node_info += sham::format(
                        "     - Edge ptr = {}, uuid = {}, label = {},\n          type = {} \n",
                        static_cast<void *>(edge.get()),
                        edge->get_uuid(),
                        edge->get_label(),
                        typeid(e).name());
                }
            };
 
            append_edges_info("Node Read Only edges", ro_edges);
            append_edges_info("Node Read Write edges", rw_edges);
 
            return node_info;
        };
 
        protected:
        inline void notify_self_state_update() { tracker.trace_state_update(*this); }

        virtual void _impl_evaluate_internal() = 0;

        virtual std::string _impl_get_label() const = 0;

        virtual std::string _impl_get_dot_graph_partial() const;
        virtual std::string _impl_get_dot_graph_node_start() const;
        virtual std::string _impl_get_dot_graph_node_end() const;

        virtual std::string _impl_get_tex() const = 0;
    };
 
    inline void INode::__internal_set_ro_edges(std::vector<std::shared_ptr<IEdge>> new_ro_edges) {
        for (auto e : ro_edges) {
            // shambase::get_check_ref(e).parent = {};
        }
        this->ro_edges = new_ro_edges;
        for (auto e : ro_edges) {
            // shambase::get_check_ref(e).parent = getptr_weak();
        }
        tracker.trace_state_update(*this);
    }
 
    inline void INode::__internal_set_rw_edges(std::vector<std::shared_ptr<IEdge>> new_rw_edges) {
        for (auto e : rw_edges) {
            // shambase::get_check_ref(e).child = {};
        }
        this->rw_edges = new_rw_edges;
        for (auto e : rw_edges) {
            // shambase::get_check_ref(e).child = getptr_weak();
        }
        tracker.trace_state_update(*this);
    }
 
    template<class Func>
    inline void INode::on_edge_ro_edges(Func &&f) {
        for (auto &in : ro_edges) {
            f(shambase::get_check_ref(in));
        }
    }
 
    template<class Func>
    inline void INode::on_edge_rw_edges(Func &&f) {
        for (auto &out : rw_edges) {
            f(shambase::get_check_ref(out));
        }
    }
 
    inline std::string INode::_impl_get_dot_graph_partial() const {
        std::string node_str
            = sham::format("n_{} [label=\"{}\"];\n", this->get_uuid(), _impl_get_label());
 
        std::string edge_str = "";
        for (auto &in : ro_edges) {
            edge_str += sham::format(
                "e_{} -> n_{} [style=\"dashed\", color=green];\n",
                in->get_uuid(),
                this->get_uuid());
            edge_str += sham::format(
                "e_{} [label=\"{}\",shape=rect, style=filled];\n", in->get_uuid(), in->get_label());
        }
        for (auto &out : rw_edges) {
            edge_str += sham::format(
                "n_{} -> e_{} [style=\"dashed\", color=red];\n", this->get_uuid(), out->get_uuid());
            edge_str += sham::format(
                "e_{} [label=\"{}\",shape=rect, style=filled];\n",
                out->get_uuid(),
                out->get_label());
        }
 
        return sham::format("{}{}", node_str, edge_str);
    };
 
    inline std::string INode::_impl_get_dot_graph_node_start() const {
        return sham::format("n_{}", this->get_uuid());
    }
    inline std::string INode::_impl_get_dot_graph_node_end() const {
        return sham::format("n_{}", this->get_uuid());
    }
 
} // namespace shamrock::solvergraph
 
#define INODE_DECL_RO(type, name) const type &name;
#define INODE_DECL_RW(type, name) type & name;
#define INODE_PARAM_RO(type, name) const std::shared_ptr<type> &name,
#define INODE_PARAM_RW(type, name) const std::shared_ptr<type> &name,
#define INODE_PUSH_RO1(type, name) name,
#define INODE_PUSH_RW1(type, name)
#define INODE_PUSH_RO2(type, name)
#define INODE_PUSH_RW2(type, name) name,
#define INODE_GET_RO(type, name) get_ro_edge<type>(ro++),
#define INODE_GET_RW(type, name) get_rw_edge<type>(rw++),
 
#define INODE_DECL_RO_OPTIONAL(type, name)                                                         \
    const std::optional<std::reference_wrapper<const type>> name;
#define INODE_DECL_RW_OPTIONAL(type, name) const std::optional<std::reference_wrapper<type>> name;
#define INODE_PARAM_RO_OPTIONAL(type, name) const std::optional<std::shared_ptr<type>> &name,
#define INODE_PARAM_RW_OPTIONAL(type, name) const std::optional<std::shared_ptr<type>> &name,
#define INODE_PUSH_RO1_OPTIONAL(type, name) shamrock::solvergraph::obsfucate_null_opt_edge(name),
#define INODE_PUSH_RW1_OPTIONAL(type, name)
#define INODE_PUSH_RO2_OPTIONAL(type, name)
#define INODE_PUSH_RW2_OPTIONAL(type, name) shamrock::solvergraph::obsfucate_null_opt_edge(name),
#define INODE_GET_RO_OPTIONAL(type, name) get_ro_edge_optional<type>(ro++),
#define INODE_GET_RW_OPTIONAL(type, name) get_rw_edge_optional<type>(rw++),
 
// TeX symbol accessors, shared by the plain and optional variants (a null optional edge still
// occupies its slot and reports a placeholder symbol)
#define INODE_TEX_DECL(type, name) std::string name;
#define INODE_TEX_GET_RO(type, name) get_ro_edge_base(ro++).get_tex_symbol(),
#define INODE_TEX_GET_RW(type, name) get_rw_edge_base(rw++).get_tex_symbol(),
#define INODE_TEX_REPLACE(type, name) shambase::replace_all(tex, "{" #name "}", symbols.name);

#define INODE_EXPAND_TEX_SYMBOLS(TEX_DECLS, TEX_GETS, TEX_REPLACES)                                \
                                                                                                   \
    struct EdgesTexSymbols {                                                                       \
        TEX_DECLS                                                                                  \
    };                                                                                             \
                                                                                                   \
    inline EdgesTexSymbols get_edges_tex_symbols() const {                                         \
        int ro = 0;                                                                                \
        int rw = 0;                                                                                \
        return EdgesTexSymbols{TEX_GETS};                                                          \
    }                                                                                              \
                                                                                                   \
    inline void replace_edges_tex_symbols(std::string &tex) const {                                \
        auto symbols = get_edges_tex_symbols();                                                    \
        TEX_REPLACES                                                                               \
    }
 
#define EXPAND_NODE_EDGES(EDGES)                                                                   \
                                                                                                   \
    struct Edges {                                                                                 \
        EDGES(INODE_DECL_RO, INODE_DECL_RW)                                                        \
    };                                                                                             \
                                                                                                   \
    inline void set_edges(                                                                         \
        EDGES(INODE_PARAM_RO, INODE_PARAM_RW) SourceLocation loc = SourceLocation{}) {             \
        __shamrock_log_callsite(loc);                                                              \
                                                                                                   \
        __internal_set_ro_edges({EDGES(INODE_PUSH_RO1, INODE_PUSH_RW1)});                          \
        __internal_set_rw_edges({EDGES(INODE_PUSH_RO2, INODE_PUSH_RW2)});                          \
    }                                                                                              \
                                                                                                   \
    inline Edges get_edges() {                                                                     \
        int ro = 0;                                                                                \
        int rw = 0;                                                                                \
        return Edges{EDGES(INODE_GET_RO, INODE_GET_RW)};                                           \
    }                                                                                              \
                                                                                                   \
    INODE_EXPAND_TEX_SYMBOLS(                                                                      \
        EDGES(INODE_TEX_DECL, INODE_TEX_DECL),                                                     \
        EDGES(INODE_TEX_GET_RO, INODE_TEX_GET_RW),                                                 \
        EDGES(INODE_TEX_REPLACE, INODE_TEX_REPLACE))
 
#define EXPAND_NODE_EDGES_OPTIONAL(EDGES)                                                          \
                                                                                                   \
    struct Edges {                                                                                 \
        EDGES(INODE_DECL_RO, INODE_DECL_RW, INODE_DECL_RO_OPTIONAL, INODE_DECL_RW_OPTIONAL)        \
    };                                                                                             \
                                                                                                   \
    inline void set_edges(                                                                         \
        EDGES(INODE_PARAM_RO, INODE_PARAM_RW, INODE_PARAM_RO_OPTIONAL, INODE_PARAM_RW_OPTIONAL)    \
            SourceLocation loc = SourceLocation{}) {                                               \
        __shamrock_log_callsite(loc);                                                              \
                                                                                                   \
        __internal_set_ro_edges({EDGES(                                                            \
            INODE_PUSH_RO1, INODE_PUSH_RW1, INODE_PUSH_RO1_OPTIONAL, INODE_PUSH_RW1_OPTIONAL)});   \
        __internal_set_rw_edges({EDGES(                                                            \
            INODE_PUSH_RO2, INODE_PUSH_RW2, INODE_PUSH_RO2_OPTIONAL, INODE_PUSH_RW2_OPTIONAL)});   \
    }                                                                                              \
                                                                                                   \
    inline Edges get_edges() {                                                                     \
        int ro = 0;                                                                                \
        int rw = 0;                                                                                \
        return Edges{                                                                              \
            EDGES(INODE_GET_RO, INODE_GET_RW, INODE_GET_RO_OPTIONAL, INODE_GET_RW_OPTIONAL)};      \
    }                                                                                              \
                                                                                                   \
    INODE_EXPAND_TEX_SYMBOLS(                                                                      \
        EDGES(INODE_TEX_DECL, INODE_TEX_DECL, INODE_TEX_DECL, INODE_TEX_DECL),                     \
        EDGES(INODE_TEX_GET_RO, INODE_TEX_GET_RW, INODE_TEX_GET_RO, INODE_TEX_GET_RW),             \
        EDGES(INODE_TEX_REPLACE, INODE_TEX_REPLACE, INODE_TEX_REPLACE, INODE_TEX_REPLACE))