Re: virtual function template workaround

On 3/19/07 12:17 PM, in article
1174307475.616490.179810@e1g2000hsg.googlegroups.com, "pl"
<patrickl55@hotmail.com> wrote:


I think that much of the "infrastructure" evident in the above program (the
data_access_base class template, the "curiously-recurring" template pattern,
and the fortuitously-placed static_cast<> - could all be eliminated - simply
by more sharply focusing on the precise requirement of the task and by
limiting the solution to the minimal implementation capable of meeting that
requirement.

The essential requirement here, as I understand it, is to write a member
function template capable of "forwarding" its calls to another member
function - a member function that is both virtual and dynamically selected
based on the parameterized type used to instantiate the member function
template itself.

For example, consider this data_access class - in particular, its read()
member template:

     class data_access
     {
     public:

        // read() must forward each call to the virtual method read_"type"
        // where "type" is OutIterators' value_type
        // (that is, the type obtained by dereferencing the iterator)

        template <typename OutIterator>
        void read( const std::string& query, OutIterator it);
        {
            // the challenge: write the code that goes in here...
        }

        // Note that including the type in the read_ function name
        // is done primarily for the purposes of exposition.
        // It would probably be considered better form to overload
        // a single name (say, "read_value") instead.

        virtual void read_int( const string& query, int& outInt )
  = 0;
        virtual void read_string(const string& query, string& outString)
= 0;
        virtual void read_date( const string& query, timeval& outDate)
  = 0;
        ...
     };

Now the challenge implement data_access's read() method in such a way that
it will call one of read_int(), read_string(), read_data() and so forth,
depending on OutIterator's de-referenced type (that is, OutIterator's
"value_type"). In essence, the task is to bridge the two signature
"paradigms" of C++: compile-time polymorphism and run-time polymorphism by
static compile-time function call is to be dispatched dynamically at
runtime.

Now in order for read() to determine which read_ virtual method to call for
a given OutIterator type, read() will have to be able to look up the
correspondence (or "mapping") that associates each potential OutIterator
value_type with its matching virtual "read_type" method in data_access. To
define this set of correspondences, the program defines a "data_traits"
class template:

     using std::string;

     class data_access;

     // T is the OutIterator's value_type

     template <class T>
     struct data_traits
     {
         typedef void (data_access::*MF)( const string&, T&);

         // MF is the data_access member pointer of the read_ method
         // to invoke for type T

         static const MF read_method;
     };

Specializations establish the actual pairings:

     // for an int value_type call data_access::read_int()

     template <>
     const data_traits< int >::MF
     data_traits< int >::read_method = &data_access::read_int;

     template <>
     const data_traits< string >::MF
     data_traits< sint >::read_method = &data_access::read_string;

     ...

Once the map (between each value_type and the data_access' virtual read
method to be invoked for that type) has been set up, read() only has to
consult this map in order to be able to forward its calls as required:

     #include <iterator>
     ...
     using std::iterator_traits;

     template <typename OutIterator>
     void read( const std::string& query, OutIterator it)
     {
         typename iterator_traits< OutIterator >::value_type val;

         data_traits<typename iterator_traits<OutIterator>::value_type > dt;

         ( this->*dt.read_method )( query, val);

         *it++ = val;
    }

Greg

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]