Boost logo

Boost :

From: Hamish Mackenzie (boost_at_[hidden])
Date: 2002-02-14 09:45:19

On Wed, 2002-02-13 at 09:01, Geurt Vos wrote:
> For the declaration I'm thinking of something like:
> boost::property<
> boost::read<int,A,&A::get_it>,
> boost::write<int,A,&A::set_it>
> > value;
In order to avoid the storage overhead how about calling it
property_proxy and returning it from a member function ie.

class A
  typedef boost::property_proxy<
> value_proxy;

  value_proxy value()
    { return value_proxy( this ); }
  typename value_proxy::const_proxy value() const
    { return typename value_proxy::const_proxy( this ); }

Where const_proxy is a version that stores a const A * and only allows
calls to the read function.

You could make this sorter one of two ways

a) Use multiple inheritance

class value {};

class A : public
  property_owner< A, int, value, &A::get_value, &A::set_value >,
  property_lookup< A >
} x;

property_lookup would have provide a member function "property" which
could be used like this

A x;< value >() = 7

b) Use a macro. Yuk but it might be the simplest solution.

Should it use boost::noncopyable?

Another question is whether or not the property proxy should be
copyable. If the proxy can be copied then it would allow delayed calls
to get_it and set_it. This may be counter intuitive and complicate
threading issues but it also might be very powerful.

I personaly think it should be posible but only if the user explicitly
requests it. This could be accomplished as follows

1) Make boost::property_proxy non copyable

2) Introduce a boost::property_ref that is copyable and can be
explicitly constructed from property_proxy

3) Have a common property class for constructing proxy, ref, const_proxy
and const_ref.

class A
  typedef boost::property<
> value_propery;

  typename value_propery::proxy value()
    { return value_propery::proxy( this ); }
  typename value_propery::const_proxy value() const
    { return value_propery::const_proxy( this ); }

User of the class can then store a reference to a property using

A x;
typename A::value_property::ref r( x.value() );
int v = r; // calls get_value on x

Hamish Mackenzie

Boost list run by bdawes at, gregod at, cpdaniel at, john at