Generic function bind() with Boost

Question

I have some C-style functions that return 0 to indicate success, and != 0 on error.
I'd like to "wrap" them into void functions that throw instead of returning a value.

I have written this helper:

void checkStatus(int status) {
  if (status != 0)
    // throw an error object
}

Then, to wrap a determinate function int tilt(float degrees), I use boost::bind:

function<void(float)> ntilt = bind(checkStatus, bind(tilt, _1));
ntilt(30); // this will call checkStatus(tilt(30))

And it works great. But I'd like to have a dedicate wrapper function, so I can just do:

function<void(float)> ntilt = wrap(tilt);
ntilt(30); // this will call checkStatus(tilt(30))

It should work for any function/signature that returns an int.
What would be the best way to do it using Boost?

Might be tedious with C++ but with C++11, you might be able to do this with varadic templates easily — dchhetri, Mar 25 '13 at 15:42
I'm using C++11, but I'm also interested in a C++ solution, if it's possible. — Alba Mendez, Mar 25 '13 at 15:43
Wait, are you sure `bind(checkStatus, bind(tilt, _1));` works fine? — Joseph Mansfield, Mar 25 '13 at 16:04
@sftrabbit I'm looking at that and I don't get what's it supposed to do xD — mfontanini, Mar 25 '13 at 16:04
@sftrabbit it should work, see that same example at [the docs](http://www.boost.org/doc/libs/1_53_0/libs/bind/bind.html#nested_binds) — Alba Mendez, Mar 25 '13 at 16:33
@mfontanini `bind` within a `bind` is used to compose functions (`lambda` style), see http://www.boost.org/doc/libs/1_53_0/libs/bind/bind.html#nested_binds Behold the hidden power of `bind`! — Alba Mendez, Mar 25 '13 at 16:38
@Fanael: yes you're right, the distinction I was making was the old feature vs new — dchhetri, Mar 25 '13 at 17:43

mfontanini · Accepted Answer · 2013-03-25T16:45:41.973

3

You could create several overloads to handle the different amount of parameters that your wrapped functions might take:

// handles 1 parameter functions
template<typename Ret, typename T0>
function<void(T0)> wrap(Ret (*fun)(T0)) {
    return bind(checkStatus, bind(fun, _1));
}

// handles 2 parameters functions    
template<typename Ret, typename T0, typename T1>
function<void(T0, T1)> wrap(Ret (*fun)(T0, T1)) {
    return bind(checkStatus, bind(fun, _1, _2));
}

// ... add more

Here's a C++11 implementation. You could avoid some stuff if you didn't want an std::function, but well, it works:

#include <functional>
#include <stdexcept>

template<typename Ret, typename... Args>
struct wrapper {
    typedef Ret (*function_type)(Args...);

    void operator()(Args&&... args) {
        if(fun(std::forward<Args>(args)...) != 0)
            throw std::runtime_error("Error");
    }

    function_type fun;
};

template<typename Ret, typename... Ts>
std::function<void(Ts...)> wrap(Ret (*fun)(Ts...)) {
    return std::function<void(Ts...)>(wrapper<Ret, Ts...>{fun});
}

Here is a live demo.

edited Mar 25 '13 at 16:45

answered Mar 25 '13 at 15:55

mfontanini

21,410
4
65
73

I see... is there a better way to do it with C++0x? Thanks for the answer. – Alba Mendez Mar 25 '13 at 15:59
Hmmm, using variadic templates, you'd need to bind all of the required placeholders. – mfontanini Mar 25 '13 at 16:11
Looking at `bind`'s own implementation, I see that it's done exactly in that way. Interesting... – Alba Mendez Mar 25 '13 at 16:42
@jmendeth there you go, a C++11 impementation. – mfontanini Mar 25 '13 at 16:45
Note that you could remove the `Ret` template parameter if you're completely sure that all of the functions return an `int`. – mfontanini Mar 25 '13 at 16:52
Yep, I'm completely sure. Also, what stuff could I avoid if I didn't want a `std::function`? – Alba Mendez Mar 25 '13 at 17:00
Not much, actually. `wrap` could just return a `wrapper<>`, instead of a `std::function`. And it'd look better if `wrapper` used the `Ret(Args)` syntax. – mfontanini Mar 25 '13 at 17:03

Generic function bind() with Boost

1 Answers1