http://www.ousob.com --- Legacy Redefined OuSob - File: /wwwroot/clipx/usr/include/boost/graph/properties.hpp

//======================================================================= // Copyright 1997, 1998, 1999, 2000 University of Notre Dame. // Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek // // 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_PROPERTIES_HPP #define BOOST_GRAPH_PROPERTIES_HPP #include <boost/config.hpp> #include <cassert> #include <boost/pending/property.hpp> #include <boost/property_map.hpp> #include <boost/graph/graph_traits.hpp> #include <boost/type_traits/is_convertible.hpp> namespace boost { enum default_color_type { white_color, gray_color, green_color, red_color, black_color }; template <class ColorValue> struct color_traits { static default_color_type white() { return white_color; } static default_color_type gray() { return gray_color; } static default_color_type green() { return green_color; } static default_color_type red() { return red_color; } static default_color_type black() { return black_color; } }; // These functions are now obsolete, replaced by color_traits. inline default_color_type white(default_color_type) { return white_color; } inline default_color_type gray(default_color_type) { return gray_color; } inline default_color_type green(default_color_type) { return green_color; } inline default_color_type red(default_color_type) { return red_color; } inline default_color_type black(default_color_type) { return black_color; } #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template <> struct property_traits<default_color_type*> { typedef default_color_type value_type; typedef std::ptrdiff_t key_type; typedef default_color_type& reference; typedef lvalue_property_map_tag category; }; // get/put already defined for T* #endif struct graph_property_tag { }; struct vertex_property_tag { }; struct edge_property_tag { }; #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // See examples/edge_property.cpp for how to use this. #define BOOST_INSTALL_PROPERTY(KIND, NAME) \ template <> struct property_kind<KIND##_##NAME##_t> { \ typedef KIND##_property_tag type; \ } #else #define BOOST_INSTALL_PROPERTY(KIND, NAME) \ template <> struct property_kind<KIND##_##NAME##_t> { \ typedef KIND##_property_tag type; \ } #endif #define BOOST_DEF_PROPERTY(KIND, NAME) \ enum KIND##_##NAME##_t { KIND##_##NAME }; \ BOOST_INSTALL_PROPERTY(KIND, NAME) BOOST_DEF_PROPERTY(vertex, all); BOOST_DEF_PROPERTY(edge, all); BOOST_DEF_PROPERTY(graph, all); BOOST_DEF_PROPERTY(vertex, index); BOOST_DEF_PROPERTY(vertex, index1); BOOST_DEF_PROPERTY(vertex, index2); BOOST_DEF_PROPERTY(vertex, root); BOOST_DEF_PROPERTY(edge, index); BOOST_DEF_PROPERTY(edge, name); BOOST_DEF_PROPERTY(edge, weight); BOOST_DEF_PROPERTY(edge, weight2); BOOST_DEF_PROPERTY(edge, color); BOOST_DEF_PROPERTY(vertex, name); BOOST_DEF_PROPERTY(graph, name); BOOST_DEF_PROPERTY(vertex, distance); BOOST_DEF_PROPERTY(vertex, color); BOOST_DEF_PROPERTY(vertex, degree); BOOST_DEF_PROPERTY(vertex, in_degree); BOOST_DEF_PROPERTY(vertex, out_degree); BOOST_DEF_PROPERTY(vertex, current_degree); BOOST_DEF_PROPERTY(vertex, priority); BOOST_DEF_PROPERTY(vertex, discover_time); BOOST_DEF_PROPERTY(vertex, finish_time); BOOST_DEF_PROPERTY(vertex, predecessor); BOOST_DEF_PROPERTY(vertex, rank); BOOST_DEF_PROPERTY(vertex, centrality); BOOST_DEF_PROPERTY(edge, reverse); BOOST_DEF_PROPERTY(edge, capacity); BOOST_DEF_PROPERTY(edge, residual_capacity); BOOST_DEF_PROPERTY(edge, centrality); BOOST_DEF_PROPERTY(graph, visitor); // These tags are used for property bundles BOOST_DEF_PROPERTY(vertex, bundle); BOOST_DEF_PROPERTY(edge, bundle); #undef BOOST_DEF_PROPERTY namespace detail { struct dummy_edge_property_selector { template <class Graph, class Property, class Tag> struct bind_ { typedef identity_property_map type; typedef identity_property_map const_type; }; }; struct dummy_vertex_property_selector { template <class Graph, class Property, class Tag> struct bind_ { typedef identity_property_map type; typedef identity_property_map const_type; }; }; } // namespace detail // Graph classes can either partially specialize property_map // or they can specialize these two selector classes. template <class GraphTag> struct edge_property_selector { typedef detail::dummy_edge_property_selector type; }; template <class GraphTag> struct vertex_property_selector { typedef detail::dummy_vertex_property_selector type; }; namespace detail { template <class Graph, class PropertyTag> struct edge_property_map { typedef typename Graph::edge_property_type Property; typedef typename Graph::graph_tag graph_tag; typedef typename edge_property_selector<graph_tag>::type Selector; typedef typename Selector::template bind_<Graph,Property,PropertyTag> Bind; typedef typename Bind::type type; typedef typename Bind::const_type const_type; }; template <class Graph, class PropertyTag> class vertex_property_map { typedef typename Graph::vertex_property_type Property; typedef typename Graph::graph_tag graph_tag; typedef typename vertex_property_selector<graph_tag>::type Selector; typedef typename Selector::template bind_<Graph,Property,PropertyTag> Bind; public: typedef typename Bind::type type; typedef typename Bind::const_type const_type; }; // This selects the kind of property map, whether is maps from // edges or from vertices. // // It is overly complicated because it's a workaround for // partial specialization. struct choose_vertex_property_map { template <class Graph, class Property> struct bind_ { typedef vertex_property_map<Graph, Property> type; }; }; struct choose_edge_property_map { template <class Graph, class Property> struct bind_ { typedef edge_property_map<Graph, Property> type; }; }; template <class Kind> struct property_map_kind_selector { // VC++ gets confused if this isn't defined, even though // this never gets used. typedef choose_vertex_property_map type; }; template <> struct property_map_kind_selector<vertex_property_tag> { typedef choose_vertex_property_map type; }; template <> struct property_map_kind_selector<edge_property_tag> { typedef choose_edge_property_map type; }; } // namespace detail template <class Graph, class Property> struct property_map { private: typedef typename property_kind<Property>::type Kind; typedef typename detail::property_map_kind_selector<Kind>::type Selector; typedef typename Selector::template bind_<Graph, Property> Bind; typedef typename Bind::type Map; public: typedef typename Map::type type; typedef typename Map::const_type const_type; }; // shortcut for accessing the value type of the property map template <class Graph, class Property> class property_map_value { typedef typename property_map<Graph, Property>::const_type PMap; public: typedef typename property_traits<PMap>::value_type type; }; template <class Graph, class Property> class graph_property { public: typedef typename property_value<typename Graph::graph_property_type, Property>::type type; }; template <class Graph> class vertex_property { public: typedef typename Graph::vertex_property_type type; }; template <class Graph> class edge_property { public: typedef typename Graph::edge_property_type type; }; template <typename Graph> class degree_property_map : public put_get_helper<typename graph_traits<Graph>::degree_size_type, degree_property_map<Graph> > { public: typedef typename graph_traits<Graph>::vertex_descriptor key_type; typedef typename graph_traits<Graph>::degree_size_type value_type; typedef value_type reference; typedef readable_property_map_tag category; degree_property_map(const Graph& g) : m_g(g) { } value_type operator[](const key_type& v) const { return degree(v, m_g); } private: const Graph& m_g; }; template <typename Graph> inline degree_property_map<Graph> make_degree_map(const Graph& g) { return degree_property_map<Graph>(g); } //======================================================================== // Iterator Property Map Generating Functions contributed by // Kevin Vanhorn. (see also the property map generating functions // in boost/property_map.hpp) #if !defined(BOOST_NO_STD_ITERATOR_TRAITS) // A helper function for creating a vertex property map out of a // random access iterator and the internal vertex index map from a // graph. template <class PropertyGraph, class RandomAccessIterator> inline iterator_property_map< RandomAccessIterator, typename property_map<PropertyGraph, vertex_index_t>::type, typename std::iterator_traits<RandomAccessIterator>::value_type, typename std::iterator_traits<RandomAccessIterator>::reference > make_iterator_vertex_map(RandomAccessIterator iter, const PropertyGraph& g) { return make_iterator_property_map(iter, get(vertex_index, g)); } // Use this next function when vertex_descriptor is known to be an // integer type, with values ranging from 0 to num_vertices(g). // template <class RandomAccessIterator> inline iterator_property_map< RandomAccessIterator, identity_property_map, typename std::iterator_traits<RandomAccessIterator>::value_type, typename std::iterator_traits<RandomAccessIterator>::reference > make_iterator_vertex_map(RandomAccessIterator iter) { return make_iterator_property_map(iter, identity_property_map()); } #endif template <class PropertyGraph, class RandomAccessContainer> inline iterator_property_map< typename RandomAccessContainer::iterator, typename property_map<PropertyGraph, vertex_index_t>::type, typename RandomAccessContainer::value_type, typename RandomAccessContainer::reference > make_container_vertex_map(RandomAccessContainer& c, const PropertyGraph& g) { assert(c.size() >= num_vertices(g)); return make_iterator_vertex_map(c.begin(), g); } template <class RandomAccessContainer> inline iterator_property_map< typename RandomAccessContainer::iterator, identity_property_map, typename RandomAccessContainer::value_type, typename RandomAccessContainer::reference > make_container_vertex_map(RandomAccessContainer& c) { return make_iterator_vertex_map(c.begin()); } #if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # define BOOST_GRAPH_NO_BUNDLED_PROPERTIES #endif #ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES template<typename Graph, typename Descriptor, typename Bundle, typename T> struct bundle_property_map : put_get_helper<T&, bundle_property_map<Graph, Descriptor, Bundle, T> > { typedef Descriptor key_type; typedef T value_type; typedef T& reference; typedef lvalue_property_map_tag category; bundle_property_map(Graph* g_, T Bundle::* pm_) : g(g_), pm(pm_) {} reference operator[](key_type k) const { return (*g)[k].*pm; } private: Graph* g; T Bundle::* pm; }; namespace detail { template<typename VertexBundle, typename EdgeBundle, typename Bundle> struct is_vertex_bundle : is_convertible<Bundle*, VertexBundle*> {}; } template <typename Graph, typename T, typename Bundle> struct property_map<Graph, T Bundle::*> { private: typedef graph_traits<Graph> traits; typedef typename Graph::vertex_bundled vertex_bundled; typedef typename Graph::edge_bundled edge_bundled; typedef typename ct_if<(detail::is_vertex_bundle<vertex_bundled, edge_bundled, Bundle>::value), typename traits::vertex_descriptor, typename traits::edge_descriptor>::type descriptor; public: typedef bundle_property_map<Graph, descriptor, Bundle, T> type; typedef bundle_property_map<const Graph, descriptor, Bundle, const T> const_type; }; #endif } // namespace boost #endif /* BOOST_GRAPH_PROPERTIES_HPPA */