FileSystemWatcher.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Async/Async.h" // AsyncLoopWakeUp
#include "../Containers/IntrusiveDoubleLinkedList.h"
#include "../Foundation/Function.h"
#include "../Foundation/OpaqueObject.h"
#include "../Foundation/Result.h"
#include "../Strings/SmallString.h"
#include "../Threading/Threading.h" // EventObject
 
namespace SC
{
struct FileSystemWatcher;
struct String;
} // namespace SC
 
 
 
struct SC::FileSystemWatcher
{
  private:
    struct Internal;
    struct ThreadRunnerInternal;
    struct ThreadRunnerDefinition
    {
        static constexpr int MaxWatchablePaths = 1024;
        static constexpr int Windows =
            (2 * MaxWatchablePaths) * sizeof(void*) + sizeof(uint64_t) + sizeof(Thread) + sizeof(Action);
        static constexpr int Apple   = sizeof(void*);
        static constexpr int Default = sizeof(Thread) + sizeof(void*) * 2;
 
        static constexpr size_t Alignment = alignof(void*);
 
        using Object = ThreadRunnerInternal;
    };
 
    struct FolderWatcherInternal;
    struct FolderWatcherSizes
    {
        static constexpr int MaxNumberOfSubdirs   = 128; // Max number of subfolders tracked in a watcher
        static constexpr int MaxChangesBufferSize = 1024;
        static constexpr int Windows =
            MaxChangesBufferSize + sizeof(void*) + sizeof(FileDescriptor) + sizeof(AsyncFilePoll);
        static constexpr int Apple = sizeof(void*);
        static constexpr int Default =
            sizeof(Array<int64_t, MaxNumberOfSubdirs>) + sizeof(Vector<char>) + sizeof(void*);
 
        static constexpr size_t Alignment = alignof(void*);
 
        using Object = FolderWatcherInternal;
    };
    struct InternalDefinition
    {
        static constexpr int Windows = 3 * sizeof(void*);
        static constexpr int Apple   = 43 * sizeof(void*) + sizeof(Mutex);
        static constexpr int Default = sizeof(void*) * 4;
 
        static constexpr size_t Alignment = alignof(void*);
 
        using Object = Internal;
    };
 
    using InternalOpaque = OpaqueObject<InternalDefinition>;
 
    InternalOpaque internal;
 
  public:
    enum class Operation
    {
        Modified,        
        AddRemoveRename, 
    };
 
    struct Notification
    {
        StringView basePath;                        
        StringView relativePath;                    
        Operation  operation = Operation::Modified; 
 
        SC::Result getFullPath(String& bufferString, StringView& outFullPath) const;
 
      private:
        friend struct Internal;
#if SC_PLATFORM_APPLE
        StringView fullPath;
#endif
    };
 
    struct FolderWatcher
    {
        Function<void(const Notification&)> notifyCallback; 
 
        Result stopWatching();
 
      private:
        friend struct FileSystemWatcher;
        friend struct IntrusiveDoubleLinkedList<FolderWatcher>;
        FileSystemWatcher* parent = nullptr;
        FolderWatcher*     next   = nullptr;
        FolderWatcher*     prev   = nullptr;
        SmallString<1024>  path;
 
        OpaqueObject<FolderWatcherSizes> internal;
    };
 
    struct EventLoopRunner
    {
 
      private:
        friend struct FileSystemWatcher;
        AsyncEventLoop* eventLoop = nullptr;
#if SC_PLATFORM_APPLE
        AsyncLoopWakeUp eventLoopAsync = {};
        EventObject     eventObject    = {};
#elif SC_PLATFORM_LINUX
        AsyncFilePoll asyncPoll = {};
#endif
    };
 
    using ThreadRunner = OpaqueObject<ThreadRunnerDefinition>;
 
    [[nodiscard]] Result init(ThreadRunner& runner);
 
    [[nodiscard]] Result init(EventLoopRunner& runner, AsyncEventLoop& eventLoop);
 
    [[nodiscard]] Result close();
 
    [[nodiscard]] Result watch(FolderWatcher& watcher, StringView path);
 
  private:
    friend decltype(internal);
    friend decltype(FolderWatcher::internal);
    IntrusiveDoubleLinkedList<FolderWatcher> watchers;
};