Boost :

powellg_at_[hidden]

-- 
Dave Abrahams
----------------------------------------------------------------------
Ok, reusing Andrei's mojo name I've got the following working:
template <class T>
class mojo 
{
protected:
    struct ref
    {
        template<class T2>
        ref(T2 *rhs) : p(rhs) {} // works if there is a conversion.
        template<class T2>
        ref(mojo<T2> *rhs) : p( static_cast<T *>(rhs) ) {} // works if there is a conversion.
        template<class T2>
        ref(mojo<T2> &rhs) : p( static_cast<T *>(rhs.p) ) {} // works if there is a conversion.
        T * p; 
        T *operator->() const
        {
            return p;
        }
        T *operator&() const
        {
           return p;
        }
    };
    mojo() {} // intended to be derived from.
public:    // Move stuff
    operator ref() {
        return ref(this);
    }
};
struct X : public mojo<X>
{
....
    // non-const rvalue
    X(mojo<X>::ref rhs)
      : id(++cnt)
      , owner(rhs->owner)
    {
        std::cout << "MOVE X#" << id << " <== X#" << rhs->id << " owner = " << std::boolalpha << rhs->owner << std::endl;
        rhs->owner = false;
        assert(owner);
    }
....
};
struct Y : public X, public mojo<Y>
{
....
    // non-const rvalue
    Y(mojo<Y>::ref rhs)
      : X ( &rhs )
      , id(++cnt)
      , owner(rhs->owner)
    {
        std::cout << "MOVE Y#" << id << " <== Y#" << rhs->id << " owner = " << std::boolalpha << std::boolalpha << rhs->owner << std::endl;
        rhs->owner = false;
        assert(owner);
    }
...
};
struct V : virtual public X, public mojo<V>
{
....
    // non-const rvalue
    V(mojo<V>::ref rhs)
      : X( &rhs)
      , id(++cnt)
      , owner(rhs->owner)
    {
        std::cout << "MOVE V#" << id << " <== V#" << rhs->id << " owner = " << std::boolalpha << rhs->owner << std::endl;
        rhs->owner = false;
        assert(owner);
    }
...
};
same for class W. (virtual inheritence)
struct U : virtual public V, virtual public W, public mojo<U>
{
....
    // non-const rvalue
    U(mojo<U>::ref rhs)
      : X( &rhs )
      , V( &rhs )
      , W( &rhs )
      , id(++cnt)
      , owner(rhs->owner)
    {
        std::cout << "MOVE U#" << id << " <== U#" << rhs->id << " owner = "  << std::boolalpha << rhs->owner << std::endl;
        rhs->owner = false;
        assert(owner);
    }
...
};
And it all seems to work correctly.
IMO it's not too bad of a "library" module. In any case I like using the operator->() as you can stop referencing the pointer "ref.p". And I chose operator &() but perhaps a "get() member fn of mojo is the right thing to do. As to whether to call it mojo or not...well I didn't have another class name in mind.
If you don't have mulitiple inheritence you don't have to specify mojo<Type>::ref, so that's nice as well.
Anyway I saw Bjarne's call for items on the list, and IMO, this topic deserves it if nothing more than to clarify that its OK.
  -Gary-