class AsyncTaskTree

Requests that all task information be updated. Automatically requests the full stack if it

isn't already present.

Provides a new set of root tasks.

Removes all tasks.

Performs a depth-first iteration of all tasks in the tree, calling |fn| on each entry.

Returns whether or not the task tree is non-empty. If this method returns true it means the

traversal methods below will work without calling |Sync| first. This is primarily an

optimization for callers to use to avoid calling |Sync| repeatedly on a task tree that has

already been cached.

Transforms the tree of AsyncTasks into a tree of arbitrary Node types.

This method uses an iterative, stack-based approach to traverse the tree,

avoiding potential stack overflow issues that can occur with recursive

traversal of deeply nested task structures. Prefer using this or ForEach

when possible.

Parameters:

populate_fn: A callable with signature `void(const AsyncTask

&

task, Node*

node)`. It is responsible for copying data from the `task`

into the `node`.

children_fn: A callable with signature `std::vector

<Node

>*(Node* node)`.

It must return a pointer to a `std::vector` that holds the

children of the given `node`. This allows the Map function

to resize the container and push child nodes onto its

processing stack.

Example:

```cpp

struct MyNode {

std::string name;

std::vector

<MyNode

> children;

};

std::vector

<MyNode

> result = tree.Map

<MyNode

>(

[](const zxdb::AsyncTask

&

task, MyNode* node) {

node->name = task.GetIdentifier().GetFullName();

},

[](MyNode* node) {

return

&node

->children;

});

```