[Boost-users] Property map design

From: Daniel Mitchell (danmitchell_at_[hidden])
Date: 2006-03-05 15:19:57

I'd like to know a little more about the design rationale for property maps, 
specifically the (maybe implicit) decision not to overload operator[] with 
respect to constness. The design leads to a situation that is, in some 
respects, at odds with convention.

The most obvious point of conflict is put_get_helper. In fact, I wouldn't be 
surprised if the decision not to overload operator[] was simply a consequence 
of writing put_get_helper. (Pure speculation.)

template<class Reference, class PropertyMap>
struct put_get_helper { };

template<class R, class P, class K>
R get( put_get_helper<R,P> const& map, K const& key );

template<class R, class P, class K, class V>
void put( put_get_helper<R,P> const& map, K const& key, V const& value );

In contrast with standard containers, the constness of the property map isn't 
correlated to the constness of its elements. I wonder why the above wasn't 
written as

template<class Reference, class PropertyMap, class ConstReference>
struct put_get_helper { };

template<class R, class P, class C, class K>
R get( put_get_helper<R,P,C>& map, K const& key );

template<class R, class P, class C, class K>
C get( put_get_helper<R,P,C> const& map, K const& key );

template<class R, class P, class C, class K, class V>
void put( put_get_helper<R,P,C>& map, K const& key, V const& value );

Another point of conflict is the property_map traits class, with its nested 
'type' and 'const_type'. Doesn't convention suggest that 'type const' is the 
appropriate type for a non-mutable property map?

My initial statement was that the design leads to a situation that is *in some 
respects* at odds with convention. When property maps are viewed, not as 
first class containers of their data, but as having more-or-less the same 
status as container iterators, the situation clarifies. I suppose that must 
have been the author's intent.

// A deficient, but harmless implementation of put(), get() for iterators.
template<class Reference, class Iterator>
struct put_get_helper { };

template<class R, class I, class K>
R get( put_get_helper<R,I> const& it, K const& key );

template<class R, class I, class K, class V>
void put( put_get_helper<R,I> const& it, K const& key, V const& value );

// Parallel to property_map.
template<class Container>
struct container_iterator {
  typedef typename Container::iterator type;
  typedef typename Container::const_iterator const_type;
};