boost/graph/subgraph.hpp

//=======================================================================
// Copyright 2001 University of Notre Dame.
// Authors: Jeremy G. Siek and Lie-Quan Lee
//
// 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_SUBGRAPH_HPP
#define BOOST_SUBGRAPH_HPP

// UNDER CONSTRUCTION

#include <boost/config.hpp>
#include <list>
#include <vector>
#include <map>
#include <boost/assert.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/graph_mutability_traits.hpp>
#include <boost/graph/properties.hpp>
#include <boost/iterator/indirect_iterator.hpp>

#include <boost/static_assert.hpp>
#include <boost/assert.hpp>
#include <boost/type_traits.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>

namespace boost
{

struct subgraph_tag
{
};

/** @name Property Lookup
 * The local_property and global_property functions are used to create
 * structures that determine the lookup strategy for properties in subgraphs.
 * Note that the nested kind member is used to help interoperate with actual
 * Property types.
 */
//@{
template < typename T > struct local_property
{
    typedef T kind;
    local_property(T x) : value(x) {}
    T value;
};

template < typename T > inline local_property< T > local(T x)
{
    return local_property< T >(x);
}

template < typename T > struct global_property
{
    typedef T kind;
    global_property(T x) : value(x) {}
    T value;
};

template < typename T > inline global_property< T > global(T x)
{
    return global_property< T >(x);
}
//@}

// Invariants of an induced subgraph:
//   - If vertex u is in subgraph g, then u must be in g.parent().
//   - If edge e is in subgraph g, then e must be in g.parent().
//   - If edge e=(u,v) is in the root graph, then edge e
//     is also in any subgraph that contains both vertex u and v.

// The Graph template parameter must have a vertex_index and edge_index
// internal property. It is assumed that the vertex indices are assigned
// automatically by the graph during a call to add_vertex(). It is not
// assumed that the edge vertices are assigned automatically, they are
// explicitly assigned here.

template < typename Graph > class subgraph
{
    typedef graph_traits< Graph > Traits;
    typedef std::list< subgraph< Graph >* > ChildrenList;

public:
    // Graph requirements
    typedef typename Traits::vertex_descriptor vertex_descriptor;
    typedef typename Traits::edge_descriptor edge_descriptor;
    typedef typename Traits::directed_category directed_category;
    typedef typename Traits::edge_parallel_category edge_parallel_category;
    typedef typename Traits::traversal_category traversal_category;

    // IncidenceGraph requirements
    typedef typename Traits::out_edge_iterator out_edge_iterator;
    typedef typename Traits::degree_size_type degree_size_type;

    // AdjacencyGraph requirements
    typedef typename Traits::adjacency_iterator adjacency_iterator;

    // VertexListGraph requirements
    typedef typename Traits::vertex_iterator vertex_iterator;
    typedef typename Traits::vertices_size_type vertices_size_type;

    // EdgeListGraph requirements
    typedef typename Traits::edge_iterator edge_iterator;
    typedef typename Traits::edges_size_type edges_size_type;

    typedef typename Traits::in_edge_iterator in_edge_iterator;

    typedef typename edge_property_type< Graph >::type edge_property_type;
    typedef typename vertex_property_type< Graph >::type vertex_property_type;
    typedef subgraph_tag graph_tag;
    typedef Graph graph_type;
    typedef typename graph_property_type< Graph >::type graph_property_type;

    // Create the main graph, the root of the subgraph tree
    subgraph() : m_parent(0), m_edge_counter(0) {}

    subgraph(const graph_property_type& p)
    : m_graph(p), m_parent(0), m_edge_counter(0)
    {
    }

    subgraph(vertices_size_type n,
        const graph_property_type& p = graph_property_type())
    : m_graph(n, p), m_parent(0), m_edge_counter(0), m_global_vertex(n)
    {
        typename Graph::vertex_iterator v, v_end;
        vertices_size_type i = 0;
        for (boost::tie(v, v_end) = vertices(m_graph); v != v_end; ++v)
            m_global_vertex[i++] = *v;
    }

    // copy constructor
    subgraph(const subgraph& x) : m_parent(x.m_parent), m_edge_counter(0)
    {
        if (x.is_root())
        {
            m_graph = x.m_graph;
            m_edge_counter = x.m_edge_counter;
            m_global_vertex = x.m_global_vertex;
            m_global_edge = x.m_global_edge;
        }
        else
        {
            get_property(*this) = get_property(x);
            typename subgraph< Graph >::vertex_iterator vi, vi_end;
            boost::tie(vi, vi_end) = vertices(x);
            for (; vi != vi_end; ++vi)
            {
                add_vertex(x.local_to_global(*vi), *this);
            }
        }
        // Do a deep copy (recursive).
        // Only the root graph is copied, the subgraphs contain
        // only references to the global vertices they own.
        typename subgraph< Graph >::children_iterator i, i_end;
        boost::tie(i, i_end) = x.children();
        for (; i != i_end; ++i)
        {
            m_children.push_back(new subgraph< Graph >(*i));
            m_children.back()->m_parent = this;
        }
    }

    ~subgraph()
    {
        for (typename ChildrenList::iterator i = m_children.begin();
             i != m_children.end(); ++i)
        {
            delete *i;
        }
    }

    // Return a null vertex descriptor for the graph.
    static vertex_descriptor null_vertex() { return Traits::null_vertex(); }

    // Create a subgraph
    subgraph< Graph >& create_subgraph()
    {
        m_children.push_back(new subgraph< Graph >());
        m_children.back()->m_parent = this;
        return *m_children.back();
    }

    // Create a subgraph with the specified vertex set.
    template < typename VertexIterator >
    subgraph< Graph >& create_subgraph(
        VertexIterator first, VertexIterator last)
    {
        m_children.push_back(new subgraph< Graph >());
        m_children.back()->m_parent = this;
        for (; first != last; ++first)
        {
            add_vertex(*first, *m_children.back());
        }
        return *m_children.back();
    }

    // local <-> global descriptor conversion functions
    vertex_descriptor local_to_global(vertex_descriptor u_local) const
    {
        return is_root() ? u_local : m_global_vertex[u_local];
    }

    vertex_descriptor global_to_local(vertex_descriptor u_global) const
    {
        vertex_descriptor u_local;
        bool in_subgraph;
        if (is_root())
            return u_global;
        boost::tie(u_local, in_subgraph) = this->find_vertex(u_global);
        BOOST_ASSERT(in_subgraph == true);
        return u_local;
    }

    edge_descriptor local_to_global(edge_descriptor e_local) const
    {
        return is_root()
            ? e_local
            : m_global_edge[get(get(edge_index, m_graph), e_local)];
    }

    edge_descriptor global_to_local(edge_descriptor e_global) const
    {
        return is_root() ? e_global
                         : (*m_local_edge.find(
                                get(get(edge_index, root().m_graph), e_global)))
                               .second;
    }

    // Is vertex u (of the root graph) contained in this subgraph?
    // If so, return the matching local vertex.
    std::pair< vertex_descriptor, bool > find_vertex(
        vertex_descriptor u_global) const
    {
        if (is_root())
            return std::make_pair(u_global, true);
        typename LocalVertexMap::const_iterator i
            = m_local_vertex.find(u_global);
        bool valid = i != m_local_vertex.end();
        return std::make_pair((valid ? (*i).second : null_vertex()), valid);
    }

    // Is edge e (of the root graph) contained in this subgraph?
    // If so, return the matching local edge.
    std::pair< edge_descriptor, bool > find_edge(edge_descriptor e_global) const
    {
        if (is_root())
            return std::make_pair(e_global, true);
        typename LocalEdgeMap::const_iterator i
            = m_local_edge.find(get(get(edge_index, root().m_graph), e_global));
        bool valid = i != m_local_edge.end();
        return std::make_pair((valid ? (*i).second : edge_descriptor()), valid);
    }

    // Return the parent graph.
    subgraph& parent() { return *m_parent; }
    const subgraph& parent() const { return *m_parent; }

    // Return true if this is the root subgraph
    bool is_root() const { return m_parent == 0; }

    // Return the root graph of the subgraph tree.
    subgraph& root() { return is_root() ? *this : m_parent->root(); }

    const subgraph& root() const
    {
        return is_root() ? *this : m_parent->root();
    }

    // Return the children subgraphs of this graph/subgraph.
    // Use a list of pointers because the VC++ std::list doesn't like
    // storing incomplete type.
    typedef indirect_iterator< typename ChildrenList::const_iterator,
        subgraph< Graph >, std::bidirectional_iterator_tag >
        children_iterator;

    typedef indirect_iterator< typename ChildrenList::const_iterator,
        subgraph< Graph > const, std::bidirectional_iterator_tag >
        const_children_iterator;

    std::pair< const_children_iterator, const_children_iterator >
    children() const
    {
        return std::make_pair(const_children_iterator(m_children.begin()),
            const_children_iterator(m_children.end()));
    }

    std::pair< children_iterator, children_iterator > children()
    {
        return std::make_pair(children_iterator(m_children.begin()),
            children_iterator(m_children.end()));
    }

    std::size_t num_children() const { return m_children.size(); }

#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
    // Defualt property access delegates the lookup to global properties.
    template < typename Descriptor >
    typename graph::detail::bundled_result< Graph, Descriptor >::type&
    operator[](Descriptor x)
    {
        return is_root() ? m_graph[x] : root().m_graph[local_to_global(x)];
    }

    template < typename Descriptor >
    typename graph::detail::bundled_result< Graph, Descriptor >::type const&
    operator[](Descriptor x) const
    {
        return is_root() ? m_graph[x] : root().m_graph[local_to_global(x)];
    }

    // Local property access returns the local property of the given descripor.
    template < typename Descriptor >
    typename graph::detail::bundled_result< Graph, Descriptor >::type&
    operator[](local_property< Descriptor > x)
    {
        return m_graph[x.value];
    }

    template < typename Descriptor >
    typename graph::detail::bundled_result< Graph, Descriptor >::type const&
    operator[](local_property< Descriptor > x) const
    {
        return m_graph[x.value];
    }

    // Global property access returns the global property associated with the
    // given descriptor. This is an alias for the default bundled property
    // access operations.
    template < typename Descriptor >
    typename graph::detail::bundled_result< Graph, Descriptor >::type&
    operator[](global_property< Descriptor > x)
    {
        return (*this)[x.value];
    }

    template < typename Descriptor >
    typename graph::detail::bundled_result< Graph, Descriptor >::type const&
    operator[](global_property< Descriptor > x) const
    {
        return (*this)[x.value];
    }

#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES

    //  private:
    typedef typename property_map< Graph, edge_index_t >::type EdgeIndexMap;
    typedef
        typename property_traits< EdgeIndexMap >::value_type edge_index_type;
    BOOST_STATIC_ASSERT((!is_same< edge_index_type,
                         boost::detail::error_property_not_found >::value));

private:
    typedef std::vector< vertex_descriptor > GlobalVertexList;
    typedef std::vector< edge_descriptor > GlobalEdgeList;
    typedef std::map< vertex_descriptor, vertex_descriptor > LocalVertexMap;
    typedef std::map< edge_index_type, edge_descriptor > LocalEdgeMap;
    // TODO: Should the LocalVertexMap be: map<index_type, descriptor>?
    // TODO: Can we relax the indexing requirement if both descriptors are
    // LessThanComparable?
    // TODO: Should we really be using unorderd_map for improved lookup times?

public: // Probably shouldn't be public....
    Graph m_graph;
    subgraph< Graph >* m_parent;
    edge_index_type m_edge_counter; // for generating unique edge indices
    ChildrenList m_children;
    GlobalVertexList m_global_vertex; // local -> global
    LocalVertexMap m_local_vertex; // global -> local
    GlobalEdgeList m_global_edge; // local -> global
    LocalEdgeMap m_local_edge; // global -> local

    edge_descriptor local_add_edge(vertex_descriptor u_local,
        vertex_descriptor v_local, edge_descriptor e_global)
    {
        edge_descriptor e_local;
        bool inserted;
        boost::tie(e_local, inserted) = add_edge(u_local, v_local, m_graph);
        put(edge_index, m_graph, e_local, m_edge_counter++);
        m_global_edge.push_back(e_global);
        m_local_edge[get(get(edge_index, this->root()), e_global)] = e_local;
        return e_local;
    }
};

template < typename Graph >
struct vertex_bundle_type< subgraph< Graph > > : vertex_bundle_type< Graph >
{
};

template < typename Graph >
struct edge_bundle_type< subgraph< Graph > > : edge_bundle_type< Graph >
{
};

template < typename Graph >
struct graph_bundle_type< subgraph< Graph > > : graph_bundle_type< Graph >
{
};

//===========================================================================
// Functions special to the Subgraph Class

template < typename G >
typename subgraph< G >::vertex_descriptor add_vertex(
    typename subgraph< G >::vertex_descriptor u_global, subgraph< G >& g)
{
    BOOST_ASSERT(!g.is_root());
    typename subgraph< G >::vertex_descriptor u_local;
    bool exists_local;
    boost::tie(u_local, exists_local) = g.find_vertex(u_global);

    if (!exists_local)
    {
        typename subgraph< G >::vertex_descriptor v_global;
        typename subgraph< G >::edge_descriptor e_global;
        // call recursion for parent subgraph
        if (!g.parent().is_root())
            add_vertex(u_global, g.parent());

        u_local = add_vertex(g.m_graph);
        g.m_global_vertex.push_back(u_global);
        g.m_local_vertex[u_global] = u_local;

        subgraph< G >& r = g.root();

        // remember edge global and local maps
        {
            typename subgraph< G >::out_edge_iterator ei, ei_end;
            for (boost::tie(ei, ei_end) = out_edges(u_global, r); ei != ei_end;
                 ++ei)
            {
                e_global = *ei;
                v_global = target(e_global, r);
                if (g.find_vertex(v_global).second == true)
                    g.local_add_edge(
                        u_local, g.global_to_local(v_global), e_global);
            }
        }
        if (is_directed(g))
        { // not necessary for undirected graph
            typename subgraph< G >::vertex_iterator vi, vi_end;
            typename subgraph< G >::out_edge_iterator ei, ei_end;
            for (boost::tie(vi, vi_end) = vertices(r); vi != vi_end; ++vi)
            {
                v_global = *vi;
                if (v_global == u_global)
                    continue; // don't insert self loops twice!
                if (!g.find_vertex(v_global).second)
                    continue; // not a subgraph vertex => try next one
                for (boost::tie(ei, ei_end) = out_edges(*vi, r); ei != ei_end;
                     ++ei)
                {
                    e_global = *ei;
                    if (target(e_global, r) == u_global)
                    {
                        g.local_add_edge(
                            g.global_to_local(v_global), u_local, e_global);
                    }
                }
            }
        }
    }
    return u_local;
}

// NOTE: Descriptors are local unless otherwise noted.

//===========================================================================
// Functions required by the IncidenceGraph concept

template < typename G >
std::pair< typename graph_traits< G >::out_edge_iterator,
    typename graph_traits< G >::out_edge_iterator >
out_edges(
    typename graph_traits< G >::vertex_descriptor v, const subgraph< G >& g)
{
    return out_edges(v, g.m_graph);
}

template < typename G >
typename graph_traits< G >::degree_size_type out_degree(
    typename graph_traits< G >::vertex_descriptor v, const subgraph< G >& g)
{
    return out_degree(v, g.m_graph);
}

template < typename G >
typename graph_traits< G >::vertex_descriptor source(
    typename graph_traits< G >::edge_descriptor e, const subgraph< G >& g)
{
    return source(e, g.m_graph);
}

template < typename G >
typename graph_traits< G >::vertex_descriptor target(
    typename graph_traits< G >::edge_descriptor e, const subgraph< G >& g)
{
    return target(e, g.m_graph);
}

//===========================================================================
// Functions required by the BidirectionalGraph concept

template < typename G >
std::pair< typename graph_traits< G >::in_edge_iterator,
    typename graph_traits< G >::in_edge_iterator >
in_edges(
    typename graph_traits< G >::vertex_descriptor v, const subgraph< G >& g)
{
    return in_edges(v, g.m_graph);
}

template < typename G >
typename graph_traits< G >::degree_size_type in_degree(
    typename graph_traits< G >::vertex_descriptor v, const subgraph< G >& g)
{
    return in_degree(v, g.m_graph);
}

template < typename G >
typename graph_traits< G >::degree_size_type degree(
    typename graph_traits< G >::vertex_descriptor v, const subgraph< G >& g)
{
    return degree(v, g.m_graph);
}

//===========================================================================
// Functions required by the AdjacencyGraph concept

template < typename G >
std::pair< typename subgraph< G >::adjacency_iterator,
    typename subgraph< G >::adjacency_iterator >
adjacent_vertices(
    typename subgraph< G >::vertex_descriptor v, const subgraph< G >& g)
{
    return adjacent_vertices(v, g.m_graph);
}

//===========================================================================
// Functions required by the VertexListGraph concept

template < typename G >
std::pair< typename subgraph< G >::vertex_iterator,
    typename subgraph< G >::vertex_iterator >
vertices(const subgraph< G >& g)
{
    return vertices(g.m_graph);
}

template < typename G >
typename subgraph< G >::vertices_size_type num_vertices(const subgraph< G >& g)
{
    return num_vertices(g.m_graph);
}

//===========================================================================
// Functions required by the EdgeListGraph concept

template < typename G >
std::pair< typename subgraph< G >::edge_iterator,
    typename subgraph< G >::edge_iterator >
edges(const subgraph< G >& g)
{
    return edges(g.m_graph);
}

template < typename G >
typename subgraph< G >::edges_size_type num_edges(const subgraph< G >& g)
{
    return num_edges(g.m_graph);
}

//===========================================================================
// Functions required by the AdjacencyMatrix concept

template < typename G >
std::pair< typename subgraph< G >::edge_descriptor, bool > edge(
    typename subgraph< G >::vertex_descriptor u,
    typename subgraph< G >::vertex_descriptor v, const subgraph< G >& g)
{
    return edge(u, v, g.m_graph);
}

//===========================================================================
// Functions required by the MutableGraph concept

namespace detail
{

