NodeFactory.hpp

#pragma once
#include <Dataflow/RaDataflow.hpp>
 
#include <Dataflow/Core/Node.hpp>
 
#include <Core/Utils/StdOptional.hpp>
 
#include <functional>
#include <iostream>
#include <unordered_map>
 
#define REGISTER_TYPE_TO_FACTORY( FACTORY, TYPE, NAMESPACE ) \
    FACTORY->register_node_creator<TYPE>( TYPE::node_typename() + "_", #NAMESPACE )
 
namespace Ra {
namespace Dataflow {
namespace Core {
 
class DataflowGraph;
 
class RA_DATAFLOW_CORE_API NodeFactory
{
  public:
    explicit NodeFactory( std::string name );
 
    [[nodiscard]] auto name() const -> std::string;
 
    using NodeCreatorFunctor = std::function<std::shared_ptr<Node>( const nlohmann::json& data )>;
 
    template <typename T>
    auto register_node_creator( NodeCreatorFunctor nodeCreator,
                                const std::string& nodeCategory = "RadiumNodes" ) -> bool;
 
    template <typename T>
    auto register_node_creator( const std::string& instanceNamePrefix,
                                const std::string& nodeCategory = "RadiumNodes" ) -> bool;
    auto register_node_creator( const std::string& nodeType,
                                NodeCreatorFunctor nodeCreator,
                                const std::string& nodeCategory = "RadiumNodes" ) -> bool;
 
    [[nodiscard]] auto create_node( const std::string& nodeType,
                                    const nlohmann::json& data,
                                    DataflowGraph* owningGraph = nullptr ) -> std::shared_ptr<Node>;
 
    using ContainerType =
        std::unordered_map<std::string, std::pair<NodeCreatorFunctor, std::string>>;
    [[nodiscard]] auto factory_map() const -> const ContainerType&;
 
  private:
    auto next_node_id() -> size_t;
 
    ContainerType m_nodesCreators;
    size_t m_nodesCreated { 0 };
    std::string m_name;
};
 
class RA_DATAFLOW_CORE_API NodeFactorySet
{
  public:
    using container_type = std::map<std::string, std::shared_ptr<NodeFactory>>;
 
    using key_type    = container_type::key_type;
    using mapped_type = container_type::mapped_type;
    using value_type  = container_type::value_type;
 
    using const_iterator = container_type::const_iterator;
    using iterator       = container_type::iterator;
 
    auto add_factory( mapped_type factory ) -> bool;
 
    auto has_factory( const key_type& name ) -> Ra::Core::Utils::optional<mapped_type>;
 
    auto remove_factory( const key_type& name ) -> bool;
 
    [[nodiscard]] auto create_node( const std::string& nodeType,
                                    const nlohmann::json& data,
                                    DataflowGraph* owningGraph = nullptr ) -> std::shared_ptr<Node>;
 
    /* Wrappers to the interface of the underlying container
     * see https://en.cppreference.com/w/cpp/container/map
     */
    auto begin() const -> const_iterator;
    auto end() const -> const_iterator;
    auto cbegin() const -> const_iterator;
    auto cend() const -> const_iterator;
    auto find( const key_type& key ) const -> const_iterator;
    auto insert( value_type value ) -> std::pair<iterator, bool>;
    auto erase( const key_type& key ) -> size_t;
 
    const std::string& default_factory_name() { return m_default_factory_name; }
 
  private:
    container_type m_factories;
    const std::string m_default_factory_name { "Dataflow Nodes" };
};
 
namespace NodeFactoriesManager {
RA_DATAFLOW_CORE_API auto factory_manager() -> NodeFactorySet&;
 
RA_DATAFLOW_CORE_API auto register_factory( NodeFactorySet::mapped_type factory ) -> bool;
 
RA_DATAFLOW_CORE_API auto create_factory( const NodeFactorySet::key_type& name )
    -> NodeFactorySet::mapped_type;
 
RA_DATAFLOW_CORE_API auto factory( const NodeFactorySet::key_type& name )
    -> NodeFactorySet::mapped_type;
 
RA_DATAFLOW_CORE_API auto unregister_factory( const NodeFactorySet::key_type& name ) -> bool;
 
RA_DATAFLOW_CORE_API auto default_factory() -> NodeFactorySet::mapped_type;
} // namespace NodeFactoriesManager
 
// -----------------------------------------------------------------
// ---------------------- inline methods ---------------------------
 
template <typename T>
auto NodeFactory::register_node_creator( NodeCreatorFunctor nodeCreator,
                                         const std::string& nodeCategory ) -> bool {
    return register_node_creator( T::node_typename(), std::move( nodeCreator ), nodeCategory );
}
 
template <typename T>
auto NodeFactory::register_node_creator( const std::string& instanceNamePrefix,
                                         const std::string& nodeCategory ) -> bool {
    return register_node_creator(
        T::node_typename(),
        [this, instanceNamePrefix]( const nlohmann::json& data ) {
            std::string instanceName;
            if ( data.contains( "instance" ) ) {
                instanceName = data["instance"];
                this->next_node_id(); // increment even if not used to avoid collision on creation
                                      // after loading files
            }
            else { instanceName = instanceNamePrefix + std::to_string( this->next_node_id() ); }
            auto node = std::make_shared<T>( instanceName );
            if ( !node->fromJson( data ) ) return std::shared_ptr<T> { nullptr };
            return node;
        },
        nodeCategory );
}
 
inline auto NodeFactory::factory_map() const -> const NodeFactory::ContainerType& {
    return m_nodesCreators;
}
 
inline auto NodeFactorySet::add_factory( NodeFactorySet::mapped_type factory ) -> bool {
    const auto [loc, inserted] = insert( { factory->name(), std::move( factory ) } );
    return inserted;
}
 
inline auto NodeFactorySet::has_factory( const NodeFactorySet::key_type& name )
    -> Ra::Core::Utils::optional<NodeFactorySet::mapped_type> {
    if ( auto fct = m_factories.find( name ); fct != m_factories.end() ) { return fct->second; }
    return {};
}
 
inline auto NodeFactorySet::remove_factory( const NodeFactorySet::key_type& name ) -> bool {
    return erase( name );
}
inline auto NodeFactorySet::begin() const -> NodeFactorySet::const_iterator {
    return m_factories.begin();
}
inline auto NodeFactorySet::end() const -> NodeFactorySet::const_iterator {
    return m_factories.end();
}
inline auto NodeFactorySet::cbegin() const -> NodeFactorySet::const_iterator {
    return m_factories.cbegin();
}
inline auto NodeFactorySet::cend() const -> NodeFactorySet::const_iterator {
    return m_factories.cend();
}
inline auto NodeFactorySet::find( const NodeFactorySet::key_type& key ) const
    -> NodeFactorySet::const_iterator {
    return m_factories.find( key );
}
inline auto NodeFactorySet::insert( NodeFactorySet::value_type value )
    -> std::pair<NodeFactorySet::iterator, bool> {
    return m_factories.insert( std::move( value ) );
}
inline auto NodeFactorySet::erase( const NodeFactorySet::key_type& key ) -> size_t {
    return m_factories.erase( key );
}
 
} // namespace Core
} // namespace Dataflow
} // namespace Ra