FM / detail

/usr/include/boost/graph/detail

Name	Size	Mode	Actions
adjacency_list.hpp	106090	0644	edit dl rm
adj_list_edge_iterator.hpp	3987	0644	edit dl rm
array_binary_tree.hpp	7015	0644	edit dl rm
augment.hpp	2293	0644	edit dl rm
compressed_sparse_row_struct.hpp	30100	0644	edit dl rm
connected_components.hpp	6716	0644	edit dl rm
d_ary_heap.hpp	12255	0644	edit dl rm
edge.hpp	3550	0644	edit dl rm
empty_header.hpp	383	0644	edit dl rm
geodesic.hpp	4825	0644	edit dl rm
histogram_sort.hpp	13020	0644	edit dl rm
incidence_iterator.hpp	2681	0644	edit dl rm
incremental_components.hpp	3187	0644	edit dl rm
index.hpp	2623	0644	edit dl rm
indexed_properties.hpp	9420	0644	edit dl rm
is_distributed_selector.hpp	855	0644	edit dl rm
labeled_graph_traits.hpp	6618	0644	edit dl rm
list_base.hpp	5614	0644	edit dl rm
mpi_include.hpp	536	0644	edit dl rm
permutation.hpp	6020	0644	edit dl rm
read_graphviz_new.hpp	3555	0644	edit dl rm
read_graphviz_spirit.hpp	28019	0644	edit dl rm
self_avoiding_walk.hpp	15856	0644	edit dl rm
set_adaptor.hpp	3092	0644	edit dl rm
shadow_iterator.hpp	5497	0644	edit dl rm
sparse_ordering.hpp	6345	0644	edit dl rm

Edit: /usr/include/boost/graph/detail/adj_list_edge_iterator.hpp (3987B)

#include <iterator>
#include <utility>
#include <boost/detail/workaround.hpp>

#if BOOST_WORKAROUND(__IBMCPP__, <= 600)
#define BOOST_GRAPH_NO_OPTIONAL
#endif

#ifdef BOOST_GRAPH_NO_OPTIONAL
#define BOOST_GRAPH_MEMBER .
#else
#define BOOST_GRAPH_MEMBER ->
#include <boost/optional.hpp>
#endif // ndef BOOST_GRAPH_NO_OPTIONAL

namespace boost
{

namespace detail
{

template < class VertexIterator, class OutEdgeIterator, class Graph >
    class adj_list_edge_iterator
    {
        typedef adj_list_edge_iterator self;

public:
        typedef std::forward_iterator_tag iterator_category;
        typedef typename OutEdgeIterator::value_type value_type;
        typedef typename OutEdgeIterator::reference reference;
        typedef typename OutEdgeIterator::pointer pointer;
        typedef typename OutEdgeIterator::difference_type difference_type;
        typedef difference_type distance_type;

inline adj_list_edge_iterator() {}

inline adj_list_edge_iterator(const self& x)
        : vBegin(x.vBegin)
        , vCurr(x.vCurr)
        , vEnd(x.vEnd)
        , edges(x.edges)
        , m_g(x.m_g)
        {
        }

template < class G >
        inline adj_list_edge_iterator(
            VertexIterator b, VertexIterator c, VertexIterator e, const G& g)
        : vBegin(b), vCurr(c), vEnd(e), m_g(&g)
        {
            if (vCurr != vEnd)
            {
                while (vCurr != vEnd && out_degree(*vCurr, *m_g) == 0)
                    ++vCurr;
                if (vCurr != vEnd)
                    edges = out_edges(*vCurr, *m_g);
            }
        }

/*Note:
          In the directed graph cases, it is fine.
          For undirected graphs, one edge go through twice.
        */
        inline self& operator++()
        {
            ++edges BOOST_GRAPH_MEMBER first;
            if (edges BOOST_GRAPH_MEMBER first
                == edges BOOST_GRAPH_MEMBER second)
            {
                ++vCurr;
                while (vCurr != vEnd && out_degree(*vCurr, *m_g) == 0)
                    ++vCurr;
                if (vCurr != vEnd)
                    edges = out_edges(*vCurr, *m_g);
            }
            return *this;
        }
        inline self operator++(int)
        {
            self tmp = *this;
            ++(*this);
            return tmp;
        }
        inline value_type operator*() const
        {
            return *edges BOOST_GRAPH_MEMBER first;
        }
        inline bool operator==(const self& x) const
        {
            return vCurr == x.vCurr
                && (vCurr == vEnd
                    || edges BOOST_GRAPH_MEMBER first
                        == x.edges BOOST_GRAPH_MEMBER first);
        }
        inline bool operator!=(const self& x) const
        {
            return vCurr != x.vCurr
                || (vCurr != vEnd
                    && edges BOOST_GRAPH_MEMBER first
                        != x.edges BOOST_GRAPH_MEMBER first);
        }

protected:
        VertexIterator vBegin;
        VertexIterator vCurr;
        VertexIterator vEnd;

#ifdef BOOST_GRAPH_NO_OPTIONAL
        std::pair< OutEdgeIterator, OutEdgeIterator > edges;
#else
        boost::optional< std::pair< OutEdgeIterator, OutEdgeIterator > > edges;
#endif // ndef BOOST_GRAPH_NO_OPTIONAL
        const Graph* m_g;
    };

} // namespace detail

}