    template < typename Vertex, typename Edge, typename Graph >
    void add_edge_recur_down(
        Vertex u_global, Vertex v_global, Edge e_global, subgraph< Graph >& g);

    template < typename Vertex, typename Edge, typename Children, typename G >
    void children_add_edge(Vertex u_global, Vertex v_global, Edge e_global,
        Children& c, subgraph< G >* orig)
    {
        for (typename Children::iterator i = c.begin(); i != c.end(); ++i)
        {
            if ((*i)->find_vertex(u_global).second
                && (*i)->find_vertex(v_global).second)
            {
                add_edge_recur_down(u_global, v_global, e_global, **i, orig);
            }
        }
    }

    template < typename Vertex, typename Edge, typename Graph >
    void add_edge_recur_down(Vertex u_global, Vertex v_global, Edge e_global,
        subgraph< Graph >& g, subgraph< Graph >* orig)
    {
        if (&g != orig)
        {
            // add local edge only if u_global and v_global are in subgraph g
            Vertex u_local, v_local;
            bool u_in_subgraph, v_in_subgraph;
            boost::tie(u_local, u_in_subgraph) = g.find_vertex(u_global);
            boost::tie(v_local, v_in_subgraph) = g.find_vertex(v_global);
            if (u_in_subgraph && v_in_subgraph)
            {
                g.local_add_edge(u_local, v_local, e_global);
            }
        }
        children_add_edge(u_global, v_global, e_global, g.m_children, orig);
    }

