From 8306d6917c7a4598ab996a514e4055e50a231626 Mon Sep 17 00:00:00 2001 From: Arnaud Becheler <8360330+Becheler@users.noreply.github.com> Date: Wed, 24 Jun 2026 12:31:23 +0200 Subject: [PATCH 1/8] fix: restructure predecessor recorder page to match old html style --- .../pages/visitors/predecessor_recorder.adoc | 93 +++++++++++++------ 1 file changed, 67 insertions(+), 26 deletions(-) diff --git a/doc/modules/ROOT/pages/visitors/predecessor_recorder.adoc b/doc/modules/ROOT/pages/visitors/predecessor_recorder.adoc index 51190ac42..25bce416f 100644 --- a/doc/modules/ROOT/pages/visitors/predecessor_recorder.adoc +++ b/doc/modules/ROOT/pages/visitors/predecessor_recorder.adoc @@ -1,54 +1,95 @@ = predecessor_recorder -Records the predecessor (parent) vertex for each vertex in a property map. +Records the predecessor (parent) vertex of each vertex in a property map. This is +an efficient way to encode the search tree traversed during a graph search. *Defined in:* `` + -*Models:* EventVisitor + -*Typical event:* `on_tree_edge` or `on_relax_edge` (edge events only) +*Models:* xref:visitors/EventVisitor.adoc[EventVisitor] + +*Typical event:* `on_tree_edge` or `on_relax_edge` (edge events only; cannot be +used with vertex events) -== Example - -[source,cpp] ----- -include::example$visitors/predecessor_recorder.cpp[] ----- - -[,text] ----- -include::example$visitors/predecessor_recorder.txt[] ----- - -TIP: Initialize the source vertex's predecessor to itself before running the -algorithm. This marks the root of the search tree as the only vertex that is -its own parent. For DFS (which creates a forest), initialize every vertex to -itself. +To use it, wrap it in an algorithm adaptor and optionally combine it with other +event visitors; see the xref:visitors/overview.adoc[visitors overview]. == Synopsis [source,cpp] ---- template -struct predecessor_recorder; +struct predecessor_recorder { + typedef EventTag event_filter; + predecessor_recorder(PredecessorMap pa); + + template + void operator()(Edge e, const Graph& g); +}; template predecessor_recorder record_predecessors(PredecessorMap pa, EventTag); ---- -== Parameters +== Template Parameters [cols="1,3",options="header"] |=== | Parameter | Description | `PredecessorMap` -| WritablePropertyMap. Key type and value type are both the vertex descriptor. +| A WritablePropertyMap whose key and value types are both the graph's vertex + descriptor. | `EventTag` -| Must be an edge event tag (e.g. `on_tree_edge`, `on_relax_edge`). +| The event at which to record. Must be an edge event (e.g. `on_tree_edge`, + `on_relax_edge`). +|=== + +== Associated Types + +[cols="1,3",options="header"] |=== +| Type | Description -== Behavior +| `event_filter` +| The event tag the visitor responds to. Same type as `EventTag`. +|=== + +== Member Functions + +[cols="1,3",options="header"] +|=== +| Member | Description -Given edge `e = (u, v)`, records `u` as the predecessor of `v`: -`put(predecessor_map, v, u)`. +| `predecessor_recorder(PredecessorMap pa)` +| Constructs a recorder writing predecessors into the property map `pa`. + +| `void operator()(Edge e, const Graph& g)` +| Given edge `e = (u, v)`, records `u` as the predecessor of `v`: `put(pa, v, u)`. +|=== + +== Non-Member Functions + +[cols="1,3",options="header"] +|=== +| Function | Description + +| `record_predecessors(PredecessorMap pa, EventTag)` +| Convenience factory that creates a `predecessor_recorder`. +|=== + +TIP: Algorithms such as Dijkstra and BFS do not assign a predecessor to the source +vertex (the root of the search tree). Initialize the source's predecessor to itself +to mark it as the only vertex that is its own parent. For DFS (which builds a +forest), initialize every vertex to itself so all roots can be distinguished. + +== Example + +[source,cpp] +---- +include::example$visitors/predecessor_recorder.cpp[] +---- + +[,text] +---- +include::example$visitors/predecessor_recorder.txt[] +---- From 42dedb70dcb91fd9f1fe68177060cc9372e84e16 Mon Sep 17 00:00:00 2001 From: Arnaud Becheler <8360330+Becheler@users.noreply.github.com> Date: Wed, 24 Jun 2026 13:16:25 +0200 Subject: [PATCH 2/8] fix: restructure edge predecessor recorder page to match old html style --- .../visitors/edge_predecessor_recorder.adoc | 98 +++++++++++++------ 1 file changed, 70 insertions(+), 28 deletions(-) diff --git a/doc/modules/ROOT/pages/visitors/edge_predecessor_recorder.adoc b/doc/modules/ROOT/pages/visitors/edge_predecessor_recorder.adoc index 688b065bd..6458c95c0 100644 --- a/doc/modules/ROOT/pages/visitors/edge_predecessor_recorder.adoc +++ b/doc/modules/ROOT/pages/visitors/edge_predecessor_recorder.adoc @@ -1,57 +1,99 @@ = edge_predecessor_recorder -Records the predecessor _edge_ (not vertex) for each vertex. Useful when a -graph has parallel edges and you need to know which specific edge the search -used to reach a vertex. +Records the predecessor _edge_ of each vertex in a property map, an efficient way +to encode the search tree traversed during a graph search. Use this instead of +xref:visitors/predecessor_recorder.adoc[`predecessor_recorder`] (which records the +predecessor vertex) when a graph has parallel edges and you need to know which +specific edge the search used to reach a vertex. *Defined in:* `` + -*Models:* EventVisitor + -*Typical event:* `on_tree_edge` or `on_relax_edge` (edge events only) +*Models:* xref:visitors/EventVisitor.adoc[EventVisitor] + +*Typical event:* `on_tree_edge` or `on_relax_edge` (edge events only; cannot be +used with vertex events) -== Example - -[source,cpp] ----- -include::example$visitors/edge_predecessor_recorder.cpp[] ----- - -[,text] ----- -include::example$visitors/edge_predecessor_recorder.txt[] ----- +To use it, wrap it in an algorithm adaptor and optionally combine it with other +event visitors; see the xref:visitors/overview.adoc[visitors overview]. == Synopsis [source,cpp] ---- template -struct edge_predecessor_recorder; +struct edge_predecessor_recorder { + typedef EventTag event_filter; + edge_predecessor_recorder(PredEdgeMap pa); + + template + void operator()(Edge e, const Graph& g); +}; template edge_predecessor_recorder record_edge_predecessors(PredEdgeMap pa, EventTag); ---- -== Parameters +== Template Parameters [cols="1,3",options="header"] |=== | Parameter | Description | `PredEdgeMap` -| WritablePropertyMap. Key type is vertex descriptor, value type is edge - descriptor. +| A WritablePropertyMap whose key type is the graph's vertex descriptor and whose + value type is the graph's edge descriptor. | `EventTag` -| Must be an edge event tag (e.g. `on_tree_edge`, `on_relax_edge`). +| The event at which to record. Must be an edge event (e.g. `on_tree_edge`, + `on_relax_edge`). +|=== + +== Associated Types + +[cols="1,3",options="header"] |=== +| Type | Description -== Behavior +| `event_filter` +| The event tag the visitor responds to. Same type as `EventTag`. +|=== + +== Member Functions + +[cols="1,3",options="header"] +|=== +| Member | Description -Given edge `e = (u, v)`, records `e` as the predecessor edge of `v`: -`put(pred_edge_map, v, e)`. +| `edge_predecessor_recorder(PredEdgeMap pa)` +| Constructs a recorder writing predecessor edges into the property map `pa`. -TIP: The source vertex (root of the search tree) will not have a predecessor -edge assigned. Initialize it to a sentinel value before running the algorithm. -For DFS (which creates a forest), do the same for every vertex so that all -roots can be identified. +| `void operator()(Edge e, const Graph& g)` +| Given edge `e = (u, v)`, records `e` as the predecessor edge of `v`: + `put(pa, v, e)`. +|=== + +== Non-Member Functions + +[cols="1,3",options="header"] +|=== +| Function | Description + +| `record_edge_predecessors(PredEdgeMap pa, EventTag)` +| Convenience factory that creates an `edge_predecessor_recorder`. +|=== + +TIP: The source vertex (the root of the search tree) is not assigned a predecessor +edge. Initialize it to a sentinel value before running the algorithm to identify +the root. For DFS (which builds a forest), do the same for every vertex so all +roots can be distinguished. + +== Example + +[source,cpp] +---- +include::example$visitors/edge_predecessor_recorder.cpp[] +---- + +[,text] +---- +include::example$visitors/edge_predecessor_recorder.txt[] +---- From b1c09b7c9838570ac4f987ce0fbb82ca9dba086b Mon Sep 17 00:00:00 2001 From: Arnaud Becheler <8360330+Becheler@users.noreply.github.com> Date: Wed, 24 Jun 2026 13:40:53 +0200 Subject: [PATCH 3/8] fix: restructure distance recorder page to match old html style --- .../pages/visitors/distance_recorder.adoc | 85 ++++++++++++++----- 1 file changed, 64 insertions(+), 21 deletions(-) diff --git a/doc/modules/ROOT/pages/visitors/distance_recorder.adoc b/doc/modules/ROOT/pages/visitors/distance_recorder.adoc index c8bf608ab..03f117448 100644 --- a/doc/modules/ROOT/pages/visitors/distance_recorder.adoc +++ b/doc/modules/ROOT/pages/visitors/distance_recorder.adoc @@ -1,49 +1,92 @@ = distance_recorder -Records the hop distance of each vertex from the source during a graph search. +Records the distance of each vertex from the source vertex into a property map. +When applied to edge `e = (u, v)`, the distance of `v` is recorded as one more +than the distance of `u`. *Defined in:* `` + -*Models:* EventVisitor + -*Typical event:* `on_tree_edge` (edge events only) +*Models:* xref:visitors/EventVisitor.adoc[EventVisitor] + +*Typical event:* `on_tree_edge` or `on_relax_edge` (edge events only; cannot be +used with vertex events) -== Example - -[source,cpp] ----- -include::example$visitors/distance_recorder.cpp[] ----- - -[,text] ----- -include::example$visitors/distance_recorder.txt[] ----- +To use it, wrap it in an algorithm adaptor and optionally combine it with other +event visitors; see the xref:visitors/overview.adoc[visitors overview]. == Synopsis [source,cpp] ---- template -struct distance_recorder; +struct distance_recorder { + typedef EventTag event_filter; + distance_recorder(DistanceMap pa); + + template + void operator()(Edge e, const Graph& g); +}; template distance_recorder record_distances(DistanceMap pa, EventTag); ---- -== Parameters +== Template Parameters [cols="1,3",options="header"] |=== | Parameter | Description | `DistanceMap` -| WritablePropertyMap. Key type is vertex descriptor. +| A WritablePropertyMap whose key type is the graph's vertex descriptor and whose + value type is the distance (a numeric type that supports adding one). | `EventTag` -| Must be an edge event tag (e.g. `on_tree_edge`). +| The event at which to record. Must be an edge event (e.g. `on_tree_edge`, + `on_relax_edge`). +|=== + +== Associated Types + +[cols="1,3",options="header"] |=== +| Type | Description -== Behavior +| `event_filter` +| The event tag the visitor responds to. Same type as `EventTag`. +|=== + +== Member Functions + +[cols="1,3",options="header"] +|=== +| Member | Description -Given edge `e = (u, v)`, sets the distance of `v` to one plus the distance -of `u`: `put(dist_map, v, get(dist_map, u) + 1)`. +| `distance_recorder(DistanceMap pa)` +| Constructs a recorder writing distances into the property map `pa`. + +| `void operator()(Edge e, const Graph& g)` +| Given edge `e = (u, v)`, records the distance of `v` as one more than the + distance of `u`: `put(pa, v, get(pa, u) + 1)`. +|=== + +== Non-Member Functions + +[cols="1,3",options="header"] +|=== +| Function | Description + +| `record_distances(DistanceMap pa, EventTag)` +| Convenience factory that creates a `distance_recorder`. +|=== + +== Example + +[source,cpp] +---- +include::example$visitors/distance_recorder.cpp[] +---- + +[,text] +---- +include::example$visitors/distance_recorder.txt[] +---- From da9891445f90d521e26e4d9dccc4a7b2f3197957 Mon Sep 17 00:00:00 2001 From: Arnaud Becheler <8360330+Becheler@users.noreply.github.com> Date: Wed, 24 Jun 2026 13:44:33 +0200 Subject: [PATCH 4/8] fix: restructure time stamper page to match old html style --- .../ROOT/pages/visitors/time_stamper.adoc | 88 ++++++++++++++----- 1 file changed, 66 insertions(+), 22 deletions(-) diff --git a/doc/modules/ROOT/pages/visitors/time_stamper.adoc b/doc/modules/ROOT/pages/visitors/time_stamper.adoc index b0b953455..3da398bb2 100644 --- a/doc/modules/ROOT/pages/visitors/time_stamper.adoc +++ b/doc/modules/ROOT/pages/visitors/time_stamper.adoc @@ -1,52 +1,96 @@ = time_stamper -Stamps a monotonically increasing time value when an event occurs. Commonly -used to record discover and finish times during DFS. +Stamps a monotonically increasing time value onto a vertex or edge when an event +occurs. Commonly used to record the discover and finish times of vertices during +a graph search. *Defined in:* `` + -*Models:* EventVisitor + -*Typical event:* `on_discover_vertex`, `on_finish_vertex` +*Models:* xref:visitors/EventVisitor.adoc[EventVisitor] + +*Typical event:* any (vertex or edge), e.g. `on_discover_vertex`, +`on_finish_vertex` -== Example - -[source,cpp] ----- -include::example$visitors/time_stamper.cpp[] ----- - -[,text] ----- -include::example$visitors/time_stamper.txt[] ----- +To use it, wrap it in an algorithm adaptor and optionally combine it with other +event visitors; see the xref:visitors/overview.adoc[visitors overview]. == Synopsis [source,cpp] ---- template -struct time_stamper; +struct time_stamper { + typedef EventTag event_filter; + time_stamper(TimeMap pa, TimeT& t); + + template + void operator()(X x, const Graph& g); +}; template time_stamper stamp_times(TimeMap pa, TimeT& t, EventTag); ---- -== Parameters +== Template Parameters [cols="1,3",options="header"] |=== | Parameter | Description | `TimeMap` -| WritablePropertyMap. Key type is the vertex or edge descriptor. +| A WritablePropertyMap whose key type is the graph's vertex or edge descriptor + (depending on the event tag), and whose value type accepts the time counter. | `TimeT` -| The time counter type. Passed by reference; incremented on each event. +| The time-counter type. Passed by reference and incremented on each event, so a + single counter can be shared across several `time_stamper` objects. | `EventTag` -| Any event tag (vertex or edge). +| The event at which to stamp the time. May be any event, vertex or edge. +|=== + +== Associated Types + +[cols="1,3",options="header"] |=== +| Type | Description -== Behavior +| `event_filter` +| The event tag the visitor responds to. Same type as `EventTag`. +|=== + +== Member Functions + +[cols="1,3",options="header"] +|=== +| Member | Description -Increments the counter and stamps the time: `put(time_map, x, ++t)`. +| `time_stamper(TimeMap pa, TimeT& t)` +| Constructs a time stamper writing into the property map `pa` and using the + shared counter `t`. + +| `void operator()(X x, const Graph& g)` +| Increments the counter and stamps the new value onto `x` (a vertex or edge): + `put(pa, x, ++t)`. +|=== + +== Non-Member Functions + +[cols="1,3",options="header"] +|=== +| Function | Description + +| `stamp_times(TimeMap pa, TimeT& t, EventTag)` +| Convenience factory that creates a `time_stamper`. +|=== + +== Example + +[source,cpp] +---- +include::example$visitors/time_stamper.cpp[] +---- + +[,text] +---- +include::example$visitors/time_stamper.txt[] +---- From c9ff9d496a31395dd26104248db10c245ed54052 Mon Sep 17 00:00:00 2001 From: Arnaud Becheler <8360330+Becheler@users.noreply.github.com> Date: Wed, 24 Jun 2026 13:47:37 +0200 Subject: [PATCH 5/8] fix: restructure property writer page to match old html style --- .../ROOT/pages/visitors/property_writer.adoc | 86 ++++++++++++++----- 1 file changed, 64 insertions(+), 22 deletions(-) diff --git a/doc/modules/ROOT/pages/visitors/property_writer.adoc b/doc/modules/ROOT/pages/visitors/property_writer.adoc index e992f943b..2b85ff0cd 100644 --- a/doc/modules/ROOT/pages/visitors/property_writer.adoc +++ b/doc/modules/ROOT/pages/visitors/property_writer.adoc @@ -1,52 +1,94 @@ = property_writer -Writes the property value of a vertex or edge to an output iterator when an -event occurs. Useful for debugging or logging during graph traversal. +Writes the property value of a vertex or edge to an output iterator when an event +occurs. Useful for debugging or logging during a graph traversal. *Defined in:* `` + -*Models:* EventVisitor + -*Typical event:* `on_discover_vertex`, `on_examine_edge` +*Models:* xref:visitors/EventVisitor.adoc[EventVisitor] + +*Typical event:* any (vertex or edge), e.g. `on_discover_vertex`, +`on_examine_edge` -== Example - -[source,cpp] ----- -include::example$visitors/property_writer.cpp[] ----- - -[,text] ----- -include::example$visitors/property_writer.txt[] ----- +To use it, wrap it in an algorithm adaptor and optionally combine it with other +event visitors; see the xref:visitors/overview.adoc[visitors overview]. == Synopsis [source,cpp] ---- template -struct property_writer; +struct property_writer { + typedef EventTag event_filter; + property_writer(PropertyMap pa, OutputIterator out); + + template + void operator()(T x, Graph& g); +}; template property_writer write_property(PropertyMap pa, OutputIterator out, EventTag); ---- -== Parameters +== Template Parameters [cols="1,3",options="header"] |=== | Parameter | Description | `PropertyMap` -| ReadablePropertyMap. Key type is vertex or edge descriptor. +| A ReadablePropertyMap whose key type is the graph's vertex or edge descriptor + (depending on the event tag), and whose value type is writable to the output + iterator. | `OutputIterator` -| Output iterator. The property's value type must be writable to it. +| The output iterator the property values are written to. | `EventTag` -| Any event tag (vertex or edge). +| The event at which to write. May be any event, vertex or edge. +|=== + +== Associated Types + +[cols="1,3",options="header"] |=== +| Type | Description -== Behavior +| `event_filter` +| The event tag the visitor responds to. Same type as `EventTag`. +|=== + +== Member Functions + +[cols="1,3",options="header"] +|=== +| Member | Description -Writes the property value to the output iterator: `*out++ = get(pa, x)`. +| `property_writer(PropertyMap pa, OutputIterator out)` +| Constructs a writer reading from the property map `pa` and writing to `out`. + +| `void operator()(T x, Graph& g)` +| Reads the property of `x` (a vertex or edge) and writes it to the output + iterator: `*out++ = get(pa, x)`. +|=== + +== Non-Member Functions + +[cols="1,3",options="header"] +|=== +| Function | Description + +| `write_property(PropertyMap pa, OutputIterator out, EventTag)` +| Convenience factory that creates a `property_writer`. +|=== + +== Example + +[source,cpp] +---- +include::example$visitors/property_writer.cpp[] +---- + +[,text] +---- +include::example$visitors/property_writer.txt[] +---- From 3109027d8866eb0b1096add7d7c5327cce42bfcf Mon Sep 17 00:00:00 2001 From: Arnaud Becheler <8360330+Becheler@users.noreply.github.com> Date: Wed, 24 Jun 2026 13:50:12 +0200 Subject: [PATCH 6/8] fix: restructure property put page to match old html style --- .../ROOT/pages/visitors/property_put.adoc | 87 ++++++++++++++----- 1 file changed, 65 insertions(+), 22 deletions(-) diff --git a/doc/modules/ROOT/pages/visitors/property_put.adoc b/doc/modules/ROOT/pages/visitors/property_put.adoc index aef0991fe..280d704e6 100644 --- a/doc/modules/ROOT/pages/visitors/property_put.adoc +++ b/doc/modules/ROOT/pages/visitors/property_put.adoc @@ -1,51 +1,94 @@ = property_put -Assigns a fixed constant value to a property map entry when an event occurs. -Useful for initialization or for marking specific edges (e.g. back edges). +Writes a fixed value to a property map when a vertex or edge is visited at an +event point. Useful as an alternative to an explicit loop for initializing a +property map, or to mark a subset of vertices or edges (for example, only back +edges) during a search. *Defined in:* `` + -*Models:* EventVisitor + -*Typical event:* any +*Models:* xref:visitors/EventVisitor.adoc[EventVisitor] + +*Typical event:* any (vertex or edge) -== Example - -[source,cpp] ----- -include::example$visitors/property_put.cpp[] ----- - -[,text] ----- -include::example$visitors/property_put.txt[] ----- +To use it, wrap it in an algorithm adaptor and optionally combine it with other +event visitors; see the xref:visitors/overview.adoc[visitors overview]. == Synopsis [source,cpp] ---- template -struct property_put; +struct property_put { + typedef EventTag event_filter; + property_put(PropertyMap pa, + typename property_traits::value_type value); + + template + void operator()(VertexOrEdge x, const Graph& g); +}; template property_put put_property(PropertyMap pa, - typename property_traits::value_type val, + typename property_traits::value_type value, EventTag); ---- -== Parameters +== Template Parameters [cols="1,3",options="header"] |=== | Parameter | Description | `PropertyMap` -| WritablePropertyMap. Key type is vertex or edge descriptor. +| A WritablePropertyMap whose key type is the graph's vertex or edge descriptor + (depending on the event tag). | `EventTag` -| Any event tag (vertex or edge). +| The event at which to write. May be any event, vertex or edge. +|=== + +== Associated Types + +[cols="1,3",options="header"] |=== +| Type | Description -== Behavior +| `event_filter` +| The event tag the visitor responds to. Same type as `EventTag`. +|=== + +== Member Functions + +[cols="1,3",options="header"] +|=== +| Member | Description -Writes the fixed value to the property map: `put(pa, x, val)`. +| `property_put(PropertyMap pa, value_type value)` +| Constructs a visitor that writes the fixed `value` into the property map `pa`. + +| `void operator()(VertexOrEdge x, const Graph& g)` +| Writes the fixed value into the property map for `x` (a vertex or edge): + `put(pa, x, value)`. +|=== + +== Non-Member Functions + +[cols="1,3",options="header"] +|=== +| Function | Description + +| `put_property(PropertyMap pa, value_type value, EventTag)` +| Convenience factory that creates a `property_put`. +|=== + +== Example + +[source,cpp] +---- +include::example$visitors/property_put.cpp[] +---- + +[,text] +---- +include::example$visitors/property_put.txt[] +---- From 108c02bbe3f0db387fad985fcb97d08c9a899579 Mon Sep 17 00:00:00 2001 From: Arnaud Becheler <8360330+Becheler@users.noreply.github.com> Date: Wed, 24 Jun 2026 13:54:36 +0200 Subject: [PATCH 7/8] fix: restructure null visitor page to match old html style --- .../ROOT/pages/visitors/null_visitor.adoc | 33 +++++++++++++++---- 1 file changed, 27 insertions(+), 6 deletions(-) diff --git a/doc/modules/ROOT/pages/visitors/null_visitor.adoc b/doc/modules/ROOT/pages/visitors/null_visitor.adoc index a70156a0b..80afd6833 100644 --- a/doc/modules/ROOT/pages/visitors/null_visitor.adoc +++ b/doc/modules/ROOT/pages/visitors/null_visitor.adoc @@ -1,19 +1,40 @@ = null_visitor -A no-op event visitor that does nothing. Used as a placeholder or default when -combining event visitors and one slot is not needed. +A no-op event visitor that does nothing. Useful as a placeholder or default when +an algorithm requires a visitor but no action is needed, or to fill an unused slot +when combining event visitors. *Defined in:* `` + -*Models:* EventVisitor +*Models:* xref:visitors/EventVisitor.adoc[EventVisitor] == Synopsis [source,cpp] ---- struct null_visitor { - using event_filter = void; + typedef on_no_event event_filter; - template - void operator()(X, const Graph&) {} + template + void operator()(T x, Graph& g); }; ---- + +== Associated Types + +[cols="1,3",options="header"] +|=== +| Type | Description + +| `event_filter` +| `on_no_event`. The visitor is not associated with any algorithm event. +|=== + +== Member Functions + +[cols="1,3",options="header"] +|=== +| Member | Description + +| `void operator()(T x, Graph& g)` +| Does nothing. +|=== From 3898362db3668f7727f61053cd354e439020ba13 Mon Sep 17 00:00:00 2001 From: Arnaud Becheler <8360330+Becheler@users.noreply.github.com> Date: Wed, 24 Jun 2026 14:05:24 +0200 Subject: [PATCH 8/8] doc: reorder pre-built visitor nav and group algo-specific ones --- doc/modules/ROOT/nav.adoc | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/doc/modules/ROOT/nav.adoc b/doc/modules/ROOT/nav.adoc index 6101a8711..ab05a9feb 100644 --- a/doc/modules/ROOT/nav.adoc +++ b/doc/modules/ROOT/nav.adoc @@ -11,13 +11,14 @@ ** xref:property_maps/pitfalls.adoc[Common Mistakes] * xref:visitors/overview.adoc[Visitors] ** Pre-built Event Visitors -*** xref:visitors/predecessor_recorder.adoc[Predecessor Recorder] +*** xref:visitors/predecessor_recorder.adoc[Vertex Predecessor Recorder] +*** xref:visitors/edge_predecessor_recorder.adoc[Edge Predecessor Recorder] *** xref:visitors/distance_recorder.adoc[Distance Recorder] -*** xref:visitors/time_stamper.adoc[Time Stamper] *** xref:visitors/property_put.adoc[Property Put] *** xref:visitors/property_writer.adoc[Property Writer] -*** xref:visitors/edge_predecessor_recorder.adoc[Edge Predecessor Recorder] +*** xref:visitors/time_stamper.adoc[Time Stamper] *** xref:visitors/null_visitor.adoc[Null Visitor] +** Algorithm-specific visitors *** xref:visitors/tsp_tour_visitor.adoc[TSP Tour Visitor] *** xref:visitors/tsp_tour_len_visitor.adoc[TSP Tour Len Visitor] *** xref:visitors/astar_heuristic.adoc[A* Heuristic (Zero)]