file_watcher.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FILE_FILE_WATCHER_HPP__
#define NEFORCE_CORE_FILE_FILE_WATCHER_HPP__

 
#include "NeForce/core/async/atomic.hpp"
#include "NeForce/core/async/mutex.hpp"
#include "NeForce/core/async/thread.hpp"
#include "NeForce/core/container/vector.hpp"
#include "NeForce/core/file/file_constants.hpp"
#include "NeForce/core/file/path.hpp"
#include "NeForce/core/functional/function.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API file_watcher {
private:
    using callback_t = function<void(const path&, file_watch_event)>; 
 
    path watch_path_;                                        
    bool recursive_;                                         
    atomic<bool> watching_{false};                           
    atomic<bool> stopping_{false};                           
    callback_t callback_;                                    
    file_watch_event current_events_{file_watch_event::ALL}; 
    vector<char> buffer_;                                    
    mutex callback_mutex_;                                   
 
#ifdef NEFORCE_PLATFORM_WINDOWS
    native_handle_type dir_handle_ = INVALID_HANDLE_VALUE;      
    native_handle_type completion_port_ = INVALID_HANDLE_VALUE; 
    ::OVERLAPPED overlapped_{};                                 
#else
    native_handle_type inotify_fd_ = -1;       
    native_handle_type watch_descriptor_ = -1; 
    native_handle_type event_fd_ = -1;         
#endif
 
    thread watch_thread_; 

    void watch_thread_func();
 
public:
    explicit file_watcher(path watch_path, bool recursive = false);

    ~file_watcher();
 
    file_watcher(const file_watcher&) = delete;
    file_watcher& operator=(const file_watcher&) = delete;

    bool start(callback_t callback, file_watch_event events = file_watch_event::ALL);

    void stop();

    NEFORCE_NODISCARD const path& watch_path() const noexcept { return watch_path_; }

    NEFORCE_NODISCARD file_watch_event current_events() const noexcept { return current_events_; }

    NEFORCE_NODISCARD bool is_watching() const noexcept { return watching_.load(); }

    NEFORCE_NODISCARD bool is_recursive() const noexcept { return recursive_; }

    bool update_watch(file_watch_event events);

    bool update_recursive(bool recursive);
};
 // File
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FILE_FILE_WATCHER_HPP__