llfio_v2_xxx::algorithm::traverse_visitor Struct Reference

A visitor for the filesystem traversal algorithm. More...

#include "traverse.hpp"

Inheritance diagram for llfio_v2_xxx::algorithm::traverse_visitor:

Public Member Functions
virtual result< directory_handle >	directory_open_failed (void *data, result< void >::error_type &&error, const directory_handle &dirh, path_view leaf, size_t depth) noexcept
	Called when we failed to open a directory for enumeration. The default fails the traversal with that error. Return a default constructed instance to ignore the failure. More...
virtual result< bool >	pre_enumeration (void *data, const directory_handle &dirh, size_t depth) noexcept
	Called to decide whether to enumerate a directory. More...
virtual result< void >	post_enumeration (void *data, const directory_handle &dirh, directory_handle::buffers_type &contents, size_t depth) noexcept
	Called just after each directory enumeration. You can modify the results to affect the traversal, typically you would set the stat to default constructed to cause it to be ignored. You are guaranteed that at least stat.st_type is valid for every entry in contents, and items whose type is a directory will be enqueued after this call for later traversal. More...
virtual result< void >	stack_updated (void *data, size_t dirs_processed, size_t known_dirs_remaining, size_t depth_processed, size_t known_depth_remaining) noexcept
	Called whenever the traversed stack of directory hierarchy is updated. This can act as an estimated progress indicator, or to give an accurate progress indicator by matching it against a previous traversal. More...
virtual result< size_t >	finished (void *data, result< size_t > result) noexcept
	Called when a traversal finishes, whether due to success or failure. Always called from the original thread.

Detailed Description

A visitor for the filesystem traversal algorithm.

Note that at any time, returning a failure causes traverse() to exit as soon as possible with the same failure. Depth is how deep into the directory hierarchy we are, with zero being the base path handle being traversed.

Member Function Documentation

directory_open_failed()

virtual result<directory_handle> llfio_v2_xxx::algorithm::traverse_visitor::directory_open_failed ( void *  data, result< void >::error_type &&  error, const directory_handle &  dirh, path_view  leaf, size_t  depth  )

inlinevirtualnoexcept

Called when we failed to open a directory for enumeration. The default fails the traversal with that error. Return a default constructed instance to ignore the failure.

Note

May be called from multiple kernel threads concurrently.

Reimplemented in llfio_v2_xxx::algorithm::summarize_visitor, and llfio_v2_xxx::algorithm::reduce_visitor.

    {
      (void) data;
      (void) dirh;
      (void) leaf;
      (void) depth;
      return failure(std::move(error));
    }

post_enumeration()

virtual result<void> llfio_v2_xxx::algorithm::traverse_visitor::post_enumeration ( void *  data, const directory_handle &  dirh, directory_handle::buffers_type &  contents, size_t  depth  )

inlinevirtualnoexcept

Called just after each directory enumeration. You can modify the results to affect the traversal, typically you would set the stat to default constructed to cause it to be ignored. You are guaranteed that at least stat.st_type is valid for every entry in contents, and items whose type is a directory will be enqueued after this call for later traversal.

Note

May be called from multiple kernel threads concurrently.

Reimplemented in llfio_v2_xxx::algorithm::summarize_visitor, llfio_v2_xxx::algorithm::reduce_visitor, llfio_v2_xxx::algorithm::compare_visitor, and llfio_v2_xxx::algorithm::contents_visitor.

    {
      (void) data;
      (void) dirh;
      (void) contents;
      (void) depth;
      return success();
    }

pre_enumeration()

virtual result<bool> llfio_v2_xxx::algorithm::traverse_visitor::pre_enumeration ( void *  data, const directory_handle &  dirh, size_t  depth  )

inlinevirtualnoexcept

Called to decide whether to enumerate a directory.

Note that it is more efficient to ignore the directory entry in post_enumeration() than to ignore it here, as a handle is opened for the directory before this callback. Equally, if you need that handle to inspect the directory e.g. to check if one is entering a different filesystem from the root, here is best.

The default returns true.

Note

May be called from multiple kernel threads concurrently.

    {
      (void) data;
      (void) dirh;
      (void) depth;
      return true;
    }

stack_updated()

virtual result<void> llfio_v2_xxx::algorithm::traverse_visitor::stack_updated ( void *  data, size_t  dirs_processed, size_t  known_dirs_remaining, size_t  depth_processed, size_t  known_depth_remaining  )

inlinevirtualnoexcept

Called whenever the traversed stack of directory hierarchy is updated. This can act as an estimated progress indicator, or to give an accurate progress indicator by matching it against a previous traversal.

Parameters

data	The third party data pointer passed to traverse().
dirs_processed	The total number of directories traversed so far.
known_dirs_remaining	The currently known number of directories awaiting traversal.
depth_processed	How many levels deep we have already completely traversed.
known_depth_remaining	The currently known number of levels we shall traverse.

Note

May be called from multiple kernel threads concurrently.

    {
      (void) data;
      (void) dirs_processed;
      (void) known_dirs_remaining;
      (void) depth_processed;
      (void) known_depth_remaining;
      return success();
    }

---

The documentation for this struct was generated from the following file:

• include/llfio/v2.0/algorithm/traverse.hpp