x
Yes
No
Do you want to visit DriveHQ English website?
首页
产品服务
价格
免费试用
下载客户端
关于我们
云文件服务
|
云备份服务
|
FTP服务
|
企业邮箱服务
|
网站托管
|
客户端软件
云文件服务
云备份服务
FTP服务
企业级邮箱服务
网站托管
客户端软件
adjacency_list.hpp - Hosted on DriveHQ Cloud IT Platform
返回上层目录
上传
下载
共享
发布
新建文件夹
新建文件
复制
剪切
删除
粘贴
评论
升级服务
路径: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\graph\adjacency_list.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_ADJACENCY_LIST_HPP #define BOOST_GRAPH_ADJACENCY_LIST_HPP #include
#include
#include
#include
#if !defined BOOST_NO_HASH # ifdef BOOST_HASH_SET_HEADER # include BOOST_HASH_SET_HEADER # else # include
# endif #endif #if !defined BOOST_NO_SLIST # ifdef BOOST_SLIST_HEADER # include BOOST_SLIST_HEADER # else # include
# endif #endif #include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
namespace boost { //=========================================================================== // Selectors for the VertexList and EdgeList template parameters of // adjacency_list, and the container_gen traits class which is used // to map the selectors to the container type used to implement the // graph. // // The main container_gen traits class uses partial specialization, // so we also include a workaround. #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #if !defined BOOST_NO_SLIST struct slistS {}; #endif struct vecS { }; struct listS { }; struct setS { }; struct multisetS { }; struct mapS { }; #if !defined BOOST_NO_HASH struct hash_mapS { }; struct hash_setS { }; #endif template
struct container_gen { }; template
struct container_gen
{ typedef std::list
type; }; #if !defined BOOST_NO_SLIST template
struct container_gen
{ typedef BOOST_STD_EXTENSION_NAMESPACE::slist
type; }; #endif template
struct container_gen
{ typedef std::vector
type; }; template
struct container_gen
{ typedef std::set
type; }; template
struct container_gen
{ typedef std::set
type; }; template
struct container_gen
{ typedef std::multiset
type; }; #if !defined BOOST_NO_HASH template
struct container_gen
{ typedef BOOST_STD_EXTENSION_NAMESPACE::hash_set
type; }; template
struct container_gen
{ typedef BOOST_STD_EXTENSION_NAMESPACE::hash_set
type; }; #endif #else // !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #if !defined BOOST_NO_SLIST struct slistS { template
struct bind_ { typedef BOOST_STD_EXTENSION_NAMESPACE::slist
type; }; }; #endif struct vecS { template
struct bind_ { typedef std::vector
type; }; }; struct listS { template
struct bind_ { typedef std::list
type; }; }; struct setS { template
struct bind_ { typedef std::set
> type; }; }; struct multisetS { template
struct bind_ { typedef std::multiset
> type; }; }; #if !defined BOOST_NO_HASH struct hash_setS { template
struct bind_ { typedef BOOST_STD_EXTENSION_NAMESPACE::hash_set
> type; }; }; #endif struct mapS { template
struct bind_ { typedef std::set
> type; }; }; #if !defined BOOST_NO_HASH struct hash_mapS { template
struct bind_ { typedef BOOST_STD_EXTENSION_NAMESPACE::hash_set
> type; }; }; #endif template
struct container_selector { typedef vecS type; }; #define BOOST_CONTAINER_SELECTOR(NAME) \ template <> struct container_selector
{ \ typedef NAME type; \ } BOOST_CONTAINER_SELECTOR(vecS); BOOST_CONTAINER_SELECTOR(listS); BOOST_CONTAINER_SELECTOR(mapS); BOOST_CONTAINER_SELECTOR(setS); BOOST_CONTAINER_SELECTOR(multisetS); #if !defined BOOST_NO_HASH BOOST_CONTAINER_SELECTOR(hash_mapS); #endif #if !defined BOOST_NO_SLIST BOOST_CONTAINER_SELECTOR(slistS); #endif template
struct container_gen { typedef typename container_selector
::type Select; typedef typename Select:: template bind_
::type type; }; #endif // !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template
struct parallel_edge_traits { }; template <> struct parallel_edge_traits
{ typedef allow_parallel_edge_tag type; }; template <> struct parallel_edge_traits
{ typedef allow_parallel_edge_tag type; }; #if !defined BOOST_NO_SLIST template <> struct parallel_edge_traits
{ typedef allow_parallel_edge_tag type; }; #endif template <> struct parallel_edge_traits
{ typedef disallow_parallel_edge_tag type; }; template <> struct parallel_edge_traits
{ typedef allow_parallel_edge_tag type; }; #if !defined BOOST_NO_HASH template <> struct parallel_edge_traits
{ typedef disallow_parallel_edge_tag type; }; #endif // mapS is obsolete, replaced with setS template <> struct parallel_edge_traits
{ typedef disallow_parallel_edge_tag type; }; #if !defined BOOST_NO_HASH template <> struct parallel_edge_traits
{ typedef disallow_parallel_edge_tag type; }; #endif namespace detail { template
struct is_random_access { enum { value = false}; typedef mpl::false_ type; }; template <> struct is_random_access
{ enum { value = true }; typedef mpl::true_ type; }; } // namespace detail //=========================================================================== // The adjacency_list_traits class, which provides a way to access // some of the associated types of an adjacency_list type without // having to first create the adjacency_list type. This is useful // when trying to create interior vertex or edge properties who's // value type is a vertex or edge descriptor. template
struct adjacency_list_traits { typedef typename detail::is_random_access
::type is_rand_access; typedef typename DirectedS::is_bidir_t is_bidir; typedef typename DirectedS::is_directed_t is_directed; typedef typename mpl::if_
::type >::type directed_category; typedef typename parallel_edge_traits
::type edge_parallel_category; typedef void* vertex_ptr; typedef typename mpl::if_
::type vertex_descriptor; typedef detail::edge_desc_impl
edge_descriptor; typedef std::size_t vertices_size_type; private: // Logic to figure out the edges_size_type struct dummy {}; typedef typename container_gen
::type EdgeContainer; typedef typename DirectedS::is_bidir_t BidirectionalT; typedef typename DirectedS::is_directed_t DirectedT; typedef typename mpl::and_
::type >::type on_edge_storage; public: typedef typename mpl::if_
::type edges_size_type; }; } // namespace boost #include
namespace boost { //=========================================================================== // The adjacency_list class. // template
class adjacency_list : public detail::adj_list_gen< adjacency_list
, VertexListS, OutEdgeListS, DirectedS, #if !defined(BOOST_GRAPH_NO_BUNDLED_PROPERTIES) typename detail::retag_property_list
::type, typename detail::retag_property_list
::type, #else VertexProperty, EdgeProperty, #endif GraphProperty, EdgeListS>::type { #if !defined(BOOST_GRAPH_NO_BUNDLED_PROPERTIES) typedef typename detail::retag_property_list
::retagged maybe_vertex_bundled; typedef typename detail::retag_property_list
::retagged maybe_edge_bundled; #endif public: #if !defined(BOOST_GRAPH_NO_BUNDLED_PROPERTIES) typedef typename detail::retag_property_list
::type vertex_property_type; typedef typename detail::retag_property_list
::type edge_property_type; // The types that are actually bundled typedef typename mpl::if_c<(is_same
::value), no_vertex_bundle, maybe_vertex_bundled>::type vertex_bundled; typedef typename mpl::if_c<(is_same
::value), no_edge_bundle, maybe_edge_bundled>::type edge_bundled; #else typedef VertexProperty vertex_property_type; typedef EdgeProperty edge_property_type; typedef no_vertex_bundle vertex_bundled; typedef no_edge_bundle edge_bundled; #endif private: typedef adjacency_list self; typedef typename detail::adj_list_gen< self, VertexListS, OutEdgeListS, DirectedS, vertex_property_type, edge_property_type, GraphProperty, EdgeListS >::type Base; public: typedef typename Base::stored_vertex stored_vertex; typedef typename Base::vertices_size_type vertices_size_type; typedef typename Base::edges_size_type edges_size_type; typedef typename Base::degree_size_type degree_size_type; typedef typename Base::vertex_descriptor vertex_descriptor; typedef typename Base::edge_descriptor edge_descriptor; typedef OutEdgeListS out_edge_list_selector; typedef VertexListS vertex_list_selector; typedef DirectedS directed_selector; typedef EdgeListS edge_list_selector; typedef GraphProperty graph_property_type; inline adjacency_list(const GraphProperty& p = GraphProperty()) : m_property(p) { } inline adjacency_list(const adjacency_list& x) : Base(x), m_property(x.m_property) { } inline adjacency_list& operator=(const adjacency_list& x) { // TBD: probably should give the strong guarantee if (&x != this) { Base::operator=(x); m_property = x.m_property; } return *this; } // Required by Mutable Graph inline adjacency_list(vertices_size_type num_vertices, const GraphProperty& p = GraphProperty()) : Base(num_vertices), m_property(p) { } #if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300 // Required by Iterator Constructible Graph template
inline adjacency_list(EdgeIterator first, EdgeIterator last, vertices_size_type n, edges_size_type = 0, const GraphProperty& p = GraphProperty()) : Base(n, first, last), m_property(p) { } template
inline adjacency_list(EdgeIterator first, EdgeIterator last, EdgePropertyIterator ep_iter, vertices_size_type n, edges_size_type = 0, const GraphProperty& p = GraphProperty()) : Base(n, first, last, ep_iter), m_property(p) { } #endif void swap(adjacency_list& x) { // Is there a more efficient way to do this? adjacency_list tmp(x); x = *this; *this = tmp; } #ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES // Directly access a vertex or edge bundle vertex_bundled& operator[](vertex_descriptor v) { return get(vertex_bundle, *this)[v]; } const vertex_bundled& operator[](vertex_descriptor v) const { return get(vertex_bundle, *this)[v]; } edge_bundled& operator[](edge_descriptor e) { return get(edge_bundle, *this)[e]; } const edge_bundled& operator[](edge_descriptor e) const { return get(edge_bundle, *this)[e]; } #endif // protected: (would be protected if friends were more portable) GraphProperty m_property; }; template
inline void set_property(adjacency_list
& g, Tag, const Value& value) { get_property_value(g.m_property, Tag()) = value;; } template
inline typename graph_property
, Tag>::type& get_property(adjacency_list
& g, Tag) { return get_property_value(g.m_property, Tag()); } template
inline const typename graph_property
, Tag>::type& get_property(const adjacency_list
& g, Tag) { return get_property_value(g.m_property, Tag()); } // dwa 09/25/00 - needed to be more explicit so reverse_graph would work. template
inline Vertex source(const detail::edge_base
& e, const adjacency_list
&) { return e.m_source; } template
inline Vertex target(const detail::edge_base
& e, const adjacency_list
&) { return e.m_target; } // Support for bundled properties #ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES template
inline typename property_map
, T Bundle::*>::type get(T Bundle::* p, adjacency_list
& g) { typedef typename property_map
, T Bundle::*>::type result_type; return result_type(&g, p); } template
inline typename property_map
, T Bundle::*>::const_type get(T Bundle::* p, adjacency_list
const & g) { typedef typename property_map
, T Bundle::*>::const_type result_type; return result_type(&g, p); } template
inline T get(T Bundle::* p, adjacency_list
const & g, const Key& key) { return get(get(p, g), key); } template
inline void put(T Bundle::* p, adjacency_list
& g, const Key& key, const T& value) { put(get(p, g), key, value); } #endif } // namespace boost #endif // BOOST_GRAPH_ADJACENCY_LIST_HPP
adjacency_list.hpp
网页地址
文件地址
上一页
3/95
下一页
下载
( 18 KB )
Comments
Total ratings:
0
Average rating:
无评论
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.