#undef BOOST_GRAPH_MEMBER

#endif // BOOST_GRAPH_DETAIL_ADJ_LIST_EDGE_ITERATOR_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_DETAIL_ADJ_LIST_EDGE_ITERATOR_HPP #define BOOST_GRAPH_DETAIL_ADJ_LIST_EDGE_ITERATOR_HPP #include #include #include #if BOOST_WORKAROUND(__IBMCPP__, <= 600) #define BOOST_GRAPH_NO_OPTIONAL #endif #ifdef BOOST_GRAPH_NO_OPTIONAL #define BOOST_GRAPH_MEMBER . #else #define BOOST_GRAPH_MEMBER -> #include #endif // ndef BOOST_GRAPH_NO_OPTIONAL namespace boost { namespace detail { template < class VertexIterator, class OutEdgeIterator, class Graph > class adj_list_edge_iterator { typedef adj_list_edge_iterator self; public: typedef std::forward_iterator_tag iterator_category; typedef typename OutEdgeIterator::value_type value_type; typedef typename OutEdgeIterator::reference reference; typedef typename OutEdgeIterator::pointer pointer; typedef typename OutEdgeIterator::difference_type difference_type; typedef difference_type distance_type; inline adj_list_edge_iterator() {} inline adj_list_edge_iterator(const self& x) : vBegin(x.vBegin) , vCurr(x.vCurr) , vEnd(x.vEnd) , edges(x.edges) , m_g(x.m_g) { } template < class G > inline adj_list_edge_iterator( VertexIterator b, VertexIterator c, VertexIterator e, const G& g) : vBegin(b), vCurr(c), vEnd(e), m_g(&g) { if (vCurr != vEnd) { while (vCurr != vEnd && out_degree(*vCurr, *m_g) == 0) ++vCurr; if (vCurr != vEnd) edges = out_edges(*vCurr, *m_g); } } /*Note: In the directed graph cases, it is fine. For undirected graphs, one edge go through twice. */ inline self& operator++() { ++edges BOOST_GRAPH_MEMBER first; if (edges BOOST_GRAPH_MEMBER first == edges BOOST_GRAPH_MEMBER second) { ++vCurr; while (vCurr != vEnd && out_degree(*vCurr, *m_g) == 0) ++vCurr; if (vCurr != vEnd) edges = out_edges(*vCurr, *m_g); } return *this; } inline self operator++(int) { self tmp = *this; ++(*this); return tmp; } inline value_type operator*() const { return *edges BOOST_GRAPH_MEMBER first; } inline bool operator==(const self& x) const { return vCurr == x.vCurr && (vCurr == vEnd || edges BOOST_GRAPH_MEMBER first == x.edges BOOST_GRAPH_MEMBER first); } inline bool operator!=(const self& x) const { return vCurr != x.vCurr || (vCurr != vEnd && edges BOOST_GRAPH_MEMBER first != x.edges BOOST_GRAPH_MEMBER first); } protected: VertexIterator vBegin; VertexIterator vCurr; VertexIterator vEnd; #ifdef BOOST_GRAPH_NO_OPTIONAL std::pair< OutEdgeIterator, OutEdgeIterator > edges; #else boost::optional< std::pair< OutEdgeIterator, OutEdgeIterator > > edges; #endif // ndef BOOST_GRAPH_NO_OPTIONAL const Graph* m_g; }; } // namespace detail } #undef BOOST_GRAPH_MEMBER #endif // BOOST_GRAPH_DETAIL_ADJ_LIST_EDGE_ITERATOR_HPP