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/indexed_properties.hpp (9420B)

// 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)

//  Authors: Jeremiah Willcock
//           Douglas Gregor
//           Andrew Lumsdaine

// Indexed properties -- used for CSR and CSR-like graphs

#ifndef BOOST_GRAPH_INDEXED_PROPERTIES_HPP
#define BOOST_GRAPH_INDEXED_PROPERTIES_HPP

#include <vector>
#include <utility>
#include <algorithm>
#include <climits>
#include <iterator>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/properties.hpp>
#include <boost/iterator/counting_iterator.hpp>
#include <boost/integer.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/property_map/property_map.hpp>
#include <boost/mpl/if.hpp>

namespace boost
{
namespace detail
{

template < typename Derived, typename Property, typename Descriptor,
        typename IndexMap >
    class indexed_vertex_properties
    {
    public:
        typedef no_property vertex_property_type;
        typedef Property vertex_bundled;
        typedef iterator_property_map<
            typename std::vector< Property >::iterator, IndexMap >
            vertex_map_type;
        typedef iterator_property_map<
            typename std::vector< Property >::const_iterator, IndexMap >
            const_vertex_map_type;

// Directly access a vertex or edge bundle
        Property& operator[](Descriptor v)
        {
            return m_vertex_properties[get(vertex_index, derived(), v)];
        }

const Property& operator[](Descriptor v) const
        {
            return m_vertex_properties[get(vertex_index, derived(), v)];
        }

vertex_map_type get_vertex_bundle(
            const IndexMap& index_map = IndexMap())
        {
            return vertex_map_type(m_vertex_properties.begin(), index_map);
        }

const_vertex_map_type get_vertex_bundle(
            const IndexMap& index_map = IndexMap()) const
        {
            return const_vertex_map_type(
                m_vertex_properties.begin(), index_map);
        }

protected:
        // Default-construct with no property values
        indexed_vertex_properties() {}

// Initialize with n default-constructed property values
        indexed_vertex_properties(std::size_t n) : m_vertex_properties(n) {}

public:
        // Clear the properties vector
        void clear() { m_vertex_properties.clear(); }

// Resize the properties vector
        void resize(std::size_t n) { m_vertex_properties.resize(n); }

// Reserve space in the vector of properties
        void reserve(std::size_t n) { m_vertex_properties.reserve(n); }

// Add a new property value to the back
        void push_back(const Property& prop)
        {
            m_vertex_properties.push_back(prop);
        }

// Write an element by raw index
        void write_by_index(std::size_t idx, const Property& prop)
        {
            m_vertex_properties[idx] = prop;
        }

// Access to the derived object
        Derived& derived() { return *static_cast< Derived* >(this); }

const Derived& derived() const
        {
            return *static_cast< const Derived* >(this);
        }

public: // should be private, but friend templates not portable
        std::vector< Property > m_vertex_properties;
    };

template < typename Derived, typename Descriptor, typename IndexMap >
    class indexed_vertex_properties< Derived, void, Descriptor, IndexMap >
    {
        struct secret
        {
        };

public:
        typedef no_property vertex_property_type;
        typedef void vertex_bundled;
        typedef secret vertex_map_type;
        typedef secret const_vertex_map_type;

secret operator[](secret) { return secret(); }

vertex_map_type get_vertex_bundle() const { return vertex_map_type(); }

protected:
        // All operations do nothing.
        indexed_vertex_properties() {}
        indexed_vertex_properties(std::size_t) {}

public:
        void clear() {}
        void resize(std::size_t) {}
        void reserve(std::size_t) {}
    };

template < typename Derived, typename Property, typename Descriptor,
        typename IndexMap >
    class indexed_edge_properties
    {
    public:
        typedef no_property edge_property_type;
        typedef Property edge_bundled;
        typedef Property edge_push_back_type;
        typedef iterator_property_map<
            typename std::vector< Property >::iterator, IndexMap >
            edge_map_type;
        typedef iterator_property_map<
            typename std::vector< Property >::const_iterator, IndexMap >
            const_edge_map_type;

// Directly access a edge or edge bundle
        Property& operator[](Descriptor v)
        {
            return m_edge_properties[get(edge_index, derived(), v)];
        }

const Property& operator[](Descriptor v) const
        {
            return m_edge_properties[get(edge_index, derived(), v)];
        }

edge_map_type get_edge_bundle(const IndexMap& index_map = IndexMap())
        {
            return edge_map_type(m_edge_properties.begin(), index_map);
        }

const_edge_map_type get_edge_bundle(
            const IndexMap& index_map = IndexMap()) const
        {
            return const_edge_map_type(m_edge_properties.begin(), index_map);
        }

protected:
        // Default-construct with no property values
        indexed_edge_properties() {}

// Initialize with n default-constructed property values
        indexed_edge_properties(std::size_t n) : m_edge_properties(n) {}

// Get the size of the properties vector
        std::size_t size() const { return m_edge_properties.size(); }

// Clear the properties vector
        void clear() { m_edge_properties.clear(); }

// Resize the properties vector
        void resize(std::size_t n) { m_edge_properties.resize(n); }

// Reserve space in the vector of properties
        void reserve(std::size_t n) { m_edge_properties.reserve(n); }

// Write an element by raw index
        void write_by_index(std::size_t idx, const Property& prop)
        {
            m_edge_properties[idx] = prop;
        }

public:
        // Add a new property value to the back
        void push_back(const Property& prop)
        {
            m_edge_properties.push_back(prop);
        }

// Move range of properties backwards
        void move_range(
            std::size_t src_begin, std::size_t src_end, std::size_t dest_begin)
        {
            std::copy_backward(m_edge_properties.begin() + src_begin,
                m_edge_properties.begin() + src_end,
                m_edge_properties.begin() + dest_begin + (src_end - src_begin));
        }

typedef typename std::vector< Property >::iterator iterator;
        iterator begin() { return m_edge_properties.begin(); }
        iterator end() { return m_edge_properties.end(); }

private:
        // Access to the derived object
        Derived& derived() { return *static_cast< Derived* >(this); }

const Derived& derived() const
        {
            return *static_cast< const Derived* >(this);
        }

public: // should be private, but friend templates not portable
        std::vector< Property > m_edge_properties;
    };

struct dummy_no_property_iterator
    : public boost::iterator_facade< dummy_no_property_iterator, no_property,
          std::random_access_iterator_tag >
    {
        mutable no_property prop;
        no_property& dereference() const { return prop; }
        bool equal(const dummy_no_property_iterator&) const { return true; }
        void increment() {}
        void decrement() {}
        void advance(std::ptrdiff_t) {}
        std::ptrdiff_t distance_to(const dummy_no_property_iterator) const
        {
            return 0;
        }
    };

template < typename Derived, typename Descriptor, typename IndexMap >
    class indexed_edge_properties< Derived, void, Descriptor, IndexMap >
    {
        struct secret
        {
        };

public:
        typedef no_property edge_property_type;
        typedef void edge_bundled;
        typedef void* edge_push_back_type;
        typedef secret edge_map_type;
        typedef secret const_edge_map_type;

secret operator[](secret) { return secret(); }
        void write_by_index(std::size_t /*idx*/, const no_property& /*prop*/) {}

edge_map_type get_edge_bundle(const IndexMap& = IndexMap()) const
        {
            return edge_map_type();
        }

protected:
        // All operations do nothing.
        indexed_edge_properties() {}
        indexed_edge_properties(std::size_t) {}
        std::size_t size() const { return 0; }
        void clear() {}
        void resize(std::size_t) {}
        void reserve(std::size_t) {}

public:
        void push_back(const edge_push_back_type&) {}
        void move_range(std::size_t /*src_begin*/, std::size_t /*src_end*/,
            std::size_t /*dest_begin*/)
        {
        }

typedef dummy_no_property_iterator iterator;
        iterator begin() { return dummy_no_property_iterator(); }
        iterator end() { return dummy_no_property_iterator(); }
    };

}
}

#endif // BOOST_GRAPH_INDEXED_PROPERTIES_HPP

cmd: