llfio_v2_xxx::algorithm::contents_visitor Struct Reference

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

#include "contents.hpp"

Inheritance diagram for llfio_v2_xxx::algorithm::contents_visitor:

Classes
struct	_state_type
struct	contents_type
	Enumerated contents, and what parts of their stat_t is valid. More...

Public Member Functions
	contents_visitor ()=default
	Default construtor.
	contents_visitor (stat_t::want _metadata, bool _include_files=true, bool _include_directories=true, bool _include_symlinks=true)
	Construct an instance.
virtual result< void >	post_enumeration (void *data, const directory_handle &dirh, directory_handle::buffers_type &contents, size_t depth) noexcept
	The default implementation accumulates the contents into thread local storage. At traverse end, all the thread local storages are coalesced into a single result, the member variable contents.
virtual result< size_t >	finished (void *data, result< size_t > result) noexcept
	Called when a traversal finishes, this default implementation merges all the thread local results into contents, and deallocates the thread local results.
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.
virtual result< bool >	pre_enumeration (void *data, const directory_handle &dirh, size_t depth) noexcept
	Called to decide whether to enumerate a directory.
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.

Public Attributes
bool	contents_include_files {true}
	Whether to include files in the contents.
bool	contents_include_directories {true}
	Whether to include directories in the contents.
bool	contents_include_symlinks {true}
	Whether to include symlinks in the contents.
stat_t::want	contents_include_metadata {stat_t::want::none}
	What stat_t::want to include, if enumeration doesn't provide these, they will be additionally fetched.

Static Protected Member Functions
static std::shared_ptr< contents_type >	_thread_contents (_state_type *state) noexcept

Friends
result< contents_type >	contents (const path_handle &dirh, contents_visitor *visitor, size_t threads, bool force_slow_path) noexcept
	Calculate the contents of everything within and under dirh. What is returned is unordered.

Detailed Description

A visitor for the filesystem contents algorithm.

Constructor & Destructor Documentation

contents_visitor()

llfio_v2_xxx::algorithm::contents_visitor::contents_visitor ( stat_t::want  _metadata, bool  _include_files = true, bool  _include_directories = true, bool  _include_symlinks = true  )

inlineexplicit

Construct an instance.

        : contents_include_files(_include_files)
        , contents_include_directories(_include_directories)
        , contents_include_symlinks(_include_symlinks)
        , contents_include_metadata(_metadata)
    {
    }

Member Function Documentation

_thread_contents()

static std::shared_ptr< contents_type > llfio_v2_xxx::algorithm::contents_visitor::_thread_contents ( _state_type *  state )

inlinestaticprotectednoexcept

    {
      LLFIO_EXCEPTION_TRY
      {
        static thread_local std::weak_ptr<contents_type> mycontents;
        auto ret = mycontents.lock();
        if(ret)
        {
          return ret;
        }
        ret = std::make_unique<contents_type>();
        mycontents = ret;
        std::lock_guard<std::mutex> g(state->lock);
        state->all_thread_contents.push_back(ret);
        return ret;
      }
      LLFIO_EXCEPTION_CATCH_ALL
      {
        return {};
      }
    }

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  )

inlinevirtualnoexceptinherited

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::reduce_visitor, and llfio_v2_xxx::algorithm::summarize_visitor.

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

finished()

virtual result< size_t > llfio_v2_xxx::algorithm::contents_visitor::finished ( void *  data, result< size_t >  result  )

inlinevirtualnoexcept

Called when a traversal finishes, this default implementation merges all the thread local results into contents, and deallocates the thread local results.

Reimplemented from llfio_v2_xxx::algorithm::traverse_visitor.

    {
      LLFIO_EXCEPTION_TRY
      {
        auto *state = (_state_type *) data;
        state->contents.clear();
        state->contents.metadata = state->metadata.load(std::memory_order_relaxed);
        size_t count = 0;
        for(auto &i : state->all_thread_contents)
        {
          count += i->size();
        }
        state->contents.reserve(count);
        for(auto &i : state->all_thread_contents)
        {
          state->contents.insert(state->contents.end(), std::make_move_iterator(i->begin()), std::make_move_iterator(i->end()));
        }
        state->all_thread_contents.clear();
        return result;
      }
      LLFIO_EXCEPTION_CATCH_ALL
      {
        return error_from_exception();
      }
    }

post_enumeration()

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

inlinevirtualnoexcept

