cache.hpp

Go to the documentation of this file.

#pragma once
 
#include "watcher.h"
#include "pattern_filter.h"
#include <chrono>
#include <filesystem>
#include <type_traits>
#include <vector>
 
namespace fs
{
 
template<typename T>
class cache
{
public:
    using iterator_t = T;
    static_assert(std::is_same<iterator_t, recursive_directory_iterator>::value ||
                      std::is_same<iterator_t, directory_iterator>::value,
                  "T must be a valid directory iterator type");
 
    using clock_t = std::chrono::steady_clock;
 
    cache() = default;
 
    cache(const fs::path& p, clock_t::duration scan_frequency)
        : path_(p)
        , scan_frequency_(scan_frequency)
        , should_refresh_(true)
    {
        watch();
    }
 
    cache(const fs::path& p, const pattern_filter& filter, clock_t::duration scan_frequency)
        : path_(p)
        , filter_(filter)
        , scan_frequency_(scan_frequency)
        , should_refresh_(true)
    {
        watch();
    }
 
    cache(const cache& rhs)
        : path_(rhs.path_)
        , scan_frequency_(rhs.scan_frequency_)
        , entries_(rhs.entries_)
        , should_refresh_(rhs.should_refresh_.load())
        , filter_(rhs.filter_)
    {
        watch();
    }
 
    cache(cache&& rhs) noexcept
        : path_(std::move(rhs.path_))
        , scan_frequency_(rhs.scan_frequency_)
        , entries_(std::move(rhs.entries_))
        , should_refresh_(rhs.should_refresh_.load())
        , filter_(std::move(rhs.filter_))
    {
        rhs.unwatch();
        watch();
    }
 
    cache& operator=(const cache& rhs)
    {
        unwatch();
        path_ = rhs.path_;
        scan_frequency_ = rhs.scan_frequency_;
        entries_ = rhs.entries_;
        should_refresh_ = rhs.should_refresh_.load();
        filter_ = rhs.filter_;
        watch();
 
        return *this;
    }
 
    cache& operator=(cache&& rhs) noexcept
    {
        rhs.unwatch();
        unwatch();
        path_ = std::move(rhs.path_);
        scan_frequency_ = std::move(rhs.scan_frequency_);
        entries_ = std::move(rhs.entries_);
        should_refresh_ = rhs.should_refresh_.load();
        filter_ = std::move(rhs.filter_);
        watch();
 
        return *this;
    }
 
    ~cache()
    {
        unwatch();
    }
    //-----------------------------------------------------------------------------
    //  Name : end ()
    //-----------------------------------------------------------------------------
    decltype(auto) begin() const
    {
        if(should_refresh())
        {
            refresh();
        }
        return entries_.begin();
    }
 
    //-----------------------------------------------------------------------------
    //  Name : end ()
    //-----------------------------------------------------------------------------
    decltype(auto) end() const
    {
        return entries_.end();
    }
 
    //-----------------------------------------------------------------------------
    //  Name : size ()
    //-----------------------------------------------------------------------------
    decltype(auto) size() const
    {
        if(should_refresh())
        {
            refresh();
        }
        return entries_.size();
    }
 
    //-----------------------------------------------------------------------------
    //  Name : at ()
    //-----------------------------------------------------------------------------
    decltype(auto) at(size_t idx) const
    {
        return entries_.at(idx);
    }
    decltype(auto) operator[](size_t idx) const
    {
        return entries_[idx];
    }
 
    //-----------------------------------------------------------------------------
    //  Name : refresh ()
    //-----------------------------------------------------------------------------
    void refresh() const
    {
        entries_.clear();
 
        fs::error_code err;
        iterator_t it(path_, err);
        for(const auto& p : it)
        {
            // Apply pattern filter if enabled
            if(!filter_.should_include(p.path()))
            {
                continue;
            }
 
            entries_.emplace_back();
            auto& cache_entry = entries_.back();
            cache_entry.entry = p;
            const auto& absolute_path = cache_entry.entry.path();
            auto filename = absolute_path.filename();
            cache_entry.protocol_path = fs::convert_to_protocol(absolute_path).generic_string();
            cache_entry.filename = absolute_path.filename().string();
            cache_entry.extension = filename.extension().string();
            cache_entry.stem = filename.stem().string();
        }
 
        std::sort(std::begin(entries_),
                  std::end(entries_),
                  [](const auto& lhs, const auto& rhs)
                  {
                      return fs::is_directory(lhs.entry.status()) > fs::is_directory(rhs.entry.status());
                  });
 
        should_refresh_ = false;
    }
 
    const fs::path& get_path() const
    {
        return path_;
    }
 
    void clear()
    {
        unwatch();
        path_.clear();
        entries_.clear();
        should_refresh_ = true;
    }
 
    void set_path(const fs::path& path, const fs::pattern_filter& filter)
    {
        if(path_ == path)
        {
            return;
        }
        unwatch();
        path_ = path;
        filter_ = filter;
        should_refresh_ = true;
        watch();
    }
 
    void set_scan_frequency(clock_t::duration scan_frequency)
    {
        if(scan_frequency_ == scan_frequency)
        {
            return;
        }
        unwatch();
        scan_frequency_ = scan_frequency;
        should_refresh_ = true;
        watch();
    }
 
    struct cache_entry
    {
        directory_entry entry;
        std::string filename;
        std::string stem;
        std::string extension;
        std::string protocol_path;
    };
 
private:
    //-----------------------------------------------------------------------------
    //  Name : should_refresh ()
    //-----------------------------------------------------------------------------
    bool should_refresh() const
    {
        return should_refresh_;
    }
 
    void watch()
    {
        using namespace std::literals;
        constexpr bool is_recursive = std::is_same<iterator_t, recursive_directory_iterator>::value;
 
        watch_id_ = watcher::watch(path_,
                                       filter_,
                                       is_recursive,
                                       false,
                                       scan_frequency_,
                                       [this](const auto&, bool)
                                       {
                                           should_refresh_ = true;
                                       }, "directory_cache");
        
    }
    void unwatch()
    {
        if(watch_id_ != 0)
        {
            watcher::unwatch(watch_id_);
            watch_id_ = 0;
        }
    }
 
    fs::path path_;
 
    clock_t::duration scan_frequency_ = std::chrono::milliseconds(500);
    mutable std::vector<cache_entry> entries_;
    mutable std::atomic_bool should_refresh_ = {true};
    std::uint64_t watch_id_ = 0;
    pattern_filter filter_;
};
 
using directory_cache = cache<directory_iterator>;
using recursive_directory_cache = cache<recursive_directory_iterator>;
 
template<typename Iterator = recursive_directory_iterator>
auto make_filtered_cache(const fs::path& path,
                         const std::vector<std::string>& includes,
                         const std::vector<std::string>& excludes = {},
                         std::chrono::steady_clock::duration scan_frequency = std::chrono::milliseconds(500))
    -> cache<Iterator>
{
    return cache<Iterator>(path, make_pattern_filter(includes, excludes), scan_frequency);
}
 
} // namespace fs