Andrew Sutton-2 wrote:

...

I'm wondering if the documentation is incorrect. Perhaps it is just imprecise, and removing any edge from the source vertex of an adjacency_iterator invalidates that iterator?

Anyone with additional insight would be very helpful.

That behavior should actually be correct since an adjacency iterator is just a wrapper around an out edge iterator. I haven't looked at the documentation on adjacency iterator invalidation, so it the docs may be incorrect.

That makes things a bit clearer. However, in the code I provided, I'm incrementing the adjacency_iterator prior to deleting the out edge to which it corresponds. My assumption was that (when using listS) deletion of an out edge would invalidate an out_edge iterator or an edge descriptor if and only if the iterator or descriptor were pointing to the deleted element at the time of its deletion. It seems, however, that deletion of any out edge invalidates the iterator. Is that truly the case, or have I made a mistake? If it is the case, can anyone explain why that limitation is required? -- View this message in context: http://old.nabble.com/-BGL--adjacency_iterator-invalidation-with-adjacency_l... Sent from the Boost - Users mailing list archive at Nabble.com.

In keeping with your comments, I have tried with both out edge iterators and adjacency iterators in the below simplified examples. Both indeed exhibit the same behavior, but they seem to invalidate the iterators, when (according to the documentation) the iterators should remain valid. There must be a good technical reason why these iterators are invalidated. If anyone can explain that to me, I would greatly appreciate it. In any event, if someone else can confirm this, I think the documentation should be changed.

I think the problem comes from the graph being undirected, which can cause some interesting problems. The graph actually doubles up on out edges so that a single undirected edge is actually two distinct edges that are stored in the out edge list of each vertex-- one (u, v) the other (v, u). Each of these out edges refers to the same edge stored on the graph (via a ptr or something like that). Basically, its giving the impression that its undirected, but it's not really. When you clear a vertex, you're removing all of the corresponding edges from each adjacent vertex and the "globally" stored edge. What happens, when you see the failures, is that you're actually removing a reciprical edge out from underneath the avinext or oeinext iterator, invalidating it. Basically, you can probably assume that clear_vertex will invalidate any iterators referring to the vertex being cleared for an undirected graph. Andrew Sutton andrew.n.sutton@gmail.com