filesystem_snapshot_internal.h

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace pixelbullet::filesystem
{
struct NativeFileSnapshot
{
    std::string logical_path;
    std::filesystem::path physical_path;
    bool exists = false;
    std::optional<std::filesystem::file_time_type> last_write_time;
};
 
struct NativeFileSnapshotBatchRequest
{
    std::string logical_path;
    std::filesystem::path physical_path;
};
 
enum class NativeFileSnapshotBatchMode
{
    None,
    BatchedExact,
    BatchedWithFallback,
    PerRecordFallback,
};
 
enum class NativeSnapshotBackend
{
    None,
    StdFilesystem,
    NativeWin32,
    Fallback,
};
 
class NativeSnapshotProbeCache
{
public:
    NativeSnapshotProbeCache();
    ~NativeSnapshotProbeCache();
    NativeSnapshotProbeCache(NativeSnapshotProbeCache&&) noexcept;
    NativeSnapshotProbeCache& operator=(NativeSnapshotProbeCache&&) noexcept;
    NativeSnapshotProbeCache(const NativeSnapshotProbeCache&) = delete;
    NativeSnapshotProbeCache& operator=(const NativeSnapshotProbeCache&) = delete;
 
    void Clear() noexcept;
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
 
    friend struct NativeSnapshotProbeCacheAccess;
};
 
struct NativeFileSnapshotBatchOptions
{
    bool collect_trusted_watched_directories = true;
    NativeSnapshotProbeCache* probe_cache = nullptr;
};
 
struct NativeFileSnapshotBatchResult
{
    std::vector<NativeFileSnapshot> snapshots;
    std::vector<std::filesystem::path> watched_directories;
    bool watched_directories_trusted = false;
    NativeFileSnapshotBatchMode mode = NativeFileSnapshotBatchMode::None;
    NativeSnapshotBackend backend = NativeSnapshotBackend::None;
    std::size_t request_count = 0u;
    std::size_t directory_group_count = 0u;
    std::size_t fallback_count = 0u;
    std::size_t probe_cache_hit_count = 0u;
    std::size_t probe_cache_miss_count = 0u;
    std::size_t probe_cache_reused_entry_count = 0u;
    float directory_enumeration_milliseconds = 0.0f;
    float fallback_milliseconds = 0.0f;
    float trusted_directory_milliseconds = 0.0f;
    float snapshot_assembly_milliseconds = 0.0f;
};
 
struct NativeDirectorySnapshot
{
    std::string logical_path;
    std::filesystem::path physical_path;
    bool exists = false;
    bool is_directory = false;
    std::optional<std::int64_t> last_write_time_ticks;
    std::string detail;
};
 
struct NativeDirectorySnapshotBatchRequest
{
    std::string logical_path;
    std::filesystem::path physical_path;
};
 
enum class NativeDirectorySnapshotBatchMode
{
    None,
    BatchedExact,
    BatchedWithFallback,
    PerRecordFallback,
};
 
struct NativeDirectorySnapshotBatchResult
{
    std::vector<NativeDirectorySnapshot> snapshots;
    NativeDirectorySnapshotBatchMode mode = NativeDirectorySnapshotBatchMode::None;
    NativeSnapshotBackend backend = NativeSnapshotBackend::None;
    std::size_t request_count = 0u;
    std::size_t parent_directory_group_count = 0u;
    std::size_t fallback_count = 0u;
    std::size_t probe_cache_hit_count = 0u;
    std::size_t probe_cache_miss_count = 0u;
    std::size_t probe_cache_reused_entry_count = 0u;
    float parent_directory_enumeration_milliseconds = 0.0f;
    float fallback_milliseconds = 0.0f;
    float snapshot_assembly_milliseconds = 0.0f;
};
 
struct NativeDirectorySnapshotPlanEntry
{
    std::string logical_path;
    std::filesystem::path physical_path;
    std::string directory_name_key;
};
 
struct NativeDirectorySnapshotPlanGroup
{
    std::filesystem::path parent_directory;
    std::vector<std::size_t> entry_indices;
};
 
struct NativeDirectorySnapshotPlan
{
    std::vector<NativeDirectorySnapshotPlanEntry> entries;
    std::vector<NativeDirectorySnapshotPlanGroup> groups;
};
 
[[nodiscard]] std::int64_t FileTimeToTicks(std::filesystem::file_time_type time) noexcept;
[[nodiscard]] std::filesystem::file_time_type FileTimeFromTicks(std::int64_t ticks) noexcept;
[[nodiscard]] std::string_view ToString(NativeSnapshotBackend backend) noexcept;
[[nodiscard]] bool CaptureDirectoryWriteTimeTicks(const std::filesystem::path& directory, std::int64_t& ticks, std::string& detail);
[[nodiscard]] NativeDirectorySnapshot CaptureDirectoryWriteTimeSnapshot(std::string logical_path, const std::filesystem::path& directory);
[[nodiscard]] NativeDirectorySnapshotBatchResult
CaptureDirectoryWriteTimeSnapshotsBatched(const std::vector<NativeDirectorySnapshotBatchRequest>& requests,
                                          NativeSnapshotProbeCache* probe_cache = nullptr);
[[nodiscard]] NativeDirectorySnapshotBatchResult CaptureDirectoryWriteTimeSnapshotsPlanned(const NativeDirectorySnapshotPlan& plan,
                                                                                           NativeSnapshotProbeCache* probe_cache = nullptr);
[[nodiscard]] std::optional<std::filesystem::path> FindNearestExistingDirectory(const std::filesystem::path& physical_path);
[[nodiscard]] NativeFileSnapshot CaptureResolvedFileSnapshot(std::string logical_path, const std::filesystem::path& resolved_path);
[[nodiscard]] NativeFileSnapshotBatchResult CaptureResolvedFileSnapshotsBatched(const std::vector<NativeFileSnapshotBatchRequest>& requests,
                                                                                const NativeFileSnapshotBatchOptions& options = {});
[[nodiscard]] bool NativeFileSnapshotsEqual(const NativeFileSnapshot& lhs, const NativeFileSnapshot& rhs) noexcept;
} // namespace pixelbullet::filesystem