[Implementation] Calling wrapped functions, converters, policies

What's next? Should we start implementing this? Or did we
leave anything unresolved?

Quoting Dave's summary;

 >So at the lowest level, we have:
 >
 >   - an invocable entity (a function pointer/reference, function
 >     object, member function pointer, or possibly data member
 >     pointer, for getters/setters)
 >
 >   - a tuple of argument/result converters
 >
 >   - a shared, per-call state object
 >
 >   - an argument package.
 >
 >   - as a matter of implementation detail, for dispatching to the
 >     right calling overload, I believe we'll need:
 >
 >        - a tag which describes how to do the invocation (function
 >          call syntax, member function syntax, data member
 >          access/assignment)
 >
 >        - a tag which says whether the invocable entity's return type
 >          is void
 >
 >        - a tag which describes the arity of the tuple of converters
 >
 >     These can probably be combined into a single integral constant
 >     wrapper for efficiency.
 >
 >Above that level, we need:
 >
 >   - a way to deduce the signature of some callable objects like
 >     function pointers
 >
 >   - a way to combine the signature of the callable object (either
 >     deduced or supplied explicitly) with the CallPolicies to produce
 >     the tuple type of argument/result converters
 >
 >    - a way to combine the CallPolicies with the ArgumentPackage to
 >      produce a shared, per-call state type/object
 >
 >    - a way to initialize an object of the arg/result converter tuple
 >      type with the shared, per-call state object and argument package
 >      (or we could combine the argument package into the shared,
 >      per-call state).
 >
 >At the top level, we need:
 >
 >   - A way to get the ArgumentPackage from the actual arguments passed.

---
Daniel Wallin




-------------------------------------------------------
This sf.net email is sponsored by:ThinkGeek
Welcome to geek heaven.
http://thinkgeek.com/sf