AbstractNode.h

Go to the documentation of this file.

// Copyright 2024-2026 Julien Lamy, ICube, Université de Strasbourg-CNRS.
// Part of msl, distributed under the terms of the MIT license.
 
#ifndef _c98760d2_f8bf_472c_9671_9d8322e26b0e
#define _c98760d2_f8bf_472c_9671_9d8322e26b0e
 
#include <cstddef>
#include <memory>
 
#include <MrMeasSrv/MeasUtils/NLSStatus.h>
 
#include <MrProtSrv/Domain/CoreNative/SeqLim.h>
#include <MrProtSrv/Domain/MrProtData/MrProt/MrProt.h>
#include <MrProtSrv/Domain/MrProtData/MrProt/SeqIF/SeqExpo.h>
#include <MrProtSrv/Domain/MrProtData/MrProt/SeqIF/SeqExpoRFBlockInfo.h>
 
#include "msl/Dictionary.h"
 
namespace msl
{

namespace graph
{

class AbstractNode
{
public:
    DECLARE_POINTERS(AbstractNode);
    
    virtual ~AbstractNode() = default;
    
    virtual NLSStatus prepare(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports) = 0;
    
    virtual NLSStatus run(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports) = 0;
    
    Dictionary::ConstPointer registry() const;
    
    Dictionary::Pointer & registry();
    
    virtual AbstractNode & setRegistry(Dictionary::Pointer registry);
    
    virtual void reset();
     
    virtual uint64_t duration() const = 0;
    
    virtual MrProtocolData::SeqExpoRFInfo rfInfo() const = 0;
    
    template<typename T>
    T const & get(std::string const & key) const
    {
        return this->_registry->get<T>(key);
    }
    
    template<typename T>
    T & get(std::string const & key)
    {
        return this->_registry->get<T>(key);
    }
    
    template<typename T>
    AbstractNode & set(std::string const & key, T && value)
    {
        this->_registry->set(key, value);
        return *this;
    }
    
    boost::typeindex::type_info const & type(std::string const & key) const;
    
protected:
    Dictionary::Pointer _registry;
    
    AbstractNode(Dictionary::Pointer registry={});
    AbstractNode(AbstractNode const &) = default;
    AbstractNode(AbstractNode &&) = default;
    AbstractNode & operator=(AbstractNode const &) = default;
    AbstractNode & operator=(AbstractNode &&) = default;
};

template<typename T, typename U>
std::shared_ptr<T> NodeCast(std::shared_ptr<U> const & p)
{
    return std::dynamic_pointer_cast<T>(p);
}
 
}
 
}
 
#endif // _c98760d2_f8bf_472c_9671_9d8322e26b0e