Edit: /usr/include/boost/graph/edge_list.hpp (9948B)
//=======================================================================
// 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_EDGE_LIST_HPP
#define BOOST_GRAPH_EDGE_LIST_HPP
#include
#include
#include
#include
#include
#include
#include
namespace boost
{
//
// The edge_list class is an EdgeListGraph module that is constructed
// from a pair of iterators whose value type is a pair of vertex
// descriptors.
//
// For example:
//
// typedef std::pair E;
// list elist;
// ...
// typedef edge_list::iterator> Graph;
// Graph g(elist.begin(), elist.end());
//
// If the iterators are random access, then Graph::edge_descriptor
// is of Integral type, otherwise it is a struct, though it is
// convertible to an Integral type.
//
struct edge_list_tag
{
};
// The implementation class for edge_list.
template < class G, class EdgeIter, class T, class D > class edge_list_impl
{
public:
typedef D edge_id;
typedef T Vpair;
typedef typename Vpair::first_type V;
typedef V vertex_descriptor;
typedef edge_list_tag graph_tag;
typedef void edge_property_type;
struct edge_descriptor
{
edge_descriptor() {}
edge_descriptor(EdgeIter p, edge_id id) : _ptr(p), _id(id) {}
operator edge_id() { return _id; }
EdgeIter _ptr;
edge_id _id;
};
typedef edge_descriptor E;
struct edge_iterator
{
typedef edge_iterator self;
typedef E value_type;
typedef E& reference;
typedef E* pointer;
typedef std::ptrdiff_t difference_type;
typedef std::input_iterator_tag iterator_category;
edge_iterator() {}
edge_iterator(EdgeIter iter) : _iter(iter), _i(0) {}
E operator*() { return E(_iter, _i); }
self& operator++()
{
++_iter;
++_i;
return *this;
}
self operator++(int)
{
self t = *this;
++(*this);
return t;
}
bool operator==(const self& x) { return _iter == x._iter; }
bool operator!=(const self& x) { return _iter != x._iter; }
EdgeIter _iter;
edge_id _i;
};
typedef void out_edge_iterator;
typedef void in_edge_iterator;
typedef void adjacency_iterator;
typedef void vertex_iterator;
};
template < class G, class EI, class T, class D >
std::pair< typename edge_list_impl< G, EI, T, D >::edge_iterator,
typename edge_list_impl< G, EI, T, D >::edge_iterator >
edges(const edge_list_impl< G, EI, T, D >& g_)
{
const G& g = static_cast< const G& >(g_);
typedef typename edge_list_impl< G, EI, T, D >::edge_iterator edge_iterator;
return std::make_pair(edge_iterator(g._first), edge_iterator(g._last));
}
template < class G, class EI, class T, class D >
typename edge_list_impl< G, EI, T, D >::vertex_descriptor source(
typename edge_list_impl< G, EI, T, D >::edge_descriptor e,
const edge_list_impl< G, EI, T, D >&)
{
return (*e._ptr).first;
}
template < class G, class EI, class T, class D >
typename edge_list_impl< G, EI, T, D >::vertex_descriptor target(
typename edge_list_impl< G, EI, T, D >::edge_descriptor e,
const edge_list_impl< G, EI, T, D >&)
{
return (*e._ptr).second;
}
template < class D, class E >
class el_edge_property_map
: public put_get_helper< D, el_edge_property_map< D, E > >
{
public:
typedef E key_type;
typedef D value_type;
typedef D reference;
typedef readable_property_map_tag category;
value_type operator[](key_type e) const { return e._i; }
};
struct edge_list_edge_property_selector
{
template < class Graph, class Property, class Tag > struct bind_
{
typedef el_edge_property_map< typename Graph::edge_id,
typename Graph::edge_descriptor >
type;
typedef type const_type;
};
};
template <> struct edge_property_selector< edge_list_tag >
{
typedef edge_list_edge_property_selector type;
};
template < class G, class EI, class T, class D >
typename property_map< edge_list_impl< G, EI, T, D >, edge_index_t >::type get(
edge_index_t, const edge_list_impl< G, EI, T, D >&)
{
typedef typename property_map< edge_list_impl< G, EI, T, D >,
edge_index_t >::type EdgeIndexMap;
return EdgeIndexMap();
}
template < class G, class EI, class T, class D >
inline D get(edge_index_t, const edge_list_impl< G, EI, T, D >&,
typename edge_list_impl< G, EI, T, D >::edge_descriptor e)
{
return e._i;
}
// A specialized implementation for when the iterators are random access.
struct edge_list_ra_tag
{
};
template < class G, class EdgeIter, class T, class D > class edge_list_impl_ra
{
public:
typedef D edge_id;
typedef T Vpair;
typedef typename Vpair::first_type V;
typedef edge_list_ra_tag graph_tag;
typedef void edge_property_type;
typedef edge_id edge_descriptor;
typedef V vertex_descriptor;
typedef typename boost::integer_range< edge_id >::iterator edge_iterator;
typedef void out_edge_iterator;
typedef void in_edge_iterator;
typedef void adjacency_iterator;
typedef void vertex_iterator;
};
template < class G, class EI, class T, class D >
std::pair< typename edge_list_impl_ra< G, EI, T, D >::edge_iterator,
typename edge_list_impl_ra< G, EI, T, D >::edge_iterator >
edges(const edge_list_impl_ra< G, EI, T, D >& g_)
{
const G& g = static_cast< const G& >(g_);
typedef
typename edge_list_impl_ra< G, EI, T, D >::edge_iterator edge_iterator;
return std::make_pair(edge_iterator(0), edge_iterator(g._last - g._first));
}
template < class G, class EI, class T, class D >
typename edge_list_impl_ra< G, EI, T, D >::vertex_descriptor source(
typename edge_list_impl_ra< G, EI, T, D >::edge_descriptor e,
const edge_list_impl_ra< G, EI, T, D >& g_)
{
const G& g = static_cast< const G& >(g_);
return g._first[e].first;
}
template < class G, class EI, class T, class D >
typename edge_list_impl_ra< G, EI, T, D >::vertex_descriptor target(
typename edge_list_impl_ra< G, EI, T, D >::edge_descriptor e,
const edge_list_impl_ra< G, EI, T, D >& g_)
{
const G& g = static_cast< const G& >(g_);
return g._first[e].second;
}
template < class E >
class el_ra_edge_property_map
: public put_get_helper< E, el_ra_edge_property_map< E > >
{
public:
typedef E key_type;
typedef E value_type;
typedef E reference;
typedef readable_property_map_tag category;
value_type operator[](key_type e) const { return e; }
};
struct edge_list_ra_edge_property_selector
{
template < class Graph, class Property, class Tag > struct bind_
{
typedef el_ra_edge_property_map< typename Graph::edge_descriptor > type;
typedef type const_type;
};
};
template <> struct edge_property_selector< edge_list_ra_tag >
{
typedef edge_list_ra_edge_property_selector type;
};
template < class G, class EI, class T, class D >
inline typename property_map< edge_list_impl_ra< G, EI, T, D >,
edge_index_t >::type
get(edge_index_t, const edge_list_impl_ra< G, EI, T, D >&)
{
typedef typename property_map< edge_list_impl_ra< G, EI, T, D >,
edge_index_t >::type EdgeIndexMap;
return EdgeIndexMap();
}
template < class G, class EI, class T, class D >
inline D get(edge_index_t, const edge_list_impl_ra< G, EI, T, D >&,
typename edge_list_impl_ra< G, EI, T, D >::edge_descriptor e)
{
return e;
}
// Some helper classes for determining if the iterators are random access
template < class Cat > struct is_random
{
enum
{
RET = false
};
typedef mpl::false_ type;
};
template <> struct is_random< std::random_access_iterator_tag >
{
enum
{
RET = true
};
typedef mpl::true_ type;
};
// The edge_list class conditionally inherits from one of the
// above two classes.
template < class EdgeIter,
#if !defined BOOST_NO_STD_ITERATOR_TRAITS
class T = typename std::iterator_traits< EdgeIter >::value_type,
class D = typename std::iterator_traits< EdgeIter >::difference_type,
class Cat = typename std::iterator_traits< EdgeIter >::iterator_category >
#else
class T, class D, class Cat >
#endif
class edge_list
: public mpl::if_< typename is_random< Cat >::type,
edge_list_impl_ra< edge_list< EdgeIter, T, D, Cat >, EdgeIter, T, D >,
edge_list_impl< edge_list< EdgeIter, T, D, Cat >, EdgeIter, T, D > >::type
{
public:
typedef directed_tag directed_category;
typedef allow_parallel_edge_tag edge_parallel_category;
typedef edge_list_graph_tag traversal_category;
typedef std::size_t edges_size_type;
typedef std::size_t vertices_size_type;
typedef std::size_t degree_size_type;
edge_list(EdgeIter first, EdgeIter last) : _first(first), _last(last)
{
m_num_edges = std::distance(first, last);
}
edge_list(EdgeIter first, EdgeIter last, edges_size_type E)
: _first(first), _last(last), m_num_edges(E)
{
}
EdgeIter _first, _last;
edges_size_type m_num_edges;
};
template < class EdgeIter, class T, class D, class Cat >
std::size_t num_edges(const edge_list< EdgeIter, T, D, Cat >& el)
{
return el.m_num_edges;
}
#ifndef BOOST_NO_STD_ITERATOR_TRAITS
template < class EdgeIter >
inline edge_list< EdgeIter > make_edge_list(EdgeIter first, EdgeIter last)
{
return edge_list< EdgeIter >(first, last);
}
#endif
} /* namespace boost */
#endif /* BOOST_GRAPH_EDGE_LIST_HPP */