SolverGraph.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/exception.hpp"
#include "shambase/memory.hpp"
#include "shamsolvergraph/edge/IEdge.hpp"
#include "shamsolvergraph/node/INode.hpp"
#include <unordered_map>
#include <algorithm>
#include <functional>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace shamrock::solvergraph {
 
    using SolverGraphNodeCheck = std::function<bool(const std::shared_ptr<INode> &node)>;
    using SolverGraphEdgeCheck = std::function<bool(const std::shared_ptr<IEdge> &edge)>;
 
    struct SolverGraphConstraint {
        std::string name;
        SolverGraphNodeCheck node_check;
        SolverGraphEdgeCheck edge_check;
 
        inline static SolverGraphConstraint no_constraint() {
            return {.name = {}, .node_check = nullptr, .edge_check = nullptr};
        }
 
        inline bool check_node(const std::shared_ptr<INode> &node) const {
            if (!bool(node)) {
                throw shambase::make_except_with_loc<std::invalid_argument>(shambase::format(
                    "node == nullptr is not allowed, please pass a shared pointer with a valid "
                    "node"));
            }
            if (!node_check) {
                return true;
            }
            return (node_check) (node);
        }
 
        inline bool check_edge(const std::shared_ptr<IEdge> &edge) const {
            if (!bool(edge)) {
                throw shambase::make_except_with_loc<std::invalid_argument>(shambase::format(
                    "edge == nullptr is not allowed, please pass a shared pointer with a valid "
                    "edge"));
            }
            if (!edge_check) {
                return true;
            }
            return (edge_check) (edge);
        }
 
        inline bool is_active() const { return bool(node_check) || bool(edge_check); }
    };

    class SolverGraph {
        std::unordered_map<std::string, std::shared_ptr<INode>> nodes = {};

        std::unordered_map<std::string, std::shared_ptr<IEdge>> edges = {};
 
        SolverGraphConstraint constraint = SolverGraphConstraint::no_constraint();
 
        protected:
        explicit SolverGraph(SolverGraphConstraint graph_constraint)
            : constraint(std::move(graph_constraint)) {}
 
        public:
        // base getters and setters
 
        SolverGraph() = default;

        inline static SolverGraph with_constraint(SolverGraphConstraint graph_constraint) {
            return SolverGraph{std::move(graph_constraint)};
        }

        inline std::shared_ptr<INode> register_node_ptr_base(
            const std::string &name, std::shared_ptr<INode> node) {
 
            if (!constraint.check_node(node)) {
                shambase::throw_with_loc<std::invalid_argument>(shambase::format(
                    "Solvergraph constraint '{}' rejected node '{}' (label='{}', uuid={})",
                    constraint.name,
                    name,
                    node->get_label(),
                    node->get_uuid()));
            }
 
            const auto [it, inserted] = nodes.try_emplace(name, std::move(node));
            if (!inserted) {
                shambase::throw_with_loc<std::invalid_argument>(
                    shambase::format("Node already exists: {}", name));
            }
            return it->second;
        }

        inline std::shared_ptr<IEdge> register_edge_ptr_base(
            const std::string &name, std::shared_ptr<IEdge> edge) {
 
            if (!constraint.check_edge(edge)) {
                shambase::throw_with_loc<std::invalid_argument>(shambase::format(
                    "Solvergraph constraint '{}' rejected edge '{}' (label='{}', uuid={})",
                    constraint.name,
                    name,
                    edge->get_label(),
                    edge->get_uuid()));
            }
 
            const auto [it, inserted] = edges.try_emplace(name, std::move(edge));
            if (!inserted) {
                shambase::throw_with_loc<std::invalid_argument>(
                    shambase::format("Edge already exists: {}", name));
            }
            return it->second;
        }

        inline std::shared_ptr<INode> &get_node_ptr_base(const std::string &name) {
            auto it = nodes.find(name);
            if (it == nodes.end()) {
                shambase::throw_with_loc<std::invalid_argument>(
                    shambase::format("Node does not exist: {}", name));
            }
            return it->second;
        }

        inline const std::shared_ptr<INode> &get_node_ptr_base(const std::string &name) const {
            auto it = nodes.find(name);
            if (it == nodes.end()) {
                shambase::throw_with_loc<std::invalid_argument>(
                    shambase::format("Node does not exist: {}", name));
            }
            return it->second;
        }

        inline std::shared_ptr<IEdge> &get_edge_ptr_base(const std::string &name) {
            auto it = edges.find(name);
            if (it == edges.end()) {
                shambase::throw_with_loc<std::invalid_argument>(
                    shambase::format("Edge does not exist: {}", name));
            }
            return it->second;
        }

        inline const std::shared_ptr<IEdge> &get_edge_ptr_base(const std::string &name) const {
            auto it = edges.find(name);
            if (it == edges.end()) {
                shambase::throw_with_loc<std::invalid_argument>(
                    shambase::format("Edge does not exist: {}", name));
            }
            return it->second;
        }

        inline bool has_node(const std::string &name) const {
            return nodes.find(name) != nodes.end();
        }

        inline bool has_edge(const std::string &name) const {
            return edges.find(name) != edges.end();
        }

        // generic getters

        inline INode &get_node_ref_base(const std::string &name) {
            return shambase::get_check_ref(get_node_ptr_base(name));
        }

        inline const INode &get_node_ref_base(const std::string &name) const {
            return shambase::get_check_ref(get_node_ptr_base(name));
        }

        inline IEdge &get_edge_ref_base(const std::string &name) {
            return shambase::get_check_ref(get_edge_ptr_base(name));
        }

        inline const IEdge &get_edge_ref_base(const std::string &name) const {
            return shambase::get_check_ref(get_edge_ptr_base(name));
        }

        // templated register and getters

        template<class T>
        inline std::shared_ptr<T> register_node(const std::string &name, T &&node) {
            static_assert(std::is_base_of<INode, T>::value, "T must derive from INode");
            register_node_ptr_base(name, std::make_shared<T>(std::forward<T>(node)));
            return get_node_ptr<T>(name);
        }

        template<class T>
        inline std::shared_ptr<T> register_edge(const std::string &name, T &&edge) {
            static_assert(std::is_base_of<IEdge, T>::value, "T must derive from IEdge");
            register_edge_ptr_base(name, std::make_shared<T>(std::forward<T>(edge)));
            return get_edge_ptr<T>(name);
        }

        template<class T>
        inline std::shared_ptr<T> get_node_ptr(const std::string &name) {
            auto tmp = std::dynamic_pointer_cast<T>(get_node_ptr_base(name));
            if (!bool(tmp)) {
                shambase::throw_with_loc<std::invalid_argument>(
                    shambase::format("Node exists but is not from the requested type: {}", name));
            }
            return tmp;
        }

        template<class T>
        inline std::shared_ptr<T> get_node_ptr(const std::string &name) const {
            auto tmp = std::dynamic_pointer_cast<T>(get_node_ptr_base(name));
            if (!bool(tmp)) {
                shambase::throw_with_loc<std::invalid_argument>(
                    shambase::format("Node exists but is not from the requested type: {}", name));
            }
            return tmp;
        }

        template<class T>
        inline std::shared_ptr<T> get_edge_ptr(const std::string &name) {
            auto tmp = std::dynamic_pointer_cast<T>(get_edge_ptr_base(name));
            if (!bool(tmp)) {
                shambase::throw_with_loc<std::invalid_argument>(
                    shambase::format("Edge exists but is not from the requested type: {}", name));
            }
            return tmp;
        }

        template<class T>
        inline std::shared_ptr<T> get_edge_ptr(const std::string &name) const {
            auto tmp = std::dynamic_pointer_cast<T>(get_edge_ptr_base(name));
            if (!bool(tmp)) {
                shambase::throw_with_loc<std::invalid_argument>(
                    shambase::format("Edge exists but is not from the requested type: {}", name));
            }
            return tmp;
        }

        template<class T>
        inline T &get_node_ref(const std::string &name) {
            return shambase::get_check_ref(get_node_ptr<T>(name));
        }

        template<class T>
        inline const T &get_node_ref(const std::string &name) const {
            return shambase::get_check_ref(get_node_ptr<T>(name));
        }

        template<class T>
        inline T &get_edge_ref(const std::string &name) {
            return shambase::get_check_ref(get_edge_ptr<T>(name));
        }

        template<class T>
        inline const T &get_edge_ref(const std::string &name) const {
            return shambase::get_check_ref(get_edge_ptr<T>(name));
        }

        inline std::vector<std::string> get_edge_names() const {
            std::vector<std::string> ret{};
            ret.reserve(edges.size());
 
            for (const auto &entry : edges) {
                ret.push_back(entry.first);
            }
            std::sort(ret.begin(), ret.end());
            return ret;
        }

        inline std::vector<std::string> get_node_names() const {
            std::vector<std::string> ret{};
            ret.reserve(nodes.size());
 
            for (const auto &entry : nodes) {
                ret.push_back(entry.first);
            }
            std::sort(ret.begin(), ret.end());
            return ret;
        }
    };
 
} // namespace shamrock::solvergraph