FileWatcher.hpp

Go to the documentation of this file.

 
//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2023 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Platform/Forward.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
#include "CeresEngine/Foundation/Threading/ExecutionContext.hpp"
 
#include <functional>
#include <memory>
#include <vector>
 
namespace CeresEngine {
 
    enum class FileEvent {
        Created = 0x01, 
        Removed = 0x02, 
        Modified = 0x04, 
        AttributeChanged = 0x08, 
 
        Default = Created | Removed | Modified | AttributeChanged,
    };
 
    using FileEvents = Flags<FileEvent>;
 
    class FileWatcher final {
    public:
        using ImplementationType = SPtr<IFileWatcher>;
 
    private:
        ImplementationType mImplementation;
 
        Vector<FileEventHandler*> mEventHandlers;
 
        Vector<UPtr<FunctionalFileEventHandler>> mOwnEventHandlers;
 
    public:
        using EventFunc = std::function<void(const FileHandle&, FileEvent)>;
 
    public:
        explicit FileWatcher(ExecutionContext& executionContext, const FileHandle& directory, const FileEvent& events = FileEvent::Default,
            bool recursive = true);
 
        CE_EXPLICIT(false) FileWatcher(ImplementationType&& implementation);
 
        FileWatcher(const FileWatcher& fileWatcher) = delete;
        FileWatcher& operator=(const FileWatcher& fileWatcher) = delete;
 
        FileWatcher& operator=(FileWatcher&& other) noexcept;
        FileWatcher(FileWatcher&& other) noexcept;
 
        ~FileWatcher() noexcept;
 
    public:
        [[nodiscard]] IFileSystem* getFileSystem() const;
 
        void start();
 
        void stop();
 
        void addHandler(FileEventHandler& eventHandler);
 
        void addHandler(EventFunc&& funcFileEvent);
 
        void removeHandler(const FileEventHandler& eventHandler);
 
    protected:
        friend class IFileWatcher;
 
        void onFileEvent(const FileHandle& handle, FileEvent event);
    };
 
    class IFileWatcher {
        friend class FileWatcher;
 
    protected:
        FileWatcher* mFileWatcher;
 
    public:
        IFileWatcher();
        virtual ~IFileWatcher();
 
    public:
        [[nodiscard]] virtual IFileSystem* getFileSystem() const = 0;
 
        virtual void start() = 0;
 
        virtual void stop() = 0;
 
    protected:
        void onFileEvent(const FileHandle& handle, FileEvent event);
    };
 
    class FileEventHandler {
        friend class FileWatcher;
 
    public:
        FileEventHandler() = default;
        virtual ~FileEventHandler() = default;
 
    protected:
        virtual void onFileEvent(const FileHandle& handle, FileEvent event);
 
        virtual void onFileCreated(const FileHandle& handle);
 
        virtual void onFileRemoved(const FileHandle& handle);
 
        virtual void onFileModified(const FileHandle& handle);
 
        virtual void onFileAttributesChanged(const FileHandle& handle);
    };
 
    class FunctionalFileEventHandler final : public FileEventHandler {
    public:
        using EventFunc = std::function<void(const FileHandle&, FileEvent)>;
 
    private:
        EventFunc mFuncFileEvent;
 
    public:
        FunctionalFileEventHandler();
 
        explicit FunctionalFileEventHandler(EventFunc&& funcFileEvent);
 
        ~FunctionalFileEventHandler() final;
 
    protected:
        void onFileEvent(const FileHandle& handle, FileEvent event) final;
    };
 
} // namespace CeresEngine