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/edge.hpp (3550B)

#ifndef BOOST_GRAPH_DETAIL_EDGE_HPP
#define BOOST_GRAPH_DETAIL_EDGE_HPP

#include <iosfwd>

#include <boost/functional/hash.hpp>

namespace boost
{

namespace detail
{

template < typename Directed, typename Vertex > struct edge_base
    {
        inline edge_base() {}
        inline edge_base(Vertex s, Vertex d) : m_source(s), m_target(d) {}
        Vertex m_source;
        Vertex m_target;
    };

template < typename Directed, typename Vertex >
    class edge_desc_impl : public edge_base< Directed, Vertex >
    {
        typedef edge_desc_impl self;
        typedef edge_base< Directed, Vertex > Base;

public:
        typedef void property_type;

inline edge_desc_impl() : m_eproperty(0) {}

inline edge_desc_impl(Vertex s, Vertex d, const property_type* eplug)
        : Base(s, d), m_eproperty(const_cast< property_type* >(eplug))
        {
        }

property_type* get_property() { return m_eproperty; }
        const property_type* get_property() const { return m_eproperty; }

//  protected:
        property_type* m_eproperty;
    };

template < class D, class V >
    inline bool operator==(const detail::edge_desc_impl< D, V >& a,
        const detail::edge_desc_impl< D, V >& b)
    {
        return a.get_property() == b.get_property();
    }
    template < class D, class V >
    inline bool operator!=(const detail::edge_desc_impl< D, V >& a,
        const detail::edge_desc_impl< D, V >& b)
    {
        return !(a.get_property() == b.get_property());
    }

// Order edges according to the address of their property object
    template < class D, class V >
    inline bool operator<(const detail::edge_desc_impl< D, V >& a,
        const detail::edge_desc_impl< D, V >& b)
    {
        return a.get_property() < b.get_property();
    }
    template < class D, class V >
    inline bool operator<=(const detail::edge_desc_impl< D, V >& a,
        const detail::edge_desc_impl< D, V >& b)
    {
        return a.get_property() <= b.get_property();
    }
    template < class D, class V >
    inline bool operator>(const detail::edge_desc_impl< D, V >& a,
        const detail::edge_desc_impl< D, V >& b)
    {
        return a.get_property() > b.get_property();
    }
    template < class D, class V >
    inline bool operator>=(const detail::edge_desc_impl< D, V >& a,
        const detail::edge_desc_impl< D, V >& b)
    {
        return a.get_property() >= b.get_property();
    }

} // namespace detail

} // namespace boost

namespace std
{
template < class Char, class Traits, class D, class V >
std::basic_ostream< Char, Traits >& operator<<(
    std::basic_ostream< Char, Traits >& os,
    const boost::detail::edge_desc_impl< D, V >& e)
{
    return os << "(" << e.m_source << "," << e.m_target << ")";
}
}

// Boost's functional/hash
namespace boost
{
template < typename D, typename V >
struct hash< boost::detail::edge_desc_impl< D, V > >
{
    std::size_t operator()(const boost::detail::edge_desc_impl< D, V >& x) const
    {
        return hash_value(x.get_property());
    }
};
}

#endif // BOOST_GRAPH_DETAIL_DETAIL_EDGE_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_EDGE_HPP #define BOOST_GRAPH_DETAIL_EDGE_HPP #include #include namespace boost { namespace detail { template < typename Directed, typename Vertex > struct edge_base { inline edge_base() {} inline edge_base(Vertex s, Vertex d) : m_source(s), m_target(d) {} Vertex m_source; Vertex m_target; }; template < typename Directed, typename Vertex > class edge_desc_impl : public edge_base< Directed, Vertex > { typedef edge_desc_impl self; typedef edge_base< Directed, Vertex > Base; public: typedef void property_type; inline edge_desc_impl() : m_eproperty(0) {} inline edge_desc_impl(Vertex s, Vertex d, const property_type* eplug) : Base(s, d), m_eproperty(const_cast< property_type* >(eplug)) { } property_type* get_property() { return m_eproperty; } const property_type* get_property() const { return m_eproperty; } // protected: property_type* m_eproperty; }; template < class D, class V > inline bool operator==(const detail::edge_desc_impl< D, V >& a, const detail::edge_desc_impl< D, V >& b) { return a.get_property() == b.get_property(); } template < class D, class V > inline bool operator!=(const detail::edge_desc_impl< D, V >& a, const detail::edge_desc_impl< D, V >& b) { return !(a.get_property() == b.get_property()); } // Order edges according to the address of their property object template < class D, class V > inline bool operator<(const detail::edge_desc_impl< D, V >& a, const detail::edge_desc_impl< D, V >& b) { return a.get_property() < b.get_property(); } template < class D, class V > inline bool operator<=(const detail::edge_desc_impl< D, V >& a, const detail::edge_desc_impl< D, V >& b) { return a.get_property() <= b.get_property(); } template < class D, class V > inline bool operator>(const detail::edge_desc_impl< D, V >& a, const detail::edge_desc_impl< D, V >& b) { return a.get_property() > b.get_property(); } template < class D, class V > inline bool operator>=(const detail::edge_desc_impl< D, V >& a, const detail::edge_desc_impl< D, V >& b) { return a.get_property() >= b.get_property(); } } // namespace detail } // namespace boost namespace std { template < class Char, class Traits, class D, class V > std::basic_ostream< Char, Traits >& operator<<( std::basic_ostream< Char, Traits >& os, const boost::detail::edge_desc_impl< D, V >& e) { return os << "(" << e.m_source << "," << e.m_target << ")"; } } // Boost's functional/hash namespace boost { template < typename D, typename V > struct hash< boost::detail::edge_desc_impl< D, V > > { std::size_t operator()(const boost::detail::edge_desc_impl< D, V >& x) const { return hash_value(x.get_property()); } }; } #endif // BOOST_GRAPH_DETAIL_DETAIL_EDGE_HPP