- Part One: Call Stream meta pattern
- Part Two: Call Stream C# Binding
CallStream Part 3 : C++ Binding
Good old C++ is one strongly typed language. CallStream concept is born (and bred) in the domain of type-less JavaScript. Also, C++ is (so called) static (compiled) language, vs dynamic (interpreted) JavaScript. C# is somewhere in between, (but not in the middle !) especially in it’s latest 4.0 reincarnation. Still I think CallStream should be implemented in C++ too. Why?
Because CallStream is not an implementation idiom of an programming language. It is a programming concept. And concept is not very good if it is not universally applicable. In which case it is not ubiquitous, and therefore not used everywhere by everyone. Not successful, in one word.
In case of C++, I have decided to make an (sort of a) type-less CallStream. An C++ interfacing mechanism which allows for more or less same call-streaming as in JavaScript. Where one can “call” anything with any arguments.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
/* */ void main(int argc, wchar_t * argv[]) { dbj::Functor & gf = dbj::GFunctor<int>(); dbj::CallStream & cs = dbj::CallStream() ; /* One instance of a single CallStream type can be used for a large variety of c++ calls */ cs ("add",1,2) (dbj::ops::add<int>,3,5) (dbj::ops::mul<int>,4,6) (true) (gf,6); } |
Above is the main(), of the real code that compiles and runs. (in VisualStudio 2008). This CallStream implementation allows calls where first argument can be a string literal, function, intrinsic type or object (aka class instance). With any number of any type of arguments following. Let’s jump straight to the CallStream code.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
/* CallStream is a single non-generic type. It declares overloaded generic function call operators It depends on the existence of the family of 'bridge' functions At compile time first appropriate 'operator ()' is found and used on the instance of this class From inside 'operator ()' found, second an appropriate bridge is found and used to the concrete implementation 'behind' if there is no required bridge function specialization found there is always a generic one. Result is comprehensive decoupling between callers and implementations hidden behind a call stream. */ class CallStream { public: /* generic 'operator ()' for pointers and variable number of arguments following */ template<typename T> const CallStream & operator () (const T * f, ...) const { va_list vl; va_start( vl, f ); dbj::bridge( *f, vl ); va_end(vl); return *this ; } /* generic 'operator ()' for references and variable number of arguments following */ template<typename T> const CallStream & operator () (const T & f, ...) const { va_list vl; va_start( vl, f ); dbj::bridge( f, vl ); va_end(vl); return *this ; } /* concretized 'operator ()' for string literals and variable number of arguments following */ template<> const CallStream & operator () (const char * s, ...) const { va_list vl; va_start( vl, s ); dbj::bridge( s, vl ); va_end(vl); return *this ; } } ; |
In this solution there is one CallStream class, serving the needs of all.