    template < typename Vertex, typename Graph >
    std::pair< typename subgraph< Graph >::edge_descriptor, bool >
    add_edge_recur_up(Vertex u_global, Vertex v_global,
        const typename Graph::edge_property_type& ep, subgraph< Graph >& g,
        subgraph< Graph >* orig)
    {
        if (g.is_root())
        {
            typename subgraph< Graph >::edge_descriptor e_global;
            bool inserted;
            boost::tie(e_global, inserted)
                = add_edge(u_global, v_global, ep, g.m_graph);
            put(edge_index, g.m_graph, e_global, g.m_edge_counter++);
            g.m_global_edge.push_back(e_global);
            children_add_edge(u_global, v_global, e_global, g.m_children, orig);
            return std::make_pair(e_global, inserted);
        }
        else
        {
            return add_edge_recur_up(u_global, v_global, ep, *g.m_parent, orig);
        }
    }

} // namespace detail

// Add an edge to the subgraph g, specified by the local vertex descriptors u
// and v. In addition, the edge will be added to any (all) other subgraphs that
// contain vertex descriptors u and v.

template < typename G >
std::pair< typename subgraph< G >::edge_descriptor, bool > add_edge(
    typename subgraph< G >::vertex_descriptor u,
    typename subgraph< G >::vertex_descriptor v,
    const typename G::edge_property_type& ep, subgraph< G >& g)
{
    if (g.is_root())
    {
        // u and v are really global
        return detail::add_edge_recur_up(u, v, ep, g, &g);
    }
    else
    {
        typename subgraph< G >::edge_descriptor e_local, e_global;
        bool inserted;
        boost::tie(e_global, inserted) = detail::add_edge_recur_up(
            g.local_to_global(u), g.local_to_global(v), ep, g, &g);
        e_local = g.local_add_edge(u, v, e_global);
        return std::make_pair(e_local, inserted);
    }
}

template < typename G >
std::pair< typename subgraph< G >::edge_descriptor, bool > add_edge(
    typename subgraph< G >::vertex_descriptor u,
    typename subgraph< G >::vertex_descriptor v, subgraph< G >& g)
{
    return add_edge(u, v, typename G::edge_property_type(), g);
}

namespace detail
{
    //-------------------------------------------------------------------------
    // implementation of remove_edge(u,v,g)
    template < typename Vertex, typename Graph >
    void remove_edge_recur_down(
        Vertex u_global, Vertex v_global, subgraph< Graph >& g);