The default implementation accumulates the contents into thread local storage. At traverse end, all the thread local storages are coalesced into a single result, the member variable contents.

Reimplemented from llfio_v2_xxx::algorithm::traverse_visitor.

    {
      LLFIO_EXCEPTION_TRY
      {
        auto *state = (_state_type *) data;
        (void) depth;
        if(!contents.empty())
        {
          contents_type toadd;
          toadd.reserve(contents.size());
          filesystem::path dirhpath;
          for(;;)
          {
            OUTCOME_TRY(dirhpath, dirh.current_path());
            auto rootdirpathlen = state->rootdirpathlen.load(std::memory_order_relaxed);
            if(dirhpath.native().size() <= rootdirpathlen)
            {
              break;
            }
            dirhpath = dirhpath.native().substr(rootdirpathlen);
            auto r = directory_handle::directory(state->rootdirh, dirhpath);
            if(r && r.value().unique_id() == dirh.unique_id())
            {
              break;
            }
            OUTCOME_TRY(dirhpath, state->rootdirh.current_path());
            state->rootdirpathlen.store(dirhpath.native().size() + 1, std::memory_order_relaxed);
          }
          auto _metadata_ = state->metadata.load(std::memory_order_relaxed);
          if((_metadata_ & (contents_include_metadata | contents.metadata())) != _metadata_)
          {
            state->metadata.store(_metadata_ & (contents_include_metadata | contents.metadata()), std::memory_order_relaxed);
          }
          auto into = _thread_contents(state);
          for(auto &entry : contents)
          {
            auto need_stat = contents_include_metadata & ~contents.metadata();
            if((contents_include_files && entry.stat.st_type == filesystem::file_type::regular) ||
               (contents_include_directories && entry.stat.st_type == filesystem::file_type::directory) ||
               (contents_include_symlinks && entry.stat.st_type == filesystem::file_type::symlink))
            {
              if(!need_stat)
              {
                into->emplace_back(dirhpath / entry.leafname, entry.stat);
                continue;
              }
              auto r = file_handle::file(dirh, entry.leafname, file_handle::mode::attr_read);
              if(r)
              {
                OUTCOME_TRY(entry.stat.fill(r.value(), need_stat));
                into->emplace_back(dirhpath / entry.leafname, entry.stat);
              }
            }
          }
        }
        return success();
      }
      LLFIO_EXCEPTION_CATCH_ALL
      {
        return error_from_exception();
      }
    }

pre_enumeration()

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

inlinevirtualnoexceptinherited

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  )

inlinevirtualnoexceptinherited

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();
    }

Friends And Related Symbol Documentation

contents

result< contents_type > contents ( const path_handle &  dirh, contents_visitor *  visitor = nullptr, size_t  threads = 0, bool  force_slow_path = false  )

friend

Calculate the contents of everything within and under dirh. What is returned is unordered.

This is a very thin veneer over traverse() which came out of the fact that I kept writing "get me the contents" traversal visitors again and again, so eventually I just wrote a library edition. Its only "clever" bit is that it stores the contents in thread local storage, and merges the contents afterwards.

It is race free to concurrent relocations of dirh. It is entirely implemented in header-only code, as it is very simple.

  {
    contents_visitor default_visitor;
    if(visitor == nullptr)
    {
      visitor = &default_visitor;
    }
    contents_visitor::_state_type state(dirh);
    OUTCOME_TRY(auto &&dirhpath, dirh.current_path());
    state.rootdirpathlen.store(dirhpath.native().size() + 1, std::memory_order_relaxed);
    OUTCOME_TRY(traverse(dirh, visitor, threads, &state, force_slow_path));
    return {std::move(state.contents)};
  }

Member Data Documentation

contents_include_directories

bool llfio_v2_xxx::algorithm::contents_visitor::contents_include_directories {true}

Whether to include directories in the contents.

{true};

contents_include_files

bool llfio_v2_xxx::algorithm::contents_visitor::contents_include_files {true}

Whether to include files in the contents.

{true};

contents_include_metadata

stat_t::want llfio_v2_xxx::algorithm::contents_visitor::contents_include_metadata {stat_t::want::none}

What stat_t::want to include, if enumeration doesn't provide these, they will be additionally fetched.

{stat_t::want::none};

contents_include_symlinks

bool llfio_v2_xxx::algorithm::contents_visitor::contents_include_symlinks {true}

Whether to include symlinks in the contents.

{true};

---

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

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