Object forwarding and user-data

Hi,

It is nice to see that the C++11 opens up better ways to things. Now
that even Visual Studio 2010 has some rudimentary C++11 support, it
seems to me that new idioms are starting to appear.

I'll present here an interesting idiom, and new at least to me, to
make it easy to embed user-data into the parts of data structures (say
an edge-label into a graph data-structure). It is based on the
combination of perfect forwarding and inheritance. Comments welcome:)

Properties
----------

Some desirable properties from such an embedding would be that

   1) it follows the zero-overhead principle: if user-data is not
needed, it will not take any resources,

   2) it supports arbitrary types, not just class types, and

   3) given a part p, the user-data or user-member-functions can be
accessed directly from p, as in p.label and p.f().

Solution
--------

The zero-overhead problem can be solved by making use of the empty
base-class optimization, thus requiring to inherit the part-type from
the user data-type. Conveniently, the property 3 can also be achieved
by the same inheritance (it is the only way to do it). What remains is
to solve the arbitrary type problem, since non-class types can not be
inherited from. This can be solved by creating a _forwarding object_,
which is an object containing another object, where the containing
object forwards all operations to the contained object, and which is
implicitly convertible to the contained object.

In case the user data-type is not a class, the part inherits the
forwarding type instead; in the other case, the part inherits the type
itself. In case the type is void, the forwarding type specializes to
an empty class, to support the empty base-class optimization. As a
final touch, the part deletes its assignment operator (as it already
should have done, since it is a part with internal invariants), and
brings into the scope the assignment operator of the user
data-type. The following example demonstrates the idea by embedding a
user-defined label to an edge of a graph. I have checked that this
compiles in Ideone (Visual Studio 2010 lacks variadic
templates... what I actually do is to simulate 1 to 6 parameters
forwarding constructors).

Concrete example
----------------

#include <type_traits>
#include <utility>

//! A forwarding class for non-class types.
template <typename Type>
class Class;

template <>
class Class<void> {};

template <typename Type>
class Class
{
public:
      static_assert(!std::is_class<Type>::value,
          "Only non-class types are allowed to be forwarded.");

      Class()
          : member_()
      {
      }

      template <typename... ParameterSet>
      Class(ParameterSet&&... parameterSet)
          : member_(std::forward<ParameterSet...>(parameterSet...))
      {
      }

      operator Type&()
      {
          return member_;
      }

      operator const Type&() const
      {
          return member_;
      }

private:
      Type member_;
};

//! Turns a non-class type into a forwarding class.
template <typename Type>
class Forward
{
public:
      typedef typename std::conditional<
          std::is_class<Type>::value,
          Type,
          Class<Type>>::type type;
};

class Vertex {};

template <typename EdgeData>
class Edge
      : public Forward<EdgeData>::type
{
public:
      typedef typename Forward<EdgeData>::type Base;
      using Base::operator=;
      Edge& operator=(Edge that) = delete;

      Edge()
          : Base()
      {
      }

      template <typename... Data>
      explicit Edge(Data&&... data)
          : Base(std::forward<Data...>(data...))
      {
      }

      Vertex* from() {return from_;}
      Vertex* to() {return to_;}

private:
      Vertex* from_;
      Vertex* to_;
};

class Label
{
public:
      explicit Label(int label_)
          : label(label_)
      {
      }

      int label;
};

int main()
{
      Edge<void> a;
      a;
      a.from();

      Edge<int> b(2);
      b = 5;
      b.to();

      Edge<Label> c(2);
      c.label = 5;
      c.from();

      return 0;
}

--
http://kaba.hilvi.org

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