0

I know that this is simple code, but I can't find amazingly detailed documentation anywhere for the project or on C++'s bind. This is the code:

uri.canonize(bind(&FaceController::onCanonizeSuccess, this, _1, onSuccess, onFailure, uri),
             bind(&FaceController::onCanonizeFailure, this, _1, onSuccess, onFailure, uri),
             m_ioService, TIME_ALLOWED_FOR_CANONIZATION);

I've only ever used bind with one more argument than the bound function, not with two. Additionally, uri.canonize has this function signature:

void
FaceUri::canonize(const CanonizeSuccessCallback& onSuccess,
              const CanonizeFailureCallback& onFailure,
              boost::asio::io_service& io, const time::nanoseconds& timeout) const

And much further down the rabbit hole, onSuccess and onFailure do get called with one argument, but I don't think it's important to show all that here. Finally, the function signature for onCanonizeSuccess is:

void
FaceController::onCanonizeSuccess(const FaceUri& uri,
                              const CommandSuccessCallback& onSuccess,
                              const CommandFailureCallback& onFailure,
                              const FaceUri& request)

Really I'm just asking for someone to interpret this with me. Here's what I have understood: uri.canonize is being passed 4 arguments:

  1. A bound function, which is of the return type FaceController::onCanonizeSuccess, with the first arg bound to the uri object, the second arg passed to the bound function, then onSuccess, onFailure, and uri.
  2. A bound function just like above, except the return type is FaceController::onCanonizeFailure.
  3. m_ioService
  4. TIME_ALLOWED_FOR_CANONIZATION

So what this means is that FaceUri::canonize here is being passed two function objects that each take 1 argument, and two other things. Then, when FaceUri::canonize ultimately calls its onSuccess with that one argument, since that function object is bound to a return type of FaceController::onCanonizeSuccess, that's the function that will be called.

That's my best attempt at understanding what's going on here. The only issue is that FaceController::onCanonizeSuccess isn't the bound function. It can't be, because the arity here means we're calling bind with a return type, and this is the function to bind to. What is this in this context? The top-most calling function? uri? uri.canonize? This is all as clear as mud. Unfortunately, I don't know which bind we're using, but I believe it is std::bind, since I see a using std::bind clause a few includes up.

Bronze
  • 153
  • 1
  • 8
  • your understanding is correct. – Richard Hodges Sep 09 '16 at 17:55
  • But I still don't understand what "this" is doing here. What is that bound to? – Bronze Sep 09 '16 at 17:57
  • OnCanonizeSuccess is a member function. It's binding to the "this" pointer. – Richard Hodges Sep 09 '16 at 17:58
  • I just don't follow. What does "this" indicate in the context it's placed in? – Bronze Sep 09 '16 at 18:00
  • It's saying "when you call onCanonizeSuccess, call it on the same object that I am calling you from" Ie it's binding the callback to the current object context. – Richard Hodges Sep 09 '16 at 18:01
  • In C++, non-static member functions have an implicit `this` parameter -- a pointer to the object on which they are being invoked. If we have `A c;` and then `c.foo(1);`, that's kind of like `A::foo(this, 1)`. – David Schwartz Sep 09 '16 at 18:10
  • That's exactly right, and now that's so clear. I don't know why that tripped me up so badly, because it's a pretty common occurrence. I feel a little embarrassed, but thanks so much! – Bronze Sep 09 '16 at 18:27

1 Answers1

1

So, void FaceUri::canonize is a function, which gets called. It accepts four arguments, being (with proper cv and ref qualifiers)
CanonizeSuccessCallback - a function, which gets called (guessing from the name, on success)
CanonizeFailureCallback - a function, which gets called (guessing from the name, on failure)
and two plain arguments, you probably understand.

Now, Canonize*Callback are probably objects (guessing templates), which supposes, to have proper operator() defined on them. I suppose you know the basics behind std::bind.

And uri.canonize is a function call, where first two arguments are functions, to be called when canonizing succeeds or fails.

According to onCanonizeSuccess singature, you have to pass four parameters to std::bind for that function. Well, actually, since that function is not static, it requires fifth (or rather null-th) argument of type FaceController* on which should the function (onCanonizeSuccess) be called. 

bind(
  &FaceController::onCanonizeSuccess, // non-static member function requiring first argument to be pointer to FaceController instance
  this, // pointer to FaceController instance, that means, the object with function, where uri.canonize is called.
  _1, // actually std::placeholders::_1, meaning, that first argument will be passed when calling bound function                                                                                                             
  onSuccess, // rest of parameters
  onFailure,
  uri
)
Zereges
  • 5,139
  • 1
  • 25
  • 49
  • The comments are really what made this clear. I really appreciate the thorough, quick answers. Keep up the good work and keep helping idiots like me learn! Thanks! – Bronze Sep 09 '16 at 18:28