Node.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 _b88cfdce_0b38_4b24_b5c6_5b69be24d9d8
#define _b88cfdce_0b38_4b24_b5c6_5b69be24d9d8
 
#include <vector>
 
#include <MrMeasSrv/MeasUtils/NLSStatus.h>
#include <MrMeasSrv/SeqIF/libRT/sSLICE_POS.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"
#include "msl/graph/AbstractNode.h"
 
namespace msl
{
 
namespace graph
{

class Node: public AbstractNode
{
public:
    DECLARE_POINTERS(Node);
    
    using Siblings = std::vector<AbstractNode::Pointer>;
    
    static Pointer New(Dictionary::Pointer registry={});
    
    template<typename T>
    static Pointer New(T const & child, Dictionary::Pointer registry={})
    {
        return Pointer(new Node(child, registry));
    }
    
    static Pointer New(
        Siblings const & siblings, Dictionary::Pointer registry={});
    
    virtual ~Node() = default;
    
    NLSStatus prepare(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports) override;
    
    NLSStatus run(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports) override;
    
    Node & setRegistry(Dictionary::Pointer registry) override;
    
    void reset() override;
    
    uint64_t duration() const override;
    
    MrProtocolData::SeqExpoRFInfo rfInfo() const override;
    
    bool empty() const;
    std::size_t size() const;
    
    template<typename T>
    T & appendChild(std::shared_ptr<T> const & child)
    {
        this->_children.push_back(child);
        this->_children.back()->setRegistry(this->_registry);
        return *child;
    }
    
    void appendChildren(Siblings const & siblings);
    
    Node & deleteChild(std::size_t index);
    
    Node & clearChildren();
    
    AbstractNode::ConstPointer child(std::size_t index) const;
    
    AbstractNode::Pointer child(std::size_t index);
    
protected:
    Siblings _children;
    
    Node(Dictionary::Pointer registry={});
    
    template<typename T>
    Node(T const & child, Dictionary::Pointer registry={})
    : Node(registry)
    {
        this->appendChild(child);
    }
    
    Node(Siblings const & siblings, Dictionary::Pointer registry={});
    
    Node(Node const &) = default;
    Node(Node &&) = default;
    Node & operator=(Node const &) = default;
    Node & operator=(Node &&) = default;
};
 
}
 
}
 
#endif // _b88cfdce_0b38_4b24_b5c6_5b69be24d9d8