fs_event.hpp

#pragma once


#include <utility>
#include <string>
#include <memory>
#include <uv.h>
#include "handle.hpp"
#include "util.hpp"
#include "loop.hpp"


namespace uvw {


namespace details {


enum class UVFsEventFlags: std::underlying_type_t<uv_fs_event_flags> {
    WATCH_ENTRY = UV_FS_EVENT_WATCH_ENTRY,
    STAT = UV_FS_EVENT_STAT,
    RECURSIVE = UV_FS_EVENT_RECURSIVE
};


enum class UVFsEvent: std::underlying_type_t<uv_fs_event> {
    RENAME = UV_RENAME,
    CHANGE = UV_CHANGE
};


}


struct FsEventEvent {
    FsEventEvent(const char * pathname, Flags<details::UVFsEvent> events)
        : filename{pathname}, flags{std::move(events)}
    {}

    const char * filename;

    Flags<details::UVFsEvent> flags;
};


class FsEventHandle final: public Handle<FsEventHandle, uv_fs_event_t> {
    static void startCallback(uv_fs_event_t *handle, const char *filename, int events, int status) {
        FsEventHandle &fsEvent = *(static_cast<FsEventHandle*>(handle->data));
        if(status) { fsEvent.publish(ErrorEvent{status}); }
        else { fsEvent.publish(FsEventEvent{filename, static_cast<std::underlying_type_t<details::UVFsEvent>>(events)}); }
    }

public:
    using Watch = details::UVFsEvent;
    using Event = details::UVFsEventFlags;

    using Handle::Handle;

    bool init() {
        return initialize(&uv_fs_event_init);
    }

    void start(std::string path, Flags<Event> flags = Flags<Event>{}) {
        invoke(&uv_fs_event_start, get(), &startCallback, path.data(), flags);
    }

    void start(std::string path, Event flag) {
        start(std::move(path), Flags<Event>{flag});
    }

    void stop() {
        invoke(&uv_fs_event_stop, get());
    }

    std::string path() noexcept {
        return details::tryRead(&uv_fs_event_getpath, get());
    }
};


}