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

On Sep 6, 2:02 pm, Edson Manoel <e.ta...@gmail.com> wrote:


As no one replied, I am assuming that this is not a very known pattern
and that there is not a common solution (library) that implements this
pattern. I've got it to work (see the following code); it even works
with raw and smart pointers.

The main problem now is that it is not transparent to the functor
implementation, i.e., the functor must be prepared, so it will not
work directly with old functors (STL, etc.). Actually, the functor<T>
must hold a "possibly_wrapped<T>::type" instead of T directly, and it
must call wrap() when assigning to it, and unwrap() when accessing it
(member functions, etc.). The advantage is that it will automatically
switch between holding by value or holding by reference as needed. The
ultimate goal was to make this transparent to the FUNCTOR side (i.e.,
the wrapping mechanism would be all on the CALLING side), but I think
this is not possible, so, this is already good for me.

I appreciate any comments; if someone is interested in further
developments, would like to review the code or only point some tips,
let me know.

  Thanks,
Edson Manoel

#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/type_traits/is_pointer.hpp>
#include <boost/mpl/if.hpp>

#include <boost/ref.hpp>
#include <boost/utility/enable_if.hpp>

#include <boost/shared_ptr.hpp>

using namespace std;
using namespace boost;

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

// trait to query classes for lightweightness
template <class T>
class is_lightweight_object
    : public 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 mpl::true_ {};

template <>
class is_lightweight_object<const lightweight_object>
    : public 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;
};

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

template <class T>
class is_pointer_like : public is_pointer<T>::type {};

template <class U>
class is_pointer_like< shared_ptr<U> > : public mpl::true_ {};

template <class U>
class is_pointer_like< weak_ptr<U> > : public mpl::true_ {};

template <class T>
class should_refwrap
    : public mpl::bool_<( !is_lightweight_object<T>::value
                         && !is_pointer_like<T>::value)
                        || is_abstract<T>::value> {};

template <class T>
class possibly_wrapped {
public:
    typedef typename mpl::if_<
        should_refwrap<T>,
        reference_wrapper<T>,
        T
    >::type type;
};

template <class T>
typename enable_if< should_refwrap<T>, reference_wrapper<T> >::type
wrap(T const& x) {
    return ref(const_cast<T&>(x));
}

template <class T>
typename disable_if< should_refwrap<T>, T const& >::type
wrap(T const& x) {
    return x;
}

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

template <class T>
class unwrapped_type {
public:
    typedef typename unwrap_reference<T>::type type;
};

template <class T>
typename unwrapped_type<T>::type&
unwrap(T& x) {
    return x;
}

template <class T>
T& unwrap(T* x) {
    return *x;
}

template <class T>
T& unwrap(shared_ptr<T> x) {
    return *x;
}

template <class T>
T& unwrap(weak_ptr<T> x) {
    return *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 possibly_wrapped<T>::type T_held_type;

    generic_functor(T& p)
        : t(wrap(p)) {}

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

    inline void change(T const& new_t) {
        this->t = wrap(new_t);
    }

protected:
    T_held_type t;
};

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

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<lightweight_object> 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<heavyweight_object> g2(fat_obj1);
    g2(); // print: 100 [OK]
    g2.change(fat_obj2); // do NOT call operator= [OK]
    g2(); // print: 200 [OK]

    generic_functor<abstract_object> g3(abstract_obj1);
    g3(); // print: 1 [OK]
    g3.change(abstract_obj2); // [OK]
    g3(); // print: 100 [OK]

    generic_functor<abstract_object> g4(abstract_obj2);
    g4(); // print: 100 [OK]

    abstract_object *ptr1 = new lightweight_object(3);
    abstract_object *ptr2 = new heavyweight_object(300);
    generic_functor< abstract_object* > g5(ptr1);
    g5(); // print: 3 [OK]
    g5.change(ptr2);
    g5(); // print: 300 [OK]
    delete ptr1;
    delete ptr2;

    shared_ptr<abstract_object> ptr3( new lightweight_object(4) );
    shared_ptr<abstract_object> ptr4( new heavyweight_object(400) );
    generic_functor< shared_ptr<abstract_object> > g6(ptr3);
    g6(); // print: 4 [OK]
    g6.change(ptr4);
    g6(); // print: 400 [OK]
}

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