FileSystemWatcher.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Foundation/Function.h"
#include "../Foundation/OpaqueObject.h"
#include "../Foundation/Result.h"
#include "../Foundation/StringPath.h"
#include "../Threading/Threading.h" // sizeof(Mutex)
 
namespace SC
{
 
 
 
 
struct FileSystemWatcher
{
  private:
    struct Internal;
 
    struct InternalDefinition
    {
        static constexpr int Windows = 3 * sizeof(void*);
        static constexpr int Apple   = 43 * sizeof(void*) + sizeof(Mutex);
        static constexpr int Linux   = sizeof(void*) * 4;
        static constexpr int Default = Linux;
 
        static constexpr size_t Alignment = alignof(void*);
 
        using Object = Internal;
    };
 
  public:
    // Must be public to avoid GCC complaining
    using InternalOpaque = OpaqueObject<InternalDefinition>;
 
  private:
    InternalOpaque 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 Linux   = sizeof(Thread) + sizeof(void*) * 2;
        static constexpr int Default = Linux;
 
        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(void*);
        static constexpr int Apple                = sizeof(void*);
        static constexpr int Linux                = 1056 + 1024 + 8;
        static constexpr int Default              = Linux;
 
        static constexpr size_t Alignment = alignof(void*);
 
        using Object = FolderWatcherInternal;
    };
 
  public:
    enum class Operation
    {
        Modified,        
        AddRemoveRename, 
    };
 
    struct Notification
    {
        StringSpan basePath;                        
        StringSpan relativePath;                    
        Operation  operation = Operation::Modified; 
 
        SC::Result getFullPath(StringPath& path) const;
 
      private:
        friend struct Internal;
#if SC_PLATFORM_APPLE
        StringSpan fullPath;
#endif
    };
 
    struct FolderWatcher
    {
        FolderWatcher(Span<char> subFolderRelativePathsBuffer = {});
 
        Function<void(const Notification&)> notifyCallback; 
 
        Result stopWatching();
 
        void setDebugName(const char* debugName);
 
      private:
        friend struct FileSystemWatcher;
        friend struct FileSystemWatcherAsync;
#if SC_PLATFORM_WINDOWS
        AlignedStorage<112> asyncStorage;
#endif
        OpaqueObject<FolderWatcherSizes> internal;
 
        FileSystemWatcher* parent = nullptr;
        FolderWatcher*     next   = nullptr;
        FolderWatcher*     prev   = nullptr;
 
        StringPath path;
 
#if SC_PLATFORM_LINUX
        Span<char> subFolderRelativePathsBuffer;
#endif
    };
 
    struct EventLoopRunner
    {
        virtual ~EventLoopRunner() {}
 
      protected:
#if SC_PLATFORM_APPLE
        virtual Result appleStartWakeUp()       = 0;
        virtual void   appleSignalEventObject() = 0;
        virtual Result appleWakeUpAndWait()     = 0;
 
#elif SC_PLATFORM_LINUX
        virtual Result linuxStartSharedFilePoll() = 0;
        virtual Result linuxStopSharedFilePoll()  = 0;
 
        int notifyFd = -1;
 
#else
        virtual Result windowsStartFolderFilePoll(FolderWatcher& watcher, void* handle) = 0;
        virtual Result windowsStopFolderFilePoll(FolderWatcher& watcher)                = 0;
        virtual void*  windowsGetOverlapped(FolderWatcher& watcher)                     = 0;
#endif
        friend struct Internal;
        FileSystemWatcher* fileSystemWatcher = nullptr;
 
        void internalInit(FileSystemWatcher& fsWatcher, int handle);
    };
 
    using ThreadRunner = OpaqueObject<ThreadRunnerDefinition>;
 
    Result init(ThreadRunner& runner);
 
    Result init(EventLoopRunner& runner);
 
    Result close();
 
    Result watch(FolderWatcher& watcher, StringSpan path);
 
    void asyncNotify(FolderWatcher* watcher);
 
  private:
    friend decltype(internal);
    friend decltype(FolderWatcher::internal);
    friend struct EventLoopRunner;
    // Trimmed duplicate of IntrusiveDoubleLinkedList<T>
    struct WatcherLinkedList
    {
        FolderWatcher* back  = nullptr; // has no next
        FolderWatcher* front = nullptr; // has no prev
 
        [[nodiscard]] bool isEmpty() const { return front == nullptr; }
 
        void queueBack(FolderWatcher& watcher);
        void remove(FolderWatcher& watcher);
    };
    WatcherLinkedList watchers;
};
 
} // namespace SC