Block.h

Go to the documentation of this file.

// Copyright 2024-2025 Julien Lamy, ICube, Université de Strasbourg-CNRS.
// Part of msl, distributed under the terms of the MIT license.
 
#ifndef _27135a4d_ad34_43b2_b032_c9745dc65fca
#define _27135a4d_ad34_43b2_b032_c9745dc65fca
 
#include <numeric>
#include <string>
 
#include <MrImagingFW/libSeqUtilFW/libSeqUtilFW.h>
 
#include <MrMeasSrv/MeasUtils/NLSStatus.h>
#include <MrMeasSrv/SeqIF/libRT/sSLICE_POS.h>
#include <MrMeasSrv/SeqIF/Sequence/sequmsg.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/Counter.h"
#include "msl/graph/AbstractNode.h"
#include "msl/helpers.h"
#include "msl/Iterator.h"
 
namespace msl
{
namespace graph
{
 
template<typename T, typename Slices=std::vector<sSLICE_POS>>
class Block: public AbstractNode
{
public:
    using Pointer = std::shared_ptr<Block<T, Slices>>;
    using ConstPointer = std::shared_ptr<Block<T const, Slices>>;
    
    T block;
    
    template<typename ... Args>
    static Pointer New(std::string const & slice, Args && ... args)
    {
        return Pointer(new Block<T>(slice, args ...));
    }
    
    virtual ~Block() = default;
    
    NLSStatus prepare(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports) override
    {
        ON_FALSE_RETURN_STATUS(this->block, prep(protocol, limits, exports));
        return MRI_SEQ_SEQU_NORMAL;
    }
    
    NLSStatus run(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports) override
    {
        auto slice = this->get<msl::ConstIterator<Slices>>(this->_slice).item();
        ON_FALSE_RETURN_STATUS(
            this->block, run(protocol, limits, exports, &slice));
        return MRI_SEQ_SEQU_NORMAL;
    }
    
    uint64_t duration() const override
    {
        // WARNING: SeqBuildBlock::getDurationPerRequest is not const.
        return const_cast<T&>(this->block).getDurationPerRequest();
    }
    
    MrProtocolData::SeqExpoRFInfo rfInfo() const override
    {
        // WARNING: SeqBuildBlock::getDurationPerRequest is not const.
        return const_cast<T&>(this->block).getRFInfoPerRequest();
    }
 
private:
    std::string _slice;
    
    template<typename ... Args>
    Block(std::string const & slice, Args && ... args)
    : AbstractNode(), block(args ...), _slice(slice)
    {
        // Nothing else.
    }
    Block(Block<T, Slices> const &) = default;
    Block(Block<T, Slices> &&) = default;
    Block & operator=(Block<T, Slices> const &) = default;
    Block & operator=(Block<T, Slices> &&) = default;
};
 
}
}
 
#endif // _27135a4d_ad34_43b2_b032_c9745dc65fca