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 <boost/variant/variant.hpp>
 
#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"
#include "msl/graph/AbstractNode.h"
#include "msl/graph/Node.h"
 
namespace msl
{
namespace graph
{

template<typename T>
class Case: public AbstractNode
{
public:
    using Map = std::unordered_map<T, AbstractNode::Pointer>;
    
    // NOTE: most of the Siemens API is not const-correct
    using Function = boost::variant<
        std::function<T()>,
        std::function<T(MrProt &)>,
        std::function<T(MrProt &, SeqLim &, SeqExpo &)>>;
    
    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);
        return child->prepare(protocol, limits, exports);
    }
    
    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->_child()->duration();
    }
    
    MrProtocolData::SeqExpoRFInfo rfInfo() const override
    {
        return this->_child()->rfInfo();
    }
    
private:
    // template<typename T>
    class Visitor: public boost::static_visitor<
        std::function<T(MrProt &, SeqLim &, SeqExpo &)>>
    {
    public:
        std::function<T(MrProt &, SeqLim &, SeqExpo &)> operator()(std::function<T()> const & f) const
        {
            return [&](MrProt &, SeqLim &, SeqExpo &){ return f(); };
        }
 
        std::function<T(MrProt &, SeqLim &, SeqExpo &)> operator()(std::function<T(MrProt &)> const & f) const
        {
            return [&](MrProt & p, SeqLim &, SeqExpo &){ return f(p); };
        }
 
        std::function<T(MrProt &, SeqLim &, SeqExpo &)> operator()(
            std::function<T(MrProt &, SeqLim &, SeqExpo &)> const & f) const
        {
            return f;
        }
    };
    
    std::string _key;
    Map _cases;
    
    // NOTE: SeqLim is an abstract class. Since the concrete object may change
    // between calls to ::prepare or ::run, it can only be stored in a pointer.
    mutable bool _hasCache;
    mutable MrProt * _protocol;
    mutable SeqLim * _limits;
    mutable SeqExpo * _exports;
    
    Case(
        std::string const & key, Map const & cases,
        Dictionary::Pointer registry={})
    : AbstractNode(registry), _key(key), _cases(cases), _hasCache(false)
    {
        this->setRegistry(registry);
    }
    
    AbstractNode::ConstPointer _child() const
    {
        if(!this->_hasCache)
        {
            throw std::runtime_error("No cached data");
        }
        else
        {
            return this->_child(
                *this->_protocol, *this->_limits, *this->_exports);
        }
    }
    
    AbstractNode::ConstPointer _child(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports) const
    {
        this->_protocol = &protocol;
        this->_limits = &limits;
        this->_exports = &exports;
        this->_hasCache = true;
        
        return this->_cases.at(
            this->type(this->_key) == typeid(T)
            ? this->get<T>(this->_key)
            : boost::apply_visitor(Visitor(), this->get<Function>(this->_key))(
                protocol, limits, exports)
        );
    }
    
    AbstractNode::Pointer _child()
    {
        if(!this->_hasCache)
        {
            throw std::runtime_error("No cached data");
        }
        else
        {
            return this->_child(
                *this->_protocol, *this->_limits, *this->_exports);
        }
    }
    
    AbstractNode::Pointer _child(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports)
    {
        this->_protocol = &protocol;
        this->_limits = &limits;
        this->_exports = &exports;
        this->_hasCache = true;
        
        return this->_cases.at(
            this->type(this->_key) == typeid(T)
            ? this->get<T>(this->_key)
            : boost::apply_visitor(Visitor(), this->get<Function>(this->_key))(
                protocol, limits, exports)
        );
    }
};
 
}
}
 
#endif // _c1c4f441_160f_46bf_869e_1bf9c199aa91