Pattern to automatically hold lightweight objects by value and others by reference

Hi,

   I need a pattern to (generically) hold an object by value, when it
is lightweight (i.e., holds little data and have a fast copy
constructor), and to hold the object by reference (or pointer) when it
is heavyweight or abstract.

   The main reason for this pattern is to remove the performance
penalty of multiple indirections in inner loops.

   Please, look at the following code. Note that if I reset the
reference in generic_functor::change, it should work fine, but this is
a non-portable hack. A pointer could be used, but then the
generic_functor::operator() would have to call t->do_something() when
using pointers, and t.do_something() when using values, besides other
"schizophrenias", so it would not be "generic" anymore. Also,
tr1::reference_wrapper<> is of no help, because it cannot be used to
call member functions (it needs an ugly cast). Also, maybe I could use
a function "dereference_if_pointer", but this solution seems a little
ugly.

   Before reinventing the wheel I would like to know if there already
is a nice pattern/idiom for this, or an implementation in some library
like Boost.

   Thanks,
Edson Manoel

Code:

#include <iostream>
#include <memory>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/is_abstract.hpp>
#include <boost/mpl/if.hpp>

using namespace std;

//------------------------------------------------------------------------

// trait to query classes for lightweightness
template <class T>
class is_lightweight_object
     : public boost::mpl::false_ {};

//------------------------------------------------------------------------

class abstract_object
{
public:
     virtual int do_something() = 0;

     void operator=(abstract_object const&) {
         cout << "abstract_object: operator= called!!!" << endl;
     }
};

//------------------------------------------------------------------------

class lightweight_object : public abstract_object
{
public:
     lightweight_object(int n) : x(n) {}

     lightweight_object(lightweight_object const& a) : x(a.x) {
         cout << "lightweight_object: copy constructor called" << endl;
     }

     void operator=(lightweight_object const& a) {
         cout << "lightweight_object: operator= called" << endl;
         x = a.x;
     }

     inline int do_something() {
         // ...
         return x;
     }

protected:
     int x;
};

template <>
class is_lightweight_object<lightweight_object>
     : public boost::mpl::true_ {};

//------------------------------------------------------------------------

class heavyweight_object : public abstract_object
{
public:
     heavyweight_object(int n) : x(new int[1024]) { x[1023] = n; }

     heavyweight_object(heavyweight_object const& a) : x(new int[1024])
{
         cout << "heavyweight_object: copy constructor called" << endl;
         memcpy(x, a.x, sizeof(int)*1024);
     }

     void operator=(heavyweight_object const& a) {
         cout << "heavyweight_object: operator= called" << endl;
         memcpy(x, a.x, sizeof(int)*1024);
     }

     ~heavyweight_object() { delete[] x; }

     inline int do_something() {
         // ...
         return x[1023];
     }

protected:
     int *x;
};

//------------------------------------------------------------------------

// Functor that holds an underlying object and calls a member function
// Lightweight objects should be held by value, to avoid extra
// indirections.

template <class T>
class generic_functor {
public:
     typedef typename boost::add_reference<
         typename boost::add_const<T>::type
     >::type T_ref_type;

     generic_functor(T_ref_type p)
         : t(p) {}

     inline void operator()() {
         cout << t.do_something() << endl;
     }

     inline void change(T_ref_type new_t) {
         // NOTE: when using a reference, should reset it, but is
calling
         // the object operator=
         this->t = new_t;
     }

protected:
     T t;
};

//------------------------------------------------------------------------

template <class T>
class generic_functor_for {
public:
     typedef typename boost::mpl::if_c<
         is_lightweight_object<T>::value && !
boost::is_abstract<T>::value,
         generic_functor<T>,
         generic_functor<T&>
     >::type type;
};

//------------------------------------------------------------------------

void main() {
     lightweight_object thin_obj1(1), thin_obj2(2);
     heavyweight_object fat_obj1(100), fat_obj2(200);
     abstract_object &abstract_obj1 = thin_obj1, &abstract_obj2 =
fat_obj1;

     // calls lightweight_object copy constructor [OK]
     generic_functor_for<lightweight_object>::type g1(thin_obj1);
     g1(); // print: 1 [OK]
     g1.change(thin_obj2); // calls operator= [OK]
     g1(); // print: 2 [OK]

     // do not call heavyweight_object copy constructor [OK]
     generic_functor_for<heavyweight_object>::type g2(fat_obj1);
     g2(); // print: 100 [OK]
     g2.change(fat_obj2); // calls operator= [WRONG]
     g2(); // print: 200

     generic_functor_for<abstract_object>::type g3(abstract_obj1);
     g3(); // print: 1 [OK]
     g3.change(abstract_obj2); // calls operator= [WRONG!]
     g3(); // print: 1 [WRONG]

     generic_functor_for<abstract_object>::type g4(abstract_obj2);
     g4(); // print: 200 [WRONG!]
}

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