:

#else

typedef

#endif

adjacency_list<vecS,vecS, bidirectionalS, no_property

// edge index property allows us to look up edges in the connectivity matrix

, property<edge_index_t,std::size_t

// The function which casts a void* from the edge's source type

// to its destination type.

, property<edge_cast_t,cast_function> > >

#if 0

{

typedef std::vector<std::size_t>::const_iterator node_distance_map;

typedef std::pair<cast_graph::out_edge_iterator

, cast_graph::out_edge_iterator> out_edges_t;

// Return a map of the distances from any node to the given

// target node

node_distance_map distances_to(vertex_t target) const

{

std::size_t n = num_vertices(m_topology);

if (m_distances.size() != n * n)

{

m_distances.clear();

m_distances.resize(n * n, (std::numeric_limits<std::size_t>::max)());

m_known_vertices = n;

}

std::vector<std::size_t>::iterator to_target = m_distances.begin() + n * target;

// this node hasn't been used as a target yet

if (to_target[target] != 0)

{

typedef reverse_graph<cast_graph> reverse_cast_graph;

reverse_cast_graph reverse_topology(m_topology);

to_target[target] = 0;

breadth_first_search(

reverse_topology, target

, visitor(

make_bfs_visitor(

record_distances(

make_iterator_property_map(

to_target

, get(vertex_index, reverse_topology)

# ifdef BOOST_NO_STD_ITERATOR_TRAITS

, *to_target

# endif

)

, on_tree_edge()

))));

}

return to_target;

}

cast_graph& topology() { return m_topology; }

cast_graph const& topology() const { return m_topology; }

smart_graph()

: m_known_vertices(0)

{}

private:

cast_graph m_topology;

mutable std::vector<std::size_t> m_distances;

mutable std::size_t m_known_vertices;

{

typedef typename tuples::element<0, Tuple>::type result_type;

result_type const& operator()(Tuple const& x) const

{

return tuples::get<0>(x);

}

{

typedef index_entry entry;

return std::lower_bound(

type_index().begin(), type_index().end()

, boost::make_tuple(type, vertex_t(), dynamic_id_function(0))

, boost::bind<bool>(std::less<class_id>()

, boost::bind<class_id>(select1st<entry>(), _1)

, boost::bind<class_id>(select1st<entry>(), _2)));

{

type_index_t::iterator p = type_position(type);

if (p != type_index().end() && tuples::get<ksrc_static_t>(*p) == type)

return p;

vertex_t v = add_vertex(full_graph().topology());

vertex_t v2 = add_vertex(up_graph().topology());

unused_variable(v2);

assert(v == v2);

return type_index().insert(p, boost::make_tuple(type, v, dynamic_id_function(0)));

{

// be sure there will be no reallocation

type_index().reserve(type_index().size() + 2);

type_index_t::iterator first = demand_type(t1);

type_index_t::iterator second = demand_type(t2);

if (first == second)

++first;

return std::make_pair(first, second);

{

q_elt(std::size_t distance

, void* src_address

, vertex_t target

, cast_function cast

)

: distance(distance)

, src_address(src_address)

, target(target)

, cast(cast)

{}

std::size_t distance;

void* src_address;

vertex_t target;

cast_function cast;

bool operator<(q_elt const& rhs) const

{

return distance < rhs.distance;

}

{

typedef tuples::tuple<

class_id // source static type

, class_id // target type

, std::ptrdiff_t // offset within source object

, class_id // source dynamic type

>::inherited key_type;

cache_element(key_type const& k)

: key(k)

, offset(0)

{}

key_type key;

std::ptrdiff_t offset;

BOOST_STATIC_CONSTANT(

std::ptrdiff_t, not_found = integer_traits<std::ptrdiff_t>::const_min);

bool operator<(cache_element const& rhs) const

{

return this->key < rhs.key;

}

bool unreachable() const

{

return offset == not_found;

}

class_id src_t, class_id dst_t, cast_function cast, bool is_downcast)

{

// adding an edge will invalidate any record of unreachability in

// the cache.

static std::size_t expected_cache_len = 0;

cache_t& c = cache();

if (c.size() > expected_cache_len)

{

c.erase(std::remove_if(

c.begin(), c.end(),

mem_fn(&cache_element::unreachable))

, c.end());

// If any new cache entries get added, we'll have to do this

// again when the next edge is added

expected_cache_len = c.size();

}

type_index_iterator_pair types = demand_types(src_t, dst_t);

vertex_t src = tuples::get<kvertex>(*types.first);

vertex_t dst = tuples::get<kvertex>(*types.second);

cast_graph* const g[2] = { &up_graph().topology(), &full_graph().topology() };

for (cast_graph*const* p = g + (is_downcast ? 1 : 0); p < g + 2; ++p)

{

edge_t e;

bool added;

tie(e, added) = add_edge(src, dst, **p);

assert(added);

put(get(edge_cast, **p), e, cast);

put(get(edge_index, **p), e, num_edges(full_graph().topology()) - 1);

}

class_id static_id, dynamic_id_function get_dynamic_id)

{

tuples::get<kdynamic_id>(*demand_type(static_id)) = get_dynamic_id;