lyx_mirror/boost/boost/property_map.hpp
Lars Gullik Bjønnes e1644a68eb update boost to pre-1.30.0
git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@6319 a592a061-630c-0410-9148-cb99ea01b6c8
2003-03-03 15:53:48 +00:00

543 lines
18 KiB
C++

// (C) Copyright Jeremy Siek 1999-2001. Permission to copy, use, modify,
// sell and distribute this software is granted provided this
// copyright notice appears in all copies. This software is provided
// "as is" without express or implied warranty, and with no claim as
// to its suitability for any purpose.
// See http://www.boost.org/libs/property_map for documentation.
#ifndef BOOST_PROPERTY_MAP_HPP
#define BOOST_PROPERTY_MAP_HPP
#include <cassert>
#include <boost/config.hpp>
#include <boost/pending/cstddef.hpp>
#include <boost/detail/iterator.hpp>
#include <boost/concept_check.hpp>
#include <boost/concept_archetype.hpp>
namespace boost {
//=========================================================================
// property_traits class
template <typename PA>
struct property_traits {
typedef typename PA::key_type key_type;
typedef typename PA::value_type value_type;
typedef typename PA::reference reference;
typedef typename PA::category category;
};
//=========================================================================
// property_traits category tags
namespace detail {
enum ePropertyMapID { READABLE_PA, WRITABLE_PA,
READ_WRITE_PA, LVALUE_PA, OP_BRACKET_PA,
RAND_ACCESS_ITER_PA, LAST_PA };
}
struct readable_property_map_tag { enum { id = detail::READABLE_PA }; };
struct writable_property_map_tag { enum { id = detail::WRITABLE_PA }; };
struct read_write_property_map_tag :
public readable_property_map_tag,
public writable_property_map_tag
{ enum { id = detail::READ_WRITE_PA }; };
struct lvalue_property_map_tag : public read_write_property_map_tag
{ enum { id = detail::LVALUE_PA }; };
//=========================================================================
// property_traits specialization for pointers
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
// The user will just have to create their own specializations for
// other pointers types if the compiler does not have partial
// specializations. Sorry!
#define BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(TYPE) \
template <> \
struct property_traits<TYPE*> { \
typedef TYPE value_type; \
typedef value_type& reference; \
typedef std::ptrdiff_t key_type; \
typedef lvalue_property_map_tag category; \
}; \
template <> \
struct property_traits<const TYPE*> { \
typedef TYPE value_type; \
typedef const value_type& reference; \
typedef std::ptrdiff_t key_type; \
typedef lvalue_property_map_tag category; \
}
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(long);
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(unsigned long);
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(int);
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(unsigned int);
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(short);
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(unsigned short);
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(char);
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(unsigned char);
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(signed char);
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(bool);
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(float);
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(double);
BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(long double);
// This may need to be turned off for some older compilers that don't have
// wchar_t intrinsically.
# ifndef BOOST_NO_INTRINSIC_WCHAR_T
template <>
struct property_traits<wchar_t*> {
typedef wchar_t value_type;
typedef value_type& reference;
typedef std::ptrdiff_t key_type;
typedef lvalue_property_map_tag category;
};
template <>
struct property_traits<const wchar_t*> {
typedef wchar_t value_type;
typedef const value_type& reference;
typedef std::ptrdiff_t key_type;
typedef lvalue_property_map_tag category;
};
# endif
#else
template <class T>
struct property_traits<T*> {
typedef T value_type;
typedef value_type& reference;
typedef std::ptrdiff_t key_type;
typedef lvalue_property_map_tag category;
};
template <class T>
struct property_traits<const T*> {
typedef T value_type;
typedef const value_type& reference;
typedef std::ptrdiff_t key_type;
typedef lvalue_property_map_tag category;
};
#endif
#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
// MSVC doesn't have Koenig lookup, so the user has to
// do boost::get() anyways, and the using clause
// doesn't really work for MSVC.
} // namespace boost
#endif
// These need to go in global namespace because Koenig
// lookup does not apply to T*.
// V must be convertible to T
template <class T, class V>
inline void put(T* pa, std::ptrdiff_t k, const V& val) { pa[k] = val; }
template <class T>
inline const T& get(const T* pa, std::ptrdiff_t k) { return pa[k]; }
#if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
namespace boost {
using ::put;
using ::get;
#endif
//=========================================================================
// concept checks for property maps
template <class PMap, class Key>
struct ReadablePropertyMapConcept
{
typedef typename property_traits<PMap>::key_type key_type;
typedef typename property_traits<PMap>::reference reference;
typedef typename property_traits<PMap>::category Category;
typedef boost::readable_property_map_tag ReadableTag;
void constraints() {
function_requires< ConvertibleConcept<Category, ReadableTag> >();
val = get(pmap, k);
}
PMap pmap;
Key k;
typename property_traits<PMap>::value_type val;
};
template <typename KeyArchetype, typename ValueArchetype>
struct readable_property_map_archetype {
typedef KeyArchetype key_type;
typedef ValueArchetype value_type;
typedef convertible_to_archetype<ValueArchetype> reference;
typedef readable_property_map_tag category;
};
template <typename K, typename V>
const typename readable_property_map_archetype<K,V>::reference&
get(const readable_property_map_archetype<K,V>&, const K&) {
typedef typename readable_property_map_archetype<K,V>::reference R;
return static_object<R>::get();
}
template <class PMap, class Key>
struct WritablePropertyMapConcept
{
typedef typename property_traits<PMap>::key_type key_type;
typedef typename property_traits<PMap>::category Category;
typedef boost::writable_property_map_tag WritableTag;
void constraints() {
function_requires< ConvertibleConcept<Category, WritableTag> >();
put(pmap, k, val);
}
PMap pmap;
Key k;
typename property_traits<PMap>::value_type val;
};
template <typename KeyArchetype, typename ValueArchetype>
struct writable_property_map_archetype {
typedef KeyArchetype key_type;
typedef ValueArchetype value_type;
typedef void reference;
typedef writable_property_map_tag category;
};
template <typename K, typename V>
void put(const writable_property_map_archetype<K,V>&, const K&, const V&) { }
template <class PMap, class Key>
struct ReadWritePropertyMapConcept
{
typedef typename property_traits<PMap>::category Category;
typedef boost::read_write_property_map_tag ReadWriteTag;
void constraints() {
function_requires< ReadablePropertyMapConcept<PMap, Key> >();
function_requires< WritablePropertyMapConcept<PMap, Key> >();
function_requires< ConvertibleConcept<Category, ReadWriteTag> >();
}
};
template <typename KeyArchetype, typename ValueArchetype>
struct read_write_property_map_archetype
: public readable_property_map_archetype<KeyArchetype, ValueArchetype>,
public writable_property_map_archetype<KeyArchetype, ValueArchetype>
{
typedef KeyArchetype key_type;
typedef ValueArchetype value_type;
typedef convertible_to_archetype<ValueArchetype> reference;
typedef read_write_property_map_tag category;
};
template <class PMap, class Key>
struct LvaluePropertyMapConcept
{
typedef typename property_traits<PMap>::category Category;
typedef boost::lvalue_property_map_tag LvalueTag;
typedef typename property_traits<PMap>::reference reference;
void constraints() {
function_requires< ReadablePropertyMapConcept<PMap, Key> >();
function_requires< ConvertibleConcept<Category, LvalueTag> >();
typedef typename property_traits<PMap>::value_type value_type;
typedef typename require_same<
const value_type&, reference>::type req;
reference ref = pmap[k];
ignore_unused_variable_warning(ref);
}
PMap pmap;
Key k;
};
template <typename KeyArchetype, typename ValueArchetype>
struct lvalue_property_map_archetype
: public readable_property_map_archetype<KeyArchetype, ValueArchetype>
{
typedef KeyArchetype key_type;
typedef ValueArchetype value_type;
typedef const ValueArchetype& reference;
typedef lvalue_property_map_tag category;
const value_type& operator[](const key_type&) const {
return static_object<value_type>::get();
}
};
template <class PMap, class Key>
struct Mutable_LvaluePropertyMapConcept
{
typedef typename property_traits<PMap>::category Category;
typedef boost::lvalue_property_map_tag LvalueTag;
typedef typename property_traits<PMap>::reference reference;
void constraints() {
boost::function_requires< ReadWritePropertyMapConcept<PMap, Key> >();
boost::function_requires<ConvertibleConcept<Category, LvalueTag> >();
typedef typename property_traits<PMap>::value_type value_type;
typedef typename require_same<
value_type&,
reference>::type req;
reference ref = pmap[k];
ignore_unused_variable_warning(ref);
}
PMap pmap;
Key k;
};
template <typename KeyArchetype, typename ValueArchetype>
struct mutable_lvalue_property_map_archetype
: public readable_property_map_archetype<KeyArchetype, ValueArchetype>,
public writable_property_map_archetype<KeyArchetype, ValueArchetype>
{
typedef KeyArchetype key_type;
typedef ValueArchetype value_type;
typedef ValueArchetype& reference;
typedef lvalue_property_map_tag category;
value_type& operator[](const key_type&) const {
return static_object<value_type>::get();
}
};
struct identity_property_map;
// A helper class for constructing a property map
// from a class that implements operator[]
template <class Reference, class LvaluePropertyMap>
struct put_get_helper { };
template <class PropertyMap, class Reference, class K>
inline Reference
get(const put_get_helper<Reference, PropertyMap>& pa, const K& k)
{
Reference v = static_cast<const PropertyMap&>(pa)[k];
return v;
}
template <class PropertyMap, class Reference, class K, class V>
inline void
put(const put_get_helper<Reference, PropertyMap>& pa, K k, const V& v)
{
static_cast<const PropertyMap&>(pa)[k] = v;
}
//=========================================================================
// Adapter to turn a RandomAccessIterator into a property map
template <class RandomAccessIterator,
class IndexMap
#ifdef BOOST_NO_STD_ITERATOR_TRAITS
, class T, class R
#else
, class T = typename std::iterator_traits<RandomAccessIterator>::value_type
, class R = typename std::iterator_traits<RandomAccessIterator>::reference
#endif
>
class iterator_property_map
: public boost::put_get_helper< R,
iterator_property_map<RandomAccessIterator, IndexMap,
T, R> >
{
public:
typedef typename property_traits<IndexMap>::key_type key_type;
typedef T value_type;
typedef R reference;
typedef boost::lvalue_property_map_tag category;
inline iterator_property_map(
RandomAccessIterator cc = RandomAccessIterator(),
const IndexMap& _id = IndexMap() )
: iter(cc), index(_id) { }
inline R operator[](key_type v) const { return *(iter + get(index, v)) ; }
protected:
RandomAccessIterator iter;
IndexMap index;
};
#if !defined BOOST_NO_STD_ITERATOR_TRAITS
template <class RAIter, class ID>
inline iterator_property_map<
RAIter, ID,
typename std::iterator_traits<RAIter>::value_type,
typename std::iterator_traits<RAIter>::reference>
make_iterator_property_map(RAIter iter, ID id) {
function_requires< RandomAccessIteratorConcept<RAIter> >();
typedef iterator_property_map<
RAIter, ID,
typename std::iterator_traits<RAIter>::value_type,
typename std::iterator_traits<RAIter>::reference> PA;
return PA(iter, id);
}
#endif
template <class RAIter, class Value, class ID>
inline iterator_property_map<RAIter, ID, Value, Value&>
make_iterator_property_map(RAIter iter, ID id, Value) {
function_requires< RandomAccessIteratorConcept<RAIter> >();
typedef iterator_property_map<RAIter, ID, Value, Value&> PMap;
return PMap(iter, id);
}
template <class RandomAccessIterator,
class IndexMap
#ifdef BOOST_NO_STD_ITERATOR_TRAITS
, class T, class R
#else
, class T = typename std::iterator_traits<RandomAccessIterator>::value_type
, class R = typename std::iterator_traits<RandomAccessIterator>::reference
#endif
>
class safe_iterator_property_map
: public boost::put_get_helper< R,
safe_iterator_property_map<RandomAccessIterator, IndexMap,
T, R> >
{
public:
typedef typename property_traits<IndexMap>::key_type key_type;
typedef T value_type;
typedef R reference;
typedef boost::lvalue_property_map_tag category;
inline safe_iterator_property_map(
RandomAccessIterator first = RandomAccessIterator(),
std::size_t n = 0,
const IndexMap& _id = IndexMap() )
: iter(first), n(n), index(_id) { }
inline R operator[](key_type v) const {
assert(get(index, v) < n);
return *(iter + get(index, v)) ;
}
typename property_traits<IndexMap>::value_type size() const { return n; }
protected:
RandomAccessIterator iter;
typename property_traits<IndexMap>::value_type n;
IndexMap index;
};
#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
template <class RAIter, class ID>
inline safe_iterator_property_map<
RAIter, ID,
typename boost::detail::iterator_traits<RAIter>::value_type,
typename boost::detail::iterator_traits<RAIter>::reference>
make_safe_iterator_property_map(RAIter iter, std::size_t n, ID id) {
function_requires< RandomAccessIteratorConcept<RAIter> >();
typedef safe_iterator_property_map<
RAIter, ID,
typename boost::detail::iterator_traits<RAIter>::value_type,
typename boost::detail::iterator_traits<RAIter>::reference> PA;
return PA(iter, n, id);
}
#endif
template <class RAIter, class Value, class ID>
inline safe_iterator_property_map<RAIter, ID, Value, Value&>
make_safe_iterator_property_map(RAIter iter, std::size_t n, ID id, Value) {
function_requires< RandomAccessIteratorConcept<RAIter> >();
typedef safe_iterator_property_map<RAIter, ID, Value, Value&> PMap;
return PMap(iter, n, id);
}
//=========================================================================
// An adaptor to turn a Unique Pair Associative Container like std::map or
// std::hash_map into an Lvalue Property Map.
template <typename UniquePairAssociativeContainer>
class associative_property_map
: public boost::put_get_helper<
typename UniquePairAssociativeContainer::value_type::second_type&,
associative_property_map<UniquePairAssociativeContainer> >
{
typedef UniquePairAssociativeContainer C;
public:
typedef typename C::key_type key_type;
typedef typename C::value_type::second_type value_type;
typedef value_type& reference;
typedef lvalue_property_map_tag category;
associative_property_map() : m_c(0) { }
associative_property_map(C& c) : m_c(&c) { }
reference operator[](const key_type& k) const {
return (*m_c)[k];
}
private:
C* m_c;
};
template <class UniquePairAssociativeContainer>
associative_property_map<UniquePairAssociativeContainer>
make_assoc_property_map(UniquePairAssociativeContainer& c)
{
return associative_property_map<UniquePairAssociativeContainer>(c);
}
template <typename UniquePairAssociativeContainer>
class const_associative_property_map
: public boost::put_get_helper<
const typename UniquePairAssociativeContainer::value_type::second_type&,
const_associative_property_map<UniquePairAssociativeContainer> >
{
typedef UniquePairAssociativeContainer C;
public:
typedef typename C::key_type key_type;
typedef typename C::value_type::second_type value_type;
typedef const value_type& reference;
typedef lvalue_property_map_tag category;
const_associative_property_map() : m_c(0) { }
const_associative_property_map(const C& c) : m_c(&c) { }
reference operator[](const key_type& k) const {
return m_c->find(k)->second;
}
private:
C const* m_c;
};
template <class UniquePairAssociativeContainer>
const_associative_property_map<UniquePairAssociativeContainer>
make_assoc_property_map(const UniquePairAssociativeContainer& c)
{
return const_associative_property_map<UniquePairAssociativeContainer>(c);
}
//=========================================================================
// A property map that applies the identity function to integers
struct identity_property_map
: public boost::put_get_helper<std::size_t,
identity_property_map>
{
typedef std::size_t key_type;
typedef std::size_t value_type;
typedef std::size_t reference;
typedef boost::readable_property_map_tag category;
inline value_type operator[](const key_type& v) const { return v; }
};
//=========================================================================
// A property map that does not do anything, for
// when you have to supply a property map, but don't need it.
namespace detail {
struct dummy_pmap_reference {
template <class T>
dummy_pmap_reference& operator=(const T&) { return *this; }
operator int() { return 0; }
};
}
class dummy_property_map
: public boost::put_get_helper<detail::dummy_pmap_reference,
dummy_property_map >
{
public:
typedef void key_type;
typedef int value_type;
typedef detail::dummy_pmap_reference reference;
typedef boost::read_write_property_map_tag category;
inline dummy_property_map() : c(0) { }
inline dummy_property_map(value_type cc) : c(cc) { }
inline dummy_property_map(const dummy_property_map& x)
: c(x.c) { }
template <class Vertex>
inline reference operator[](Vertex) const { return reference(); }
protected:
value_type c;
};
} // namespace boost
#endif /* BOOST_PROPERTY_MAP_HPP */