mirror of
https://github.com/boostorg/graph.git
synced 2026-01-29 07:32:21 +00:00
Removing experimental headers. To be worked on later.
[SVN r53717]
This commit is contained in:
Andrew Sutton
@@ -1,108 +0,0 @@
|
||||
// (C) Copyright Andrew Sutton 2008-2009
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_GRAPH_DETAIL_HASHED_PROPERTIES_HPP
|
||||
#define BOOST_GRAPH_DETAIL_HASHED_PROPERTIES_HPP
|
||||
|
||||
#include <tr1/unordered_map>
|
||||
#include <boost/iterator/iterator_facade.hpp>
|
||||
#include <boost/functional/hash.hpp>
|
||||
|
||||
namespace boost { namespace graph_detail {
|
||||
|
||||
/**
|
||||
* Wrap an iterator with a default value so that it generates default values
|
||||
* over a range of keys.
|
||||
*/
|
||||
template <typename Iter, typename Prop>
|
||||
struct key_value_iterator
|
||||
{
|
||||
typedef typename std::forward_iterator_tag iterator_category;
|
||||
typedef typename std::size_t difference_type;
|
||||
|
||||
typedef std::pair<typename Iter::value_type, Prop> value_type;
|
||||
typedef value_type reference;
|
||||
typedef value_type pointer;
|
||||
|
||||
key_value_iterator(Iter i, Prop const& p)
|
||||
: iter(i), value(p)
|
||||
{ }
|
||||
|
||||
key_value_iterator& operator++()
|
||||
{ ++iter; return *this; }
|
||||
|
||||
reference operator*()
|
||||
{ return make_pair(*iter, value); }
|
||||
|
||||
bool operator==(key_value_iterator const& x) const
|
||||
{ return iter == x.iter; }
|
||||
|
||||
bool operator!=(key_value_iterator const& x) const
|
||||
{ return iter != x.iter; }
|
||||
|
||||
Iter iter;
|
||||
Prop value;
|
||||
};
|
||||
|
||||
template <typename Iter, typename Prop>
|
||||
inline key_value_iterator<Iter, Prop>
|
||||
make_key_value_iterator(Iter i, Prop const& x)
|
||||
{ return key_value_iterator<Iter, Prop>(i, x); }
|
||||
|
||||
/**
|
||||
* A simple wrapper around an unordered map, this is used to map descriptors
|
||||
* to arbitrary property values. Note that the property type must be default
|
||||
* constructible.
|
||||
*
|
||||
* This may seem a little odd because we're passing an iterator and not the key
|
||||
* type. However, the key type is always the iterator's value type.
|
||||
*/
|
||||
template <typename Descriptor, typename Property>
|
||||
class hashed_property_container
|
||||
{
|
||||
public:
|
||||
typedef Property value_type;
|
||||
typedef Descriptor key_type;
|
||||
typedef std::tr1::unordered_map<key_type, value_type, boost::hash<key_type>> container_type;
|
||||
|
||||
/**
|
||||
* Construct the hashtable over n buckets. This may not actually allocate
|
||||
* n buckets, so we can't necessarily guarantee that memory will actually
|
||||
* be allocated for each element, much less what those default values would
|
||||
* actually be.
|
||||
*/
|
||||
hashed_property_container(std::size_t n)
|
||||
: data(n)
|
||||
{ }
|
||||
|
||||
/**
|
||||
* Construct the hashtable over the keys in the iterator range [f, l) with
|
||||
* the default value x.
|
||||
*/
|
||||
template <typename Iter>
|
||||
hashed_property_container(Iter f, Iter l, value_type const& x)
|
||||
: data(detail::make_key_value_iterator(f, x),
|
||||
detail::make_key_value_iterator(l, value_type()))
|
||||
{ }
|
||||
|
||||
template <typename Range>
|
||||
hashed_property_container(Range rng, value_type const& x)
|
||||
: data(detail::make_key_value_iterator(rng.first, x),
|
||||
detail::make_key_value_iterator(rng.second, value_type()))
|
||||
{ }
|
||||
|
||||
inline value_type& operator[](key_type const& k)
|
||||
{ return data[k]; }
|
||||
|
||||
inline value_type const& operator[](key_type const& k) const
|
||||
{ return data[k]; }
|
||||
|
||||
container_type data;
|
||||
};
|
||||
|
||||
} } // namespace boost::graph_detail
|
||||
|
||||
|
||||
#endif
|
||||
@@ -1,102 +0,0 @@
|
||||
// (C) Copyright Andrew Sutton 2008-2009
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_GRAPH_DETAIL_INDEXED_PROPERTIES_HPP
|
||||
#define BOOST_GRAPH_DETAIL_INDEXED_PROPERTIES_HPP
|
||||
|
||||
#include <vector>
|
||||
#include <boost/iterator/iterator_facade.hpp>
|
||||
|
||||
namespace boost { namespace graph_detail {
|
||||
|
||||
/**
|
||||
* Wrap an iterator with a default value so that it generates default values
|
||||
* over a range of keys. This maintains the defalt value as an object to
|
||||
* prevent multiple constructions if the object is "heavy".
|
||||
*/
|
||||
template <typename Iter, typename Prop>
|
||||
struct default_value_iterator
|
||||
: iterator_facade<
|
||||
default_value_iterator<Iter, Prop>, Prop, std::forward_iterator_tag,
|
||||
Prop const&
|
||||
>
|
||||
{
|
||||
typedef typename std::forward_iterator_tag iterator_category;
|
||||
typedef std::size_t difference_type;
|
||||
|
||||
typedef Prop value_type;
|
||||
typedef value_type const& reference;
|
||||
typedef value_type const* pointer;
|
||||
|
||||
default_value_iterator(Iter i, Prop const& p)
|
||||
: iter(i), value(p)
|
||||
{ }
|
||||
|
||||
void advance()
|
||||
{ ++iter; }
|
||||
|
||||
bool equal(default_value_iterator const& x) const
|
||||
{ return iter == x.iter; }
|
||||
|
||||
Prop const& dereference() const
|
||||
{ return value; }
|
||||
|
||||
Iter iter;
|
||||
Prop value;
|
||||
};
|
||||
|
||||
template <typename Iter, typename Prop>
|
||||
inline default_value_iterator<Iter, Prop>
|
||||
make_default_value_iterator(Iter i, Prop const& p)
|
||||
{ return default_value_iterator<Iter, Prop>(i, p); }
|
||||
|
||||
/**
|
||||
* A simple wrapper around a vector. Because the "key" to this vector is
|
||||
* actually given as a descriptor, we have to get the underlying index that
|
||||
* allows us to map this value to a property.
|
||||
*
|
||||
* @todo If the underlying container is shared, then this can act as both
|
||||
* the property map and the container. Or we could have the property map
|
||||
* be a shared_ptr to this (or other) containers.
|
||||
*/
|
||||
template <typename Descriptor, typename Property>
|
||||
struct indexed_property_container
|
||||
{
|
||||
typedef Property value_type;
|
||||
typedef Descriptor key_type;
|
||||
typedef std::vector<Property> container_type;
|
||||
|
||||
inline indexed_property_container(std::size_t n)
|
||||
: data(n)
|
||||
{ }
|
||||
|
||||
/**
|
||||
* Construct the hashtable over the keys in the iterator range [f, l) with
|
||||
* the default value x.
|
||||
*/
|
||||
template <typename Iter>
|
||||
inline indexed_property_container(Iter f, Iter l, value_type const& x)
|
||||
: data(detail::make_default_value_iterator(f, x),
|
||||
detail::make_default_value_iterator(l, value_type()))
|
||||
{ }
|
||||
|
||||
template <typename Range>
|
||||
inline indexed_property_container(Range rng, value_type const& x)
|
||||
: data(detail::make_default_value_iterator(rng.first, x),
|
||||
detail::make_default_value_iterator(rng.second, value_type()))
|
||||
{ }
|
||||
|
||||
inline value_type& operator[](key_type const& k)
|
||||
{ return data[k.value]; }
|
||||
|
||||
inline value_type const& operator[](key_type const& k) const
|
||||
{ return data[k.value]; }
|
||||
|
||||
container_type data;
|
||||
};
|
||||
|
||||
} } // namespace boost::graph_detail
|
||||
|
||||
#endif
|
||||
@@ -1,192 +0,0 @@
|
||||
// (C) Copyright Andrew Sutton 2008-2009
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_GRAPH_SHARED_PROPERTIES_HPP
|
||||
#define BOOST_GRAPH_SHARED_PROPERTIES_HPP
|
||||
|
||||
#include <boost/shared_ptr.hpp>
|
||||
|
||||
#include <boost/graph/detail/hashed_property_container.hpp>
|
||||
#include <boost/graph/detail/indexed_property_container.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace graph_detail {
|
||||
// Define the mapping strategy based on the type of descriptor. By default,
|
||||
// we prefer to use hashing since the number of data structures that
|
||||
// actually index their vertices is tiny.
|
||||
struct index_mapping { };
|
||||
struct hash_mapping { };
|
||||
|
||||
/** @internal @name Descriptor Mapping */
|
||||
//@{
|
||||
template <typename Descriptor>
|
||||
struct descriptor_mapping
|
||||
{ typedef hash_mapping strategy; };
|
||||
|
||||
// If the descriptor is an unsigned int, then we can use a vector.
|
||||
template <>
|
||||
struct descriptor_mapping<std::size_t>
|
||||
{ typedef index_mapping strategy; };
|
||||
//@}
|
||||
|
||||
// Select the type of container based on the underlying store selector.
|
||||
// Noe that these have to wrap the underlying containers so that a common
|
||||
// interface exists between the two.
|
||||
template <typename Descriptor, typename Property>
|
||||
struct choose_container
|
||||
: typename mpl::if_<
|
||||
is_same<
|
||||
typename descriptor_mapping<Descriptor>::strategy, hash_mapping
|
||||
>,
|
||||
hashed_property_container<Descriptor, Property>,
|
||||
indexed_property_container<Descriptor, Property>
|
||||
>::type type;
|
||||
{ };
|
||||
|
||||
/** @internal @name Get Range
|
||||
* Return a range over the set of vertices or edges. Note that this is
|
||||
* going to be truly problematic if is_same<Vertex, Edge>.
|
||||
*/
|
||||
template <typename Graph>
|
||||
inline typename Graph::vertex_range
|
||||
get_range(Graph const& g, typename Graph::vertex_descriptor)
|
||||
{ return g.vertices(); }
|
||||
|
||||
template <typename Graph>
|
||||
inline typename Graph::edge_range
|
||||
get_range(Graph const& g, typename Graph::edge_descriptor)
|
||||
{ return g.edges(); }
|
||||
} // namespace graph_detail
|
||||
|
||||
// TODO: Work in progress.
|
||||
|
||||
/**
|
||||
* The label type allows the definition of exterior properties that
|
||||
* can maintain either their own internal store (via shared pointers) or be
|
||||
* constructed over an exterioir store. This is useful in algorithms that
|
||||
* can provide default exterior properties or allow the user to provide their
|
||||
* own.
|
||||
*
|
||||
* The use of this type incurs a slight overhead due to an additional level of
|
||||
* indirection.
|
||||
*/
|
||||
template <typename Graph, typename Descriptor, typename Label>
|
||||
struct label {
|
||||
// Select the container and map type for the self-wrapping property.
|
||||
typedef typename detail::choose_container<
|
||||
Descriptor, Label
|
||||
>::type Container;
|
||||
|
||||
typedef typename Label value_type;
|
||||
typedef typename Label& reference;
|
||||
typedef typename Descriptor key_type;
|
||||
|
||||
// By default, the optional property contains no property. This should
|
||||
// probably never be used.
|
||||
label()
|
||||
: data()
|
||||
{ }
|
||||
|
||||
// Allocate a label and build a property map over it.
|
||||
label(Graph const& g, value_type const& x = value_type())
|
||||
: container(new Container(detail::get_range(g, Descriptor()), x))
|
||||
{ }
|
||||
|
||||
// Construct the optional property over the given map, without allocating
|
||||
// an exterior label.
|
||||
label(Container& cont)
|
||||
: container(&cont)
|
||||
{ }
|
||||
|
||||
value_type& operator()(key_type const& key)
|
||||
{ return map(key); }
|
||||
|
||||
void operator()(key_type const& key, value_type const& value) const
|
||||
{ return map(key, value); }
|
||||
|
||||
optional_label& swap(optional_label& x) {
|
||||
using std::swap;
|
||||
swap(container, x.container); // Should overload to constant time op.
|
||||
swap(map, x.map);
|
||||
return *this;
|
||||
}
|
||||
|
||||
shared_ptr<Container> data;
|
||||
};
|
||||
|
||||
/**
|
||||
* The optional vertex map allows a user-provided property map or a self-
|
||||
* contained exterior property to be passed to a generic function. The user
|
||||
* provided property map is not required to be constructed over an exterior
|
||||
* property.
|
||||
*/
|
||||
template <typename Graph, typename Label>
|
||||
struct vertex_label
|
||||
: label<Graph, typename Graph::vertex_descriptor, Label>
|
||||
{
|
||||
typedef label<Graph, typename Graph::vertex_descriptor, Label> Base;
|
||||
typedef typename Base::Container Container;
|
||||
|
||||
vertex_label() : Base() { }
|
||||
vertex_label(Graph const& g, Label const& x = Label()) : Base(g, x) { }
|
||||
vertex_label(Container& cont) : Base(cost) { }
|
||||
};
|
||||
|
||||
/**
|
||||
* The optional edge map allows a user-provided property map or a self-
|
||||
* contained exterior property to be passed to a generic function. The user
|
||||
* provided property map is not required to be constructed over an exterior
|
||||
* property.
|
||||
*/
|
||||
template <typename Graph, typename Label>
|
||||
struct edge_label
|
||||
: label<Graph, typename Graph::edge_descriptor, Label>
|
||||
{
|
||||
typedef label<Graph, typename Graph::vertex_descriptor, Label> base_type;
|
||||
typedef typename Base::Container Container;
|
||||
|
||||
edge_label() : Base() { }
|
||||
edge_label(Graph const& g, Label const& x = Label()) : Base(g, x) { }
|
||||
edge_label(Container& cont) : Base(cont) { }
|
||||
};
|
||||
|
||||
namespace detail
|
||||
{
|
||||
// Optionally initialize the container, but not if the map is already
|
||||
// initialized.
|
||||
template <typename Graph, typename Map>
|
||||
void optional_init(Graph const& g, Map& map, typename Map::value_type x)
|
||||
{
|
||||
if(!map.data) {
|
||||
Map tmp(g, x);
|
||||
map.swap(tmp);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** @name Initialize Property Map
|
||||
* Delayed initialization of optional property maps. The default solution
|
||||
* is to do nothing (i.e,. the map is already initialized). Specialized
|
||||
* variants simply swap the given map with one that's actually initialized.
|
||||
*/
|
||||
//@{
|
||||
/*
|
||||
template <typename Graph, typename Map>
|
||||
void initialize(Graph const&, Map&, typename Map::value_type)
|
||||
{ throw 0; }
|
||||
*/
|
||||
|
||||
template <typename Graph, typename Label>
|
||||
void initialize(Graph const& g, optional_vertex_label<Graph, Label>& map, Label const& x)
|
||||
{ detail::optional_init(g, map, x); }
|
||||
|
||||
template <typename Graph, typename Label>
|
||||
void initialize(Graph const g, optional_edge_label<Graph, Label>& map, Label const& x)
|
||||
{ detail::optional_init(g, map, x); }
|
||||
//@}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user