FlexibleFunction.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 _b7df6a58_79dd_4d8c_92ab_616d6fe3c0ce
#define _b7df6a58_79dd_4d8c_92ab_616d6fe3c0ce
 
#include <functional>
 
#include <boost/variant/variant.hpp>
 
#include <MrProtSrv/Domain/CoreNative/SeqLim.h>
#include <MrProtSrv/Domain/MrProtData/MrProt/MrProt.h>
#include <MrProtSrv/Domain/MrProtData/MrProt/SeqIF/SeqExpo.h>
 
#include "msl/Dictionary.h"
 
namespace msl
{
 
namespace graph
{
 
template<typename T>
using FlexibleFunction = boost::variant<
    std::function<T()>,
    std::function<T(Dictionary::Pointer)>,
    std::function<T(MrProt &)>,
    std::function<T(MrProt &, Dictionary::Pointer)>,
    std::function<T(MrProt &, SeqLim &, SeqExpo &)>,
    std::function<T(MrProt &, SeqLim &, SeqExpo &, Dictionary::Pointer)>>;
 
template<typename T>
class FlexibleFunctionAdapter: public boost::static_visitor<
    std::function<T(MrProt &, SeqLim &, SeqExpo &, Dictionary::Pointer)>>
{
public:
    using typename boost::static_visitor<
            std::function<T(MrProt &, SeqLim &, SeqExpo &, Dictionary::Pointer)>
        >::result_type;
    
    result_type operator()(std::function<T()> const & f) const
    {
        return [&](MrProt &, SeqLim &, SeqExpo &, msl::Dictionary::Pointer){
            return f(); };
    }
    
    result_type operator()(
        std::function<T(Dictionary::Pointer)> const & f) const
    {
        return [&](MrProt &, SeqLim &, SeqExpo &, Dictionary::Pointer d){
            return f(d); };
    }
    
    result_type operator()(std::function<T(MrProt &)> const & f) const
    {
        return [&](MrProt & p, SeqLim &, SeqExpo &, Dictionary::Pointer){
            return f(p); };
    }
    
    result_type operator()(
        std::function<T(MrProt &, Dictionary::Pointer)> const & f) const
    {
        return [&](MrProt & p, SeqLim &, SeqExpo &, Dictionary::Pointer d){
            return f(p, d); };
    }
    
    result_type operator()(
        std::function<T(MrProt &, SeqLim &, SeqExpo &)> const & f) const
    {
        return [&](MrProt & p, SeqLim & l, SeqExpo & e, Dictionary::Pointer){
            return f(p, l, e); };
    }
    
    result_type operator()(
        std::function<T(MrProt &, SeqLim &, SeqExpo &, msl::Dictionary::Pointer)> const & f) const
    {
        return f;
    }
};
 
template<typename T>
std::function<T(MrProt &, SeqLim &, SeqExpo &, Dictionary::Pointer)>
function_adapter(FlexibleFunction<T> const & f)
{
    return boost::apply_visitor(FlexibleFunctionAdapter<T>{}, f);
}
 
}
 
}
 
#endif // _b7df6a58_79dd_4d8c_92ab_616d6fe3c0ce