    template < typename Vertex, typename Children >
    void children_remove_edge(Vertex u_global, Vertex v_global, Children& c)
    {
        for (typename Children::iterator i = c.begin(); i != c.end(); ++i)
        {
            if ((*i)->find_vertex(u_global).second
                && (*i)->find_vertex(v_global).second)
            {
                remove_edge_recur_down(u_global, v_global, **i);
            }
        }
    }

    template < typename Vertex, typename Graph >
    void remove_edge_recur_down(
        Vertex u_global, Vertex v_global, subgraph< Graph >& g)
    {
        Vertex u_local, v_local;
        u_local = g.m_local_vertex[u_global];
        v_local = g.m_local_vertex[v_global];
        remove_edge(u_local, v_local, g.m_graph);
        children_remove_edge(u_global, v_global, g.m_children);
    }

    template < typename Vertex, typename Graph >
    void remove_edge_recur_up(
        Vertex u_global, Vertex v_global, subgraph< Graph >& g)
    {
        if (g.is_root())
        {
            remove_edge(u_global, v_global, g.m_graph);
            children_remove_edge(u_global, v_global, g.m_children);
        }
        else
        {
            remove_edge_recur_up(u_global, v_global, *g.m_parent);
        }
    }

    //-------------------------------------------------------------------------
    // implementation of remove_edge(e,g)

    template < typename G, typename Edge, typename Children >
    void children_remove_edge(Edge e_global, Children& c)
    {
        for (typename Children::iterator i = c.begin(); i != c.end(); ++i)
        {
            std::pair< typename subgraph< G >::edge_descriptor, bool > found
                = (*i)->find_edge(e_global);
            if (!found.second)
            {
                continue;
            }
            children_remove_edge< G >(e_global, (*i)->m_children);
            remove_edge(found.first, (*i)->m_graph);
        }
    }

} // namespace detail

template < typename G >
void remove_edge(typename subgraph< G >::vertex_descriptor u,
    typename subgraph< G >::vertex_descriptor v, subgraph< G >& g)
{
    if (g.is_root())
    {
        detail::remove_edge_recur_up(u, v, g);
    }
    else
    {
        detail::remove_edge_recur_up(
            g.local_to_global(u), g.local_to_global(v), g);
    }
}

template < typename G >
void remove_edge(typename subgraph< G >::edge_descriptor e, subgraph< G >& g)
{
    typename subgraph< G >::edge_descriptor e_global = g.local_to_global(e);
#ifndef NDEBUG
    std::pair< typename subgraph< G >::edge_descriptor, bool > fe
        = g.find_edge(e_global);
    BOOST_ASSERT(fe.second && fe.first == e);
#endif // NDEBUG
    subgraph< G >& root = g.root(); // chase to root
    detail::children_remove_edge< G >(e_global, root.m_children);
    remove_edge(e_global, root.m_graph); // kick edge from root
}

// This is slow, but there may not be a good way to do it safely otherwise
template < typename Predicate, typename G >
void remove_edge_if(Predicate p, subgraph< G >& g)
{
    while (true)
    {
        bool any_removed = false;
        typedef typename subgraph< G >::edge_iterator ei_type;
        for (std::pair< ei_type, ei_type > ep = edges(g); ep.first != ep.second;
             ++ep.first)
        {
            if (p(*ep.first))
            {
                any_removed = true;
                remove_edge(*ep.first, g);
                break; /* Since iterators may be invalidated */
            }
        }
        if (!any_removed)
            break;
    }
}

template < typename G >
void clear_vertex(typename subgraph< G >::vertex_descriptor v, subgraph< G >& g)
{
    while (true)
    {
        typedef typename subgraph< G >::out_edge_iterator oei_type;
        std::pair< oei_type, oei_type > p = out_edges(v, g);
        if (p.first == p.second)
            break;
        remove_edge(*p.first, g);
    }
}

namespace detail
{
    template < typename G >
    typename subgraph< G >::vertex_descriptor add_vertex_recur_up(
        subgraph< G >& g)
    {
        typename subgraph< G >::vertex_descriptor u_local, u_global;
        if (g.is_root())
        {
            u_global = add_vertex(g.m_graph);
            g.m_global_vertex.push_back(u_global);
        }
        else
        {
            u_global = add_vertex_recur_up(*g.m_parent);
            u_local = add_vertex(g.m_graph);
            g.m_global_vertex.push_back(u_global);
            g.m_local_vertex[u_global] = u_local;
        }
        return u_global;
    }
} // namespace detail

template < typename G >
typename subgraph< G >::vertex_descriptor add_vertex(subgraph< G >& g)
{
    typename subgraph< G >::vertex_descriptor u_local, u_global;
    if (g.is_root())
    {
        u_global = add_vertex(g.m_graph);
        g.m_global_vertex.push_back(u_global);
        u_local = u_global;
    }
    else
    {
        u_global = detail::add_vertex_recur_up(g.parent());
        u_local = add_vertex(g.m_graph);
        g.m_global_vertex.push_back(u_global);
        g.m_local_vertex[u_global] = u_local;
    }
    return u_local;
}

#if 0
// TODO: Under Construction
template <typename G>
void remove_vertex(typename subgraph<G>::vertex_descriptor u, subgraph<G>& g)
{ BOOST_ASSERT(false); }
#endif

//===========================================================================
// Functions required by the PropertyGraph concept

/**
 * The global property map returns the global properties associated with local
 * descriptors.
 */
template < typename GraphPtr, typename PropertyMap, typename Tag >
class subgraph_global_property_map
: public put_get_helper< typename property_traits< PropertyMap >::reference,
      subgraph_global_property_map< GraphPtr, PropertyMap, Tag > >
{
    typedef property_traits< PropertyMap > Traits;

public:
    typedef typename mpl::if_<
        is_const< typename remove_pointer< GraphPtr >::type >,
        readable_property_map_tag, typename Traits::category >::type category;
    typedef typename Traits::value_type value_type;
    typedef typename Traits::key_type key_type;
    typedef typename Traits::reference reference;

    subgraph_global_property_map() {}

    subgraph_global_property_map(GraphPtr g, Tag tag) : m_g(g), m_tag(tag) {}

    reference operator[](key_type e) const
    {
        PropertyMap pmap = get(m_tag, m_g->root().m_graph);
        return m_g->is_root() ? pmap[e] : pmap[m_g->local_to_global(e)];
    }

    GraphPtr m_g;
    Tag m_tag;
};

/**
 * The local property map returns the local property associated with the local
 * descriptors.
 */
template < typename GraphPtr, typename PropertyMap, typename Tag >
class subgraph_local_property_map
: public put_get_helper< typename property_traits< PropertyMap >::reference,
      subgraph_local_property_map< GraphPtr, PropertyMap, Tag > >
{
    typedef property_traits< PropertyMap > Traits;

public:
    typedef typename mpl::if_<
        is_const< typename remove_pointer< GraphPtr >::type >,
        readable_property_map_tag, typename Traits::category >::type category;
    typedef typename Traits::value_type value_type;
    typedef typename Traits::key_type key_type;
    typedef typename Traits::reference reference;

    typedef Tag tag;
    typedef PropertyMap pmap;

    subgraph_local_property_map() {}

    subgraph_local_property_map(GraphPtr g, Tag tag) : m_g(g), m_tag(tag) {}

    reference operator[](key_type e) const
    {
        // Get property map on the underlying graph.
        PropertyMap pmap = get(m_tag, m_g->m_graph);
        return pmap[e];
    }

    GraphPtr m_g;
    Tag m_tag;
};

namespace detail
{
    // Extract the actual tags from local or global property maps so we don't
    // try to find non-properties.
    template < typename P > struct extract_lg_tag
    {
        typedef P type;
    };
    template < typename P > struct extract_lg_tag< local_property< P > >
    {
        typedef P type;
    };
    template < typename P > struct extract_lg_tag< global_property< P > >
    {
        typedef P type;
    };

    // NOTE: Mysterious Property template parameter unused in both metafunction
    // classes.
    struct subgraph_global_pmap
    {
        template < class Tag, class SubGraph, class Property > struct bind_
        {
            typedef typename SubGraph::graph_type Graph;
            typedef SubGraph* SubGraphPtr;
            typedef const SubGraph* const_SubGraphPtr;
            typedef typename extract_lg_tag< Tag >::type TagType;
            typedef typename property_map< Graph, TagType >::type PMap;
            typedef
                typename property_map< Graph, TagType >::const_type const_PMap;

        public:
            typedef subgraph_global_property_map< SubGraphPtr, PMap, TagType >
                type;
            typedef subgraph_global_property_map< const_SubGraphPtr, const_PMap,
                TagType >
                const_type;
        };
    };

    struct subgraph_local_pmap
    {
        template < class Tag, class SubGraph, class Property > struct bind_
        {
            typedef typename SubGraph::graph_type Graph;
            typedef SubGraph* SubGraphPtr;
            typedef const SubGraph* const_SubGraphPtr;
            typedef typename extract_lg_tag< Tag >::type TagType;
            typedef typename property_map< Graph, TagType >::type PMap;
            typedef
                typename property_map< Graph, TagType >::const_type const_PMap;

        public:
            typedef subgraph_local_property_map< SubGraphPtr, PMap, TagType >
                type;
            typedef subgraph_local_property_map< const_SubGraphPtr, const_PMap,
                TagType >
                const_type;
        };
    };

    // These metafunctions select the corresponding metafunctions above, and
    // are used by the choose_pmap metafunction below to specialize the choice
    // of local/global property map. By default, we defer to the global
    // property.
    template < class Tag > struct subgraph_choose_pmap_helper
    {
        typedef subgraph_global_pmap type;
    };
    template < class Tag >
    struct subgraph_choose_pmap_helper< local_property< Tag > >
    {
        typedef subgraph_local_pmap type;
    };
    template < class Tag >
    struct subgraph_choose_pmap_helper< global_property< Tag > >
    {
        typedef subgraph_global_pmap type;
    };

    // As above, unless we're requesting vertex_index_t. Then it's always a
    // local property map. This enables the correct translation of descriptors
    // between local and global layers.
    template <> struct subgraph_choose_pmap_helper< vertex_index_t >
    {
        typedef subgraph_local_pmap type;
    };
    template <>
    struct subgraph_choose_pmap_helper< local_property< vertex_index_t > >
    {
        typedef subgraph_local_pmap type;
    };
    template <>
    struct subgraph_choose_pmap_helper< global_property< vertex_index_t > >
    {
        typedef subgraph_local_pmap type;
    };

    // Determine the kind of property. If SameType<Tag, vertex_index_t>, then
    // the property lookup is always local. Otherwise, the lookup is global.
    // NOTE: Property parameter is basically unused.
    template < class Tag, class Graph, class Property >
    struct subgraph_choose_pmap
    {
        typedef typename subgraph_choose_pmap_helper< Tag >::type Helper;
        typedef typename Helper::template bind_< Tag, Graph, Property > Bind;
        typedef typename Bind::type type;
        typedef typename Bind::const_type const_type;
    };

    // Used by the vertex/edge property selectors to determine the kind(s) of
    // property maps used by the property_map type generator.
    struct subgraph_property_generator
    {
        template < class SubGraph, class Property, class Tag > struct bind_
        {
            typedef subgraph_choose_pmap< Tag, SubGraph, Property > Choice;
            typedef typename Choice::type type;
            typedef typename Choice::const_type const_type;
        };
    };

} // namespace detail

template <> struct vertex_property_selector< subgraph_tag >
{
    typedef detail::subgraph_property_generator type;
};

template <> struct edge_property_selector< subgraph_tag >
{
    typedef detail::subgraph_property_generator type;
};

// ==================================================
// get(p, g), get(p, g, k), and put(p, g, k, v)
// ==================================================
template < typename G, typename Property >
typename property_map< subgraph< G >, Property >::type get(
    Property p, subgraph< G >& g)
{
    typedef typename property_map< subgraph< G >, Property >::type PMap;
    return PMap(&g, p);
}

template < typename G, typename Property >
typename property_map< subgraph< G >, Property >::const_type get(
    Property p, const subgraph< G >& g)
{
    typedef typename property_map< subgraph< G >, Property >::const_type PMap;
    return PMap(&g, p);
}

template < typename G, typename Property, typename Key >
typename property_traits<
    typename property_map< subgraph< G >, Property >::const_type >::value_type
get(Property p, const subgraph< G >& g, const Key& k)
{
    typedef typename property_map< subgraph< G >, Property >::const_type PMap;
    PMap pmap(&g, p);
    return pmap[k];
}

template < typename G, typename Property, typename Key, typename Value >
void put(Property p, subgraph< G >& g, const Key& k, const Value& val)
{
    typedef typename property_map< subgraph< G >, Property >::type PMap;
    PMap pmap(&g, p);
    pmap[k] = val;
}

// ==================================================
// get(global(p), g)
// NOTE: get(global(p), g, k) and put(global(p), g, k, v) not supported
// ==================================================
template < typename G, typename Property >
typename property_map< subgraph< G >, global_property< Property > >::type get(
    global_property< Property > p, subgraph< G >& g)
{
    typedef typename property_map< subgraph< G >,
        global_property< Property > >::type Map;
    return Map(&g, p.value);
}

template < typename G, typename Property >
typename property_map< subgraph< G >, global_property< Property > >::const_type
get(global_property< Property > p, const subgraph< G >& g)
{
    typedef typename property_map< subgraph< G >,
        global_property< Property > >::const_type Map;
    return Map(&g, p.value);
}

// ==================================================
// get(local(p), g)
// NOTE: get(local(p), g, k) and put(local(p), g, k, v) not supported
// ==================================================
template < typename G, typename Property >
typename property_map< subgraph< G >, local_property< Property > >::type get(
    local_property< Property > p, subgraph< G >& g)
{
    typedef
        typename property_map< subgraph< G >, local_property< Property > >::type
            Map;
    return Map(&g, p.value);
}

template < typename G, typename Property >
typename property_map< subgraph< G >, local_property< Property > >::const_type
get(local_property< Property > p, const subgraph< G >& g)
{
    typedef typename property_map< subgraph< G >,
        local_property< Property > >::const_type Map;
    return Map(&g, p.value);
}

template < typename G, typename Tag >
inline typename graph_property< G, Tag >::type& get_property(
    subgraph< G >& g, Tag tag)
{
    return get_property(g.m_graph, tag);
}

template < typename G, typename Tag >
inline const typename graph_property< G, Tag >::type& get_property(
    const subgraph< G >& g, Tag tag)
{
    return get_property(g.m_graph, tag);
}

//===========================================================================
// Miscellaneous Functions

template < typename G >
typename subgraph< G >::vertex_descriptor vertex(
    typename subgraph< G >::vertices_size_type n, const subgraph< G >& g)
{
    return vertex(n, g.m_graph);
}

//===========================================================================
// Mutability Traits
// Just pull the mutability traits form the underlying graph. Note that this
// will probably fail (badly) for labeled graphs.
template < typename G > struct graph_mutability_traits< subgraph< G > >
{
    typedef typename graph_mutability_traits< G >::category category;
};

} // namespace boost

#endif // BOOST_SUBGRAPH_HPP