FM / graph

/usr/include/boost/graph

Name	Size	Mode	Actions
detail/	-	0755	rm
distributed/	-	0755	rm
parallel/	-	0755	rm
planar_detail/	-	0755	rm
property_maps/	-	0755	rm
accounting.hpp	876	0644	edit dl rm
adjacency_iterator.hpp	2899	0644	edit dl rm
adjacency_list.hpp	13692	0644	edit dl rm
adjacency_list_io.hpp	11849	0644	edit dl rm
adjacency_matrix.hpp	45743	0644	edit dl rm
adj_list_serialize.hpp	4523	0644	edit dl rm
astar_search.hpp	26736	0644	edit dl rm
bandwidth.hpp	2992	0644	edit dl rm
bc_clustering.hpp	5937	0644	edit dl rm
bellman_ford_shortest_paths.hpp	8229	0644	edit dl rm
betweenness_centrality.hpp	26290	0644	edit dl rm
biconnected_components.hpp	16701	0644	edit dl rm
bipartite.hpp	13492	0644	edit dl rm
boyer_myrvold_planar_test.hpp	9849	0644	edit dl rm
boykov_kolmogorov_max_flow.hpp	47342	0644	edit dl rm
breadth_first_search.hpp	14751	0644	edit dl rm
bron_kerbosch_all_cliques.hpp	11736	0644	edit dl rm
buffer_concepts.hpp	2429	0644	edit dl rm
chrobak_payne_drawing.hpp	8641	0644	edit dl rm
circle_layout.hpp	1924	0644	edit dl rm
closeness_centrality.hpp	6057	0644	edit dl rm
clustering_coefficient.hpp	5726	0644	edit dl rm
compressed_sparse_row_graph.hpp	69887	0644	edit dl rm
connected_components.hpp	4134	0644	edit dl rm
copy.hpp	21225	0644	edit dl rm
core_numbers.hpp	13663	0644	edit dl rm
create_condensation_graph.hpp	3159	0644	edit dl rm
cuthill_mckee_ordering.hpp	5992	0644	edit dl rm
cycle_canceling.hpp	6645	0644	edit dl rm
dag_shortest_paths.hpp	6064	0644	edit dl rm
degree_centrality.hpp	4236	0644	edit dl rm
depth_first_search.hpp	15430	0644	edit dl rm
dijkstra_shortest_paths.hpp	23687	0644	edit dl rm
dijkstra_shortest_paths_no_color_map.hpp	9620	0644	edit dl rm
dimacs.hpp	10448	0644	edit dl rm
directed_graph.hpp	24214	0644	edit dl rm
dll_import_export.hpp	892	0644	edit dl rm
dominator_tree.hpp	17553	0644	edit dl rm
eccentricity.hpp	4611	0644	edit dl rm
edge_coloring.hpp	6809	0644	edit dl rm
edge_connectivity.hpp	6796	0644	edit dl rm
edge_list.hpp	9948	0644	edit dl rm
edmonds_karp_max_flow.hpp	10177	0644	edit dl rm
edmunds_karp_max_flow.hpp	982	0644	edit dl rm
erdos_renyi_generator.hpp	7257	0644	edit dl rm
exception.hpp	1466	0644	edit dl rm
exterior_property.hpp	4289	0644	edit dl rm
filtered_graph.hpp	20098	0644	edit dl rm
find_flow_cost.hpp	1859	0644	edit dl rm
floyd_warshall_shortest.hpp	8510	0644	edit dl rm
fruchterman_reingold.hpp	17325	0644	edit dl rm
geodesic_distance.hpp	8015	0644	edit dl rm
graphml.hpp	13460	0644	edit dl rm
graphviz.hpp	33503	0644	edit dl rm
graph_archetypes.hpp	11008	0644	edit dl rm
graph_as_tree.hpp	4532	0644	edit dl rm
graph_concepts.hpp	19785	0644	edit dl rm
graph_mutability_traits.hpp	4995	0644	edit dl rm
graph_selectors.hpp	1274	0644	edit dl rm
graph_stats.hpp	4394	0644	edit dl rm
graph_traits.hpp	13065	0644	edit dl rm
graph_utility.hpp	16182	0644	edit dl rm
grid_graph.hpp	33830	0644	edit dl rm
gursoy_atun_layout.hpp	13248	0644	edit dl rm
hawick_circuits.hpp	14593	0644	edit dl rm
howard_cycle_ratio.hpp	23107	0644	edit dl rm
incremental_components.hpp	8224	0644	edit dl rm
isomorphism.hpp	26308	0644	edit dl rm
is_kuratowski_subgraph.hpp	10260	0644	edit dl rm
is_straight_line_drawing.hpp	7230	0644	edit dl rm
iteration_macros.hpp	11659	0644	edit dl rm
iteration_macros_undef.hpp	673	0644	edit dl rm
johnson_all_pairs_shortest.hpp	7646	0644	edit dl rm
kamada_kawai_spring_layout.hpp	28048	0644	edit dl rm
king_ordering.hpp	12101	0644	edit dl rm
kruskal_min_spanning_tree.hpp	5743	0644	edit dl rm
labeled_graph.hpp	30914	0644	edit dl rm
leda_graph.hpp	28789	0644	edit dl rm
lookup_edge.hpp	1894	0644	edit dl rm
loop_erased_random_walk.hpp	4436	0644	edit dl rm
make_biconnected_planar.hpp	3513	0644	edit dl rm
make_connected.hpp	2645	0644	edit dl rm
make_maximal_planar.hpp	7578	0644	edit dl rm
matrix_as_graph.hpp	7227	0644	edit dl rm
maximum_adjacency_search.hpp	15125	0644	edit dl rm
maximum_weighted_matching.hpp	49722	0644	edit dl rm
max_cardinality_matching.hpp	31000	0644	edit dl rm
mcgregor_common_subgraphs.hpp	43470	0644	edit dl rm
mesh_graph_generator.hpp	5616	0644	edit dl rm
metis.hpp	10982	0644	edit dl rm
metric_tsp_approx.hpp	10809	0644	edit dl rm
minimum_degree_ordering.hpp	27087	0644	edit dl rm
named_function_params.hpp	39639	0644	edit dl rm
named_graph.hpp	20614	0644	edit dl rm
neighbor_bfs.hpp	11763	0644	edit dl rm
numeric_values.hpp	1814	0644	edit dl rm
one_bit_color_map.hpp	3277	0644	edit dl rm
overloading.hpp	1584	0644	edit dl rm
page_rank.hpp	6164	0644	edit dl rm
planar_canonical_ordering.hpp	7203	0644	edit dl rm
planar_face_traversal.hpp	6020	0644	edit dl rm
plod_generator.hpp	7708	0644	edit dl rm
point_traits.hpp	782	0644	edit dl rm
prim_minimum_spanning_tree.hpp	2960	0644	edit dl rm
profile.hpp	1327	0644	edit dl rm
properties.hpp	12417	0644	edit dl rm
property_iter_range.hpp	4345	0644	edit dl rm
push_relabel_max_flow.hpp	34737	0644	edit dl rm
random.hpp	9672	0644	edit dl rm
random_layout.hpp	988	0644	edit dl rm
random_spanning_tree.hpp	5775	0644	edit dl rm
read_dimacs.hpp	12080	0644	edit dl rm
relax.hpp	4400	0644	edit dl rm
reverse_graph.hpp	22402	0644	edit dl rm
rmat_graph_generator.hpp	19291	0644	edit dl rm
r_c_shortest_paths.hpp	30673	0644	edit dl rm
sequential_vertex_coloring.hpp	4562	0644	edit dl rm
simple_point.hpp	628	0644	edit dl rm
sloan_ordering.hpp	15540	0644	edit dl rm
smallest_last_ordering.hpp	5458	0644	edit dl rm
small_world_generator.hpp	3670	0644	edit dl rm
ssca_graph_generator.hpp	6564	0644	edit dl rm
stanford_graph.hpp	20126	0644	edit dl rm
stoer_wagner_min_cut.hpp	12415	0644	edit dl rm
strong_components.hpp	13009	0644	edit dl rm
st_connected.hpp	2852	0644	edit dl rm
subgraph.hpp	39996	0644	edit dl rm
successive_shortest_path_nonnegative_weights.hpp	10413	0644	edit dl rm
tiernan_all_cycles.hpp	12547	0644	edit dl rm
topological_sort.hpp	2611	0644	edit dl rm
topology.hpp	20389	0644	edit dl rm
transitive_closure.hpp	14260	0644	edit dl rm
transitive_reduction.hpp	5326	0644	edit dl rm
transpose_graph.hpp	1198	0644	edit dl rm
tree_traits.hpp	1338	0644	edit dl rm
two_bit_color_map.hpp	3510	0644	edit dl rm
two_graphs_common_spanning_trees.hpp	34996	0644	edit dl rm
undirected_dfs.hpp	10672	0644	edit dl rm
undirected_graph.hpp	25276	0644	edit dl rm
use_mpi.hpp	437	0644	edit dl rm
vector_as_graph.hpp	10474	0644	edit dl rm
vertex_and_edge_range.hpp	5528	0644	edit dl rm
vf2_sub_graph_iso.hpp	48585	0644	edit dl rm
visitors.hpp	11318	0644	edit dl rm
wavefront.hpp	3932	0644	edit dl rm
write_dimacs.hpp	2889	0644	edit dl rm

Edit: /usr/include/boost/graph/copy.hpp (21225B)

//
//=======================================================================
// Copyright 1997-2001 University of Notre Dame.
// Authors: Jeremy G. Siek, Lie-Quan Lee, Andrew Lumsdaine
//
// 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)
//=======================================================================
//

/*
  This file implements the following functions:

template <typename VertexListGraph, typename MutableGraph>
  void copy_graph(const VertexListGraph& g_in, MutableGraph& g_out)

template <typename IncidenceGraph, typename MutableGraph>
  typename graph_traits<MutableGraph>::vertex_descriptor
  copy_component(IncidenceGraph& g_in,
                 typename graph_traits<IncidenceGraph>::vertex_descriptor src,
                 MutableGraph& g_out)

template <typename IncidenceGraph, typename MutableGraph,
           typename P, typename T, typename R>
  typename graph_traits<MutableGraph>::vertex_descriptor
  copy_component(IncidenceGraph& g_in,
                 typename graph_traits<IncidenceGraph>::vertex_descriptor src,
                 MutableGraph& g_out,
                 const bgl_named_params<P, T, R>& params)
 */

#ifndef BOOST_GRAPH_COPY_HPP
#define BOOST_GRAPH_COPY_HPP

#include <boost/config.hpp>
#include <vector>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/reverse_graph.hpp>
#include <boost/property_map/property_map.hpp>
#include <boost/graph/named_function_params.hpp>
#include <boost/graph/breadth_first_search.hpp>
#include <boost/type_traits/conversion_traits.hpp>

namespace boost
{

namespace detail
{

// Hack to make transpose_graph work with the same interface as before
    template < typename Graph, typename Desc >
    struct remove_reverse_edge_descriptor
    {
        typedef Desc type;
        static Desc convert(const Desc& d, const Graph&) { return d; }
    };

template < typename Graph, typename Desc >
    struct remove_reverse_edge_descriptor< Graph,
        reverse_graph_edge_descriptor< Desc > >
    {
        typedef Desc type;
        static Desc convert(
            const reverse_graph_edge_descriptor< Desc >& d, const Graph& g)
        {
            return get(edge_underlying, g, d);
        }
    };

// Add a reverse_graph_edge_descriptor wrapper if the Graph is a
    // reverse_graph but the edge descriptor is from the original graph (this
    // case comes from the fact that transpose_graph uses reverse_graph
    // internally but doesn't expose the different edge descriptor type to the
    // user).
    template < typename Desc, typename Graph >
    struct add_reverse_edge_descriptor
    {
        typedef Desc type;
        static Desc convert(const Desc& d) { return d; }
    };

template < typename Desc, typename G, typename GR >
    struct add_reverse_edge_descriptor< Desc, boost::reverse_graph< G, GR > >
    {
        typedef reverse_graph_edge_descriptor< Desc > type;
        static reverse_graph_edge_descriptor< Desc > convert(const Desc& d)
        {
            return reverse_graph_edge_descriptor< Desc >(d);
        }
    };

template < typename Desc, typename G, typename GR >
    struct add_reverse_edge_descriptor< reverse_graph_edge_descriptor< Desc >,
        boost::reverse_graph< G, GR > >
    {
        typedef reverse_graph_edge_descriptor< Desc > type;
        static reverse_graph_edge_descriptor< Desc > convert(
            const reverse_graph_edge_descriptor< Desc >& d)
        {
            return d;
        }
    };

// Default edge and vertex property copiers

template < typename Graph1, typename Graph2 > struct edge_copier
    {
        edge_copier(const Graph1& g1, Graph2& g2)
        : edge_all_map1(get(edge_all, g1)), edge_all_map2(get(edge_all, g2))
        {
        }

template < typename Edge1, typename Edge2 >
        void operator()(const Edge1& e1, Edge2& e2) const
        {
            put(edge_all_map2, e2,
                get(edge_all_map1,
                    add_reverse_edge_descriptor< Edge1, Graph1 >::convert(e1)));
        }
        typename property_map< Graph1, edge_all_t >::const_type edge_all_map1;
        mutable typename property_map< Graph2, edge_all_t >::type edge_all_map2;
    };
    template < typename Graph1, typename Graph2 >
    inline edge_copier< Graph1, Graph2 > make_edge_copier(
        const Graph1& g1, Graph2& g2)
    {
        return edge_copier< Graph1, Graph2 >(g1, g2);
    }

template < typename Graph1, typename Graph2 > struct vertex_copier
    {
        vertex_copier(const Graph1& g1, Graph2& g2)
        : vertex_all_map1(get(vertex_all, g1))
        , vertex_all_map2(get(vertex_all, g2))
        {
        }

template < typename Vertex1, typename Vertex2 >
        void operator()(const Vertex1& v1, Vertex2& v2) const
        {
            put(vertex_all_map2, v2, get(vertex_all_map1, v1));
        }
        typename property_map< Graph1, vertex_all_t >::const_type
            vertex_all_map1;
        mutable
            typename property_map< Graph2, vertex_all_t >::type vertex_all_map2;
    };
    template < typename Graph1, typename Graph2 >
    inline vertex_copier< Graph1, Graph2 > make_vertex_copier(
        const Graph1& g1, Graph2& g2)
    {
        return vertex_copier< Graph1, Graph2 >(g1, g2);
    }

// Copy all the vertices and edges of graph g_in into graph g_out.
    // The copy_vertex and copy_edge function objects control how vertex
    // and edge properties are copied.

template < int Version > struct copy_graph_impl
    {
    };

template <> struct copy_graph_impl< 0 >
    {
        template < typename Graph, typename MutableGraph, typename CopyVertex,
            typename CopyEdge, typename IndexMap,
            typename Orig2CopyVertexIndexMap >
        static void apply(const Graph& g_in, MutableGraph& g_out,
            CopyVertex copy_vertex, CopyEdge copy_edge,
            Orig2CopyVertexIndexMap orig2copy, IndexMap)
        {
            typedef remove_reverse_edge_descriptor< Graph,
                typename graph_traits< Graph >::edge_descriptor >
                cvt;
            typename graph_traits< Graph >::vertex_iterator vi, vi_end;
            for (boost::tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi)
            {
                typename graph_traits< MutableGraph >::vertex_descriptor new_v
                    = add_vertex(g_out);
                put(orig2copy, *vi, new_v);
                copy_vertex(*vi, new_v);
            }
            typename graph_traits< Graph >::edge_iterator ei, ei_end;
            for (boost::tie(ei, ei_end) = edges(g_in); ei != ei_end; ++ei)
            {
                typename graph_traits< MutableGraph >::edge_descriptor new_e;
                bool inserted;
                boost::tie(new_e, inserted)
                    = add_edge(get(orig2copy, source(*ei, g_in)),
                        get(orig2copy, target(*ei, g_in)), g_out);
                copy_edge(cvt::convert(*ei, g_in), new_e);
            }
        }
    };

// for directed graphs
    template <> struct copy_graph_impl< 1 >
    {
        template < typename Graph, typename MutableGraph, typename CopyVertex,
            typename CopyEdge, typename IndexMap,
            typename Orig2CopyVertexIndexMap >
        static void apply(const Graph& g_in, MutableGraph& g_out,
            CopyVertex copy_vertex, CopyEdge copy_edge,
            Orig2CopyVertexIndexMap orig2copy, IndexMap)
        {
            typedef remove_reverse_edge_descriptor< Graph,
                typename graph_traits< Graph >::edge_descriptor >
                cvt;
            typename graph_traits< Graph >::vertex_iterator vi, vi_end;
            for (boost::tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi)
            {
                typename graph_traits< MutableGraph >::vertex_descriptor new_v
                    = add_vertex(g_out);
                put(orig2copy, *vi, new_v);
                copy_vertex(*vi, new_v);
            }
            for (boost::tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi)
            {
                typename graph_traits< Graph >::out_edge_iterator ei, ei_end;
                for (boost::tie(ei, ei_end) = out_edges(*vi, g_in);
                     ei != ei_end; ++ei)
                {
                    typename graph_traits< MutableGraph >::edge_descriptor
                        new_e;
                    bool inserted;
                    boost::tie(new_e, inserted)
                        = add_edge(get(orig2copy, source(*ei, g_in)),
                            get(orig2copy, target(*ei, g_in)), g_out);
                    copy_edge(cvt::convert(*ei, g_in), new_e);
                }
            }
        }
    };

// for undirected graphs
    template <> struct copy_graph_impl< 2 >
    {
        template < typename Graph, typename MutableGraph, typename CopyVertex,
            typename CopyEdge, typename IndexMap,
            typename Orig2CopyVertexIndexMap >
        static void apply(const Graph& g_in, MutableGraph& g_out,
            CopyVertex copy_vertex, CopyEdge copy_edge,
            Orig2CopyVertexIndexMap orig2copy, IndexMap index_map)
        {
            typedef remove_reverse_edge_descriptor< Graph,
                typename graph_traits< Graph >::edge_descriptor >
                cvt;
            typedef color_traits< default_color_type > Color;
            std::vector< default_color_type > color(
                num_vertices(g_in), Color::white());
            typename graph_traits< Graph >::vertex_iterator vi, vi_end;
            for (boost::tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi)
            {
                typename graph_traits< MutableGraph >::vertex_descriptor new_v
                    = add_vertex(g_out);
                put(orig2copy, *vi, new_v);
                copy_vertex(*vi, new_v);
            }
            for (boost::tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi)
            {
                typename graph_traits< Graph >::out_edge_iterator ei, ei_end;
                for (boost::tie(ei, ei_end) = out_edges(*vi, g_in);
                     ei != ei_end; ++ei)
                {
                    typename graph_traits< MutableGraph >::edge_descriptor
                        new_e;
                    bool inserted;
                    if (color[get(index_map, target(*ei, g_in))]
                        == Color::white())
                    {
                        boost::tie(new_e, inserted)
                            = add_edge(get(orig2copy, source(*ei, g_in)),
                                get(orig2copy, target(*ei, g_in)), g_out);
                        copy_edge(cvt::convert(*ei, g_in), new_e);
                    }
                }
                color[get(index_map, *vi)] = Color::black();
            }
        }
    };

template < class Graph > struct choose_graph_copy
    {
        typedef typename graph_traits< Graph >::traversal_category Trv;
        typedef typename graph_traits< Graph >::directed_category Dr;
        enum
        {
            algo = (is_convertible< Trv, vertex_list_graph_tag >::value
                       && is_convertible< Trv, edge_list_graph_tag >::value)
                ? 0
                : is_convertible< Dr, directed_tag >::value ? 1 : 2
        };
        typedef copy_graph_impl< algo > type;
    };

//-------------------------------------------------------------------------
    struct choose_copier_parameter
    {
        template < class P, class G1, class G2 > struct bind_
        {
            typedef const P& result_type;
            static result_type apply(const P& p, const G1&, G2&) { return p; }
        };
    };
    struct choose_default_edge_copier
    {
        template < class P, class G1, class G2 > struct bind_
        {
            typedef edge_copier< G1, G2 > result_type;
            static result_type apply(const P&, const G1& g1, G2& g2)
            {
                return result_type(g1, g2);
            }
        };
    };
    template < class Param > struct choose_edge_copy
    {
        typedef choose_copier_parameter type;
    };
    template <> struct choose_edge_copy< param_not_found >
    {
        typedef choose_default_edge_copier type;
    };
    template < class Param, class G1, class G2 >
    struct choose_edge_copier_helper
    {
        typedef typename choose_edge_copy< Param >::type Selector;
        typedef typename Selector::template bind_< Param, G1, G2 > Bind;
        typedef Bind type;
        typedef typename Bind::result_type result_type;
    };
    template < typename Param, typename G1, typename G2 >
    typename detail::choose_edge_copier_helper< Param, G1, G2 >::result_type
    choose_edge_copier(const Param& params, const G1& g_in, G2& g_out)
    {
        typedef
            typename detail::choose_edge_copier_helper< Param, G1, G2 >::type
                Choice;
        return Choice::apply(params, g_in, g_out);
    }

struct choose_default_vertex_copier
    {
        template < class P, class G1, class G2 > struct bind_
        {
            typedef vertex_copier< G1, G2 > result_type;
            static result_type apply(const P&, const G1& g1, G2& g2)
            {
                return result_type(g1, g2);
            }
        };
    };
    template < class Param > struct choose_vertex_copy
    {
        typedef choose_copier_parameter type;
    };
    template <> struct choose_vertex_copy< param_not_found >
    {
        typedef choose_default_vertex_copier type;
    };
    template < class Param, class G1, class G2 >
    struct choose_vertex_copier_helper
    {
        typedef typename choose_vertex_copy< Param >::type Selector;
        typedef typename Selector::template bind_< Param, G1, G2 > Bind;
        typedef Bind type;
        typedef typename Bind::result_type result_type;
    };
    template < typename Param, typename G1, typename G2 >
    typename detail::choose_vertex_copier_helper< Param, G1, G2 >::result_type
    choose_vertex_copier(const Param& params, const G1& g_in, G2& g_out)
    {
        typedef
            typename detail::choose_vertex_copier_helper< Param, G1, G2 >::type
                Choice;
        return Choice::apply(params, g_in, g_out);
    }

} // namespace detail

template < typename VertexListGraph, typename MutableGraph >
void copy_graph(const VertexListGraph& g_in, MutableGraph& g_out)
{
    if (num_vertices(g_in) == 0)
        return;
    typedef typename graph_traits< MutableGraph >::vertex_descriptor vertex_t;
    std::vector< vertex_t > orig2copy(num_vertices(g_in));
    typedef
        typename detail::choose_graph_copy< VertexListGraph >::type copy_impl;
    copy_impl::apply(g_in, g_out, detail::make_vertex_copier(g_in, g_out),
        detail::make_edge_copier(g_in, g_out),
        make_iterator_property_map(
            orig2copy.begin(), get(vertex_index, g_in), orig2copy[0]),
        get(vertex_index, g_in));
}

template < typename VertexListGraph, typename MutableGraph, class P, class T,
    class R >
void copy_graph(const VertexListGraph& g_in, MutableGraph& g_out,
    const bgl_named_params< P, T, R >& params)
{
    typename std::vector< T >::size_type n;
    n = is_default_param(get_param(params, orig_to_copy_t()))
        ? num_vertices(g_in)
        : 1;
    if (n == 0)
        return;
    std::vector<
        BOOST_DEDUCED_TYPENAME graph_traits< MutableGraph >::vertex_descriptor >
        orig2copy(n);

typedef
        typename detail::choose_graph_copy< VertexListGraph >::type copy_impl;
    copy_impl::apply(g_in, g_out,
        detail::choose_vertex_copier(
            get_param(params, vertex_copy_t()), g_in, g_out),
        detail::choose_edge_copier(
            get_param(params, edge_copy_t()), g_in, g_out),
        choose_param(get_param(params, orig_to_copy_t()),
            make_iterator_property_map(orig2copy.begin(),
                choose_const_pmap(
                    get_param(params, vertex_index), g_in, vertex_index),
                orig2copy[0])),
        choose_const_pmap(get_param(params, vertex_index), g_in, vertex_index));
}

namespace detail
{

template < class NewGraph, class Copy2OrigIndexMap, class CopyVertex,
        class CopyEdge >
    struct graph_copy_visitor : public bfs_visitor<>
    {
        graph_copy_visitor(
            NewGraph& graph, Copy2OrigIndexMap c, CopyVertex cv, CopyEdge ce)
        : g_out(graph), orig2copy(c), copy_vertex(cv), copy_edge(ce)
        {
        }

template < class Vertex >
        typename graph_traits< NewGraph >::vertex_descriptor copy_one_vertex(
            Vertex u) const
        {
            typename graph_traits< NewGraph >::vertex_descriptor new_u
                = add_vertex(g_out);
            put(orig2copy, u, new_u);
            copy_vertex(u, new_u);
            return new_u;
        }

template < class Edge, class Graph >
        void tree_edge(Edge e, const Graph& g_in) const
        {
            // For a tree edge, the target vertex has not been copied yet.
            typename graph_traits< NewGraph >::edge_descriptor new_e;
            bool inserted;
            boost::tie(new_e, inserted)
                = add_edge(get(orig2copy, source(e, g_in)),
                    this->copy_one_vertex(target(e, g_in)), g_out);
            copy_edge(e, new_e);
        }

template < class Edge, class Graph >
        void non_tree_edge(Edge e, const Graph& g_in) const
        {
            // For a non-tree edge, the target vertex has already been copied.
            typename graph_traits< NewGraph >::edge_descriptor new_e;
            bool inserted;
            boost::tie(new_e, inserted)
                = add_edge(get(orig2copy, source(e, g_in)),
                    get(orig2copy, target(e, g_in)), g_out);
            copy_edge(e, new_e);
        }

private:
        NewGraph& g_out;
        Copy2OrigIndexMap orig2copy;
        CopyVertex copy_vertex;
        CopyEdge copy_edge;
    };

template < typename Graph, typename MutableGraph, typename CopyVertex,
        typename CopyEdge, typename Orig2CopyVertexIndexMap, typename Params >
    typename graph_traits< MutableGraph >::vertex_descriptor
    copy_component_impl(const Graph& g_in,
        typename graph_traits< Graph >::vertex_descriptor src,
        MutableGraph& g_out, CopyVertex copy_vertex, CopyEdge copy_edge,
        Orig2CopyVertexIndexMap orig2copy, const Params& params)
    {
        graph_copy_visitor< MutableGraph, Orig2CopyVertexIndexMap, CopyVertex,
            CopyEdge >
            vis(g_out, orig2copy, copy_vertex, copy_edge);
        typename graph_traits< MutableGraph >::vertex_descriptor src_copy
            = vis.copy_one_vertex(src);
        breadth_first_search(g_in, src, params.visitor(vis));
        return src_copy;
    }

} // namespace detail

// Copy all the vertices and edges of graph g_in that are reachable
// from the source vertex into graph g_out. Return the vertex
// in g_out that matches the source vertex of g_in.
template < typename IncidenceGraph, typename MutableGraph, typename P,
    typename T, typename R >
typename graph_traits< MutableGraph >::vertex_descriptor copy_component(
    IncidenceGraph& g_in,
    typename graph_traits< IncidenceGraph >::vertex_descriptor src,
    MutableGraph& g_out, const bgl_named_params< P, T, R >& params)
{
    typename std::vector< T >::size_type n;
    n = is_default_param(get_param(params, orig_to_copy_t()))
        ? num_vertices(g_in)
        : 1;
    std::vector< typename graph_traits< IncidenceGraph >::vertex_descriptor >
        orig2copy(n);

return detail::copy_component_impl(g_in, src, g_out,
        detail::choose_vertex_copier(
            get_param(params, vertex_copy_t()), g_in, g_out),
        detail::choose_edge_copier(
            get_param(params, edge_copy_t()), g_in, g_out),
        choose_param(get_param(params, orig_to_copy_t()),
            make_iterator_property_map(orig2copy.begin(),
                choose_pmap(
                    get_param(params, vertex_index), g_in, vertex_index),
                orig2copy[0])),
        params);
}

template < typename IncidenceGraph, typename MutableGraph >
typename graph_traits< MutableGraph >::vertex_descriptor copy_component(
    IncidenceGraph& g_in,
    typename graph_traits< IncidenceGraph >::vertex_descriptor src,
    MutableGraph& g_out)
{
    std::vector< typename graph_traits< IncidenceGraph >::vertex_descriptor >
        orig2copy(num_vertices(g_in));

return detail::copy_component_impl(g_in, src, g_out,
        make_vertex_copier(g_in, g_out), make_edge_copier(g_in, g_out),
        make_iterator_property_map(
            orig2copy.begin(), get(vertex_index, g_in), orig2copy[0]),
        bgl_named_params< char, char >('x') // dummy param object
    );
}

} // namespace boost

#endif // BOOST_GRAPH_COPY_HPP

cmd: