Case.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 _c1c4f441_160f_46bf_869e_1bf9c199aa91
#define _c1c4f441_160f_46bf_869e_1bf9c199aa91
 
#include <unordered_map>
 
#include <MrMeasSrv/MeasUtils/NLSStatus.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/Dictionary.h"
#include "msl/graph/AbstractNode.h"
#include "msl/graph/FlexibleFunction.h"
#include "msl/graph/Node.h"
#include "msl/helpers.h"
 
namespace msl
{
namespace graph
{
 
template<typename T>
class Case: public AbstractNode
{
public:
    using Map = std::unordered_map<T, AbstractNode::Pointer>;
    
    using Function = FlexibleFunction<T>;
    
    DECLARE_POINTERS(Case<T>);
    
    static Pointer New(
        std::string const & key, Map const & cases,
        Dictionary::Pointer registry={})
    {
        return Pointer(new Case(key, cases, registry));
    }
    
    NLSStatus prepare(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports) override
    {
        auto child = this->_child(protocol, limits, exports);
        ON_ERROR_RETURN_STATUS(child->prepare(protocol, limits, exports));
        
        // Update the duration and rfInfo cache
        this->_duration = child->duration();
        this->_rfInfo = child->rfInfo();
        
        return MRI_SEQ_SEQU_NORMAL;
    }
    
    NLSStatus run(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports) override
    {
        auto child = this->_child(protocol, limits, exports);
        return child->run(protocol, limits, exports);
    }
    
    Case & setRegistry(Dictionary::Pointer registry) override
    {
        this->AbstractNode::setRegistry(registry);
        for(auto && item: this->_cases)
        {
            auto & child = item.second;
            child->setRegistry(this->_registry);
        }
        return *this;
    }
    
    uint64_t duration() const override
    {
        return this->_duration;
    }
    
    MrProtocolData::SeqExpoRFInfo rfInfo() const override
    {
        return this->_rfInfo;
    }
    
private:
    std::string _key;
    Map _cases;
    
    // Cache for duration and rfInfo, updated when _condition is called
    mutable uint64_t _duration;
    mutable MrProtocolData::SeqExpoRFInfo _rfInfo;
    
    Case(
        std::string const & key, Map const & cases,
        Dictionary::Pointer registry={})
    : AbstractNode(registry), _key(key), _cases(cases)
    {
        this->setRegistry(registry);
    }
    
    AbstractNode::ConstPointer _child(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports) const
    {
        auto const child = this->_cases.at(
            this->type(this->_key) == typeid(T)
            ? this->get<T>(this->_key)
            : function_adapter(this->get<Function>(this->_key))(
                protocol, limits, exports, this->_registry));
        
        return child;
    }
    
    AbstractNode::Pointer _child(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports)
    {
        auto const child = this->_cases.at(
            this->type(this->_key) == typeid(T)
            ? this->get<T>(this->_key)
            : function_adapter(this->get<Function>(this->_key))(
                protocol, limits, exports, this->_registry));
        
        return child;
    }
};
 
}
}
 
#endif // _c1c4f441_160f_46bf_869e_1bf9c199aa91