Alternative to syntactically-heavy multiple lambda wrapper - how to avoid boilerplate code? - c++

Question

I find myself encapsulating multiple lambdas in a "proxy" object with a nicer interface in various parts of my code:
auto create_proxy()
{
auto f_get_foo = [something]
{
return something_else();
};
auto f_set_bar = [something](auto x)
{
something_else(x);
};
auto f_render = [&window]
{
window.render();
};
return make_nice_proxy( // .
std::move(f_get_foo), // .
std::move(f_set_bar), // .
std::move(f_render));
}
I can use the proxy like this:
nice_proxy.get_foo(); // calls the stored `f_get_foo` lambda
nice_proxy.set_foo(15); // calls the stored `f_set_foo` lambda
nice_proxy.render(); // calls the stored `f_render` lambda
The problem is that writing and maintaining code for these proxies is very cumbersome and syntactically heavy:
template < // .
typename TFGetFoo, // .
typename TFSetBar, // .
typename TFRender // .
>
class nice_proxy_impl
{
// Hide the lambdas:
private:
TFGetFoo _f_get_foo;
TFSetBar _f_set_bar;
TFRender _f_render;
int _render_count = 0;
public:
template < // .
typename TFwdFGetFoo, // .
typename TFwdFSetBar, // .
typename TFwdFRender // .
>
nice_proxy_impl( // .
TFwdFGetFoo&& f_get_foo, // .
TFwdFSetBar&& f_set_bar, // .
TFwdFRender&& f_render) // .
: _f_get_foo(FWD(f_get_foo)),
_f_set_bar(FWD(f_set_bar)),
_f_render(FWD(f_render))
{
}
// Expose the lambdas:
void set_bar(int x)
{
some_side_effect();
_f_set_bar(x);
}
auto get_foo()
{
return _f_get_foo();
}
void render()
{
std::cout << "rendering...\n";
_f_render();
++_render_count;
}
};
template <typename... TFs>
auto make_nice_proxy(TFs&&... fs)
{
return nice_proxy_impl<std::decay_t<TFs>...>(FWD(fs)...);
}
The purpose of the proxy class is to:
Hide the lambdas from the user.
Give the users a nice (and possibly richer) interface through which they can call the "hidden" lambdas.
I have multiple proxy classes in my codebase, which all privately store some perfectly-forwarded callable objects (and expose them through public functions), and that are created using make_xxx_proxy functions.
While make_xxx_proxy is usually easy to implement and does not require much maintenance, every proxy class (like nice_proxy_impl) require one template parameter per function, one field per function and one perfect-forwarding constructor parameter.
With multiple proxy classes, even adding or removing a single "encapsulated function" becomes annoying fairly quickly. get_foo is repeated 5 times in nice_proxy_impl (in different forms).
Is there a better and less syntactically-heavy solution for this "pattern"?
I'm looking for a way of avoiding the constant lambda/function repetition, type decaying and perfect-forwarding, which is just boilerplate.
make_xxx_proxy functions also become hell to maintain if the passed arguments are not only functions, but also additional field. Parameter expansion cannot be used in that case, and every single function has to be decayed and forwarded.
Here's a real example of a make_xxx_proxy-like function. Proxies may contain additional data/methods, that use the "encapsulated lambdas" and additional fields in various ways. Here's the corresponding proxy class.

Answer 1

Not sure I understand what you're actually asking, but you could reduce make_nice_proxy to just return a local class (thanks to C++14) with public members (so you can aggregate-initialize). This avoids having to rewrite most stuff:
template <class Getter, class Setter, class Render>
auto make_nice_proxy(Getter&& g, Setter&& s, Render&& r)
{
struct Proxy {
std::decay_t<Getter> _f_get_foo;
std::decay_t<Setter> _f_set_bar;
std::decay_t<Render> _f_render;
int _render_count = 0;
void set_bar(int x) {
some_side_effect();
_f_set_bar(x);
}
auto get_foo() {
return _f_get_foo();
}
void render() {
std::cout << "rendering...\n";
_f_render();
++_render_count;
}
};
return Proxy{std::forward<Getter>(g), std::forward<Setter>(s), std::forward<Render>(r)};
}