Iterator.h

Go to the documentation of this file.

// Copyright 2025 Julien Lamy, ICube, Université de Strasbourg-CNRS.
// Part of msl, distributed under the terms of the MIT license.
 
#ifndef _be7f134a_58de_4d2c_9052_d40da0b2c01d
#define _be7f134a_58de_4d2c_9052_d40da0b2c01d
 
#include <iterator>
#include <string>
 
#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/Iterator.h"
#include "msl/helpers.h"
#include "msl/graph/Node.h"
 
namespace msl
{
namespace graph
{
 
template<typename T>
class IteratorTemplate: public Node
{
public:
    DECLARE_POINTERS(IteratorTemplate<T>)
    
    
    static Pointer New(std::string const & key, Dictionary::Pointer registry={})
    {
        return Pointer(new IteratorTemplate<T>(key, registry));
    }
    
    template<typename Child>
    static Pointer New(
        std::string const & key, Child const & child,
        Dictionary::Pointer registry={})
    {
        return Pointer(new IteratorTemplate<T>(key, child, registry));
    }
    
    static Pointer New(
        std::string const & key, Siblings const & siblings,
        Dictionary::Pointer registry={})
    {
        return Pointer(new IteratorTemplate<T>(key, siblings, registry));
    }
    
    virtual ~IteratorTemplate() = default;
    
    NLSStatus prepare(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports) override
    {
        this->_iterator().reset();
        return this->Node::prepare(protocol, limits, exports);
    }
    
    NLSStatus run(
        MrProt & protocol, SeqLim & limits, SeqExpo & exports) override
    {
        this->_iterator().reset();
        while(!this->_iterator().done())
        {
            ON_ERROR_RETURN_STATUS(this->Node::run(protocol, limits, exports));
            ++this->_iterator();
        }
        return MRI_SEQ_SEQU_NORMAL;
    }
    
    uint64_t duration() const override
    {
        return this->_iterator().end() * this->Node::duration();
    }
    
    MrProtocolData::SeqExpoRFInfo rfInfo() const override
    {
        // NOTE: using `double(this->_counter().end()) * this->Node::rfInfo()`
        // as in Loop yields a compilation error on Windows.
        MrProtocolData::SeqExpoRFInfo rfInfo = this->Node::rfInfo();
        rfInfo *= this->_iterator().end();
        return rfInfo;
    }
    
private:
    std::string _key;
    
    IteratorTemplate(std::string const & key, Dictionary::Pointer registry={})
    : Node(registry), _key(key)
    {
        // Nothing else
    }
    
    template<typename Child>
    IteratorTemplate(
        std::string const & key, Child const & child,
        Dictionary::Pointer registry={})
    : Node(child, registry), _key(key)
    {
        // Nothing else
    }
    
    IteratorTemplate(
        std::string const & key, Siblings const & siblings,
        Dictionary::Pointer registry={})
    : Node(siblings, registry), _key(key)
    {
        // Nothing else
    }
    
    IteratorTemplate(IteratorTemplate<T> const &) = default;
    IteratorTemplate(IteratorTemplate<T> &&) = default;
    IteratorTemplate & operator=(IteratorTemplate<T> const &) = default;
    IteratorTemplate & operator=(IteratorTemplate<T> &&) = default;
    
    T const & _iterator() const
    {
        return this->get<T>(this->_key);
    }
    
    T & _iterator()
    {
        return this->get<T>(this->_key);
    }
};
 
template<typename T>
using ConstIterator = IteratorTemplate<msl::ConstIterator<T>>;
 
template<typename T>
using Iterator = IteratorTemplate<msl::Iterator<T>>;
 
}
}
 
#endif // _be7f134a_58de_4d2c_9052_d40da0b2c01d