FileSystemWatcherError.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Common/Result.h"
 
namespace SC
{
 
enum class FileSystemWatcherError : uint32_t
{
    NotInitialized = 1,
    AlreadyWatching,
    NotWatching,
    UnsupportedPathEncoding,
    PathPreparationFailed,
    WatchLimitExceeded,
    BufferTooSmall,
    InitializationFailed,
    WatchSetupFailed,
    StopWatchingFailed,
    CloseFailed,
};
 
enum class FileSystemWatcherErrorDetail : uint32_t
{
    None = 0,
    AssignWatchPath,
    BuildSubfolderPath,
    BuildNotificationPath,
    BuildFullPath,
    WatchPathCapacity,
    WorkerAlreadyStarted,
    PosixPthreadCreate,
    PosixPthreadJoin,
    WindowsCreateThread,
    WindowsWaitForSingleObject,
    LinuxCreateShutdownPipe,
    LinuxInitializeInotify,
    LinuxWriteShutdownPipe,
    LinuxInotifyDescriptor,
    LinuxRemoveWatch,
    LinuxAddRootWatch,
    LinuxAddSubdirectoryWatch,
    LinuxOpenRootDirectory,
    LinuxWatchHandleCapacity,
    LinuxPendingDirectoryCapacity,
    LinuxRelativePathStorage,
    AppleRunLoop,
    AppleCreateRunLoopSource,
    AppleAllocateWatchPaths,
    AppleCreateWatchPathString,
    AppleCreateWatchPathsArray,
    AppleCreateEventStream,
    AppleStartEventStream,
    WindowsOpenDirectory,
    WindowsSubmitDirectoryChanges,
};
 
static constexpr ResultCategory FileSystemWatcherResultCategory = ResultCategory(6);
 
struct [[nodiscard]] ResultFileSystemWatcher
{
    Result                       result;
    FileSystemWatcherErrorDetail detail      = FileSystemWatcherErrorDetail::None;
    uint32_t                     nativeError = 0;
 
    explicit constexpr ResultFileSystemWatcher(bool valid = true) : result(valid) {}
    constexpr ResultFileSystemWatcher(FileSystemWatcherError       error,
                                      FileSystemWatcherErrorDetail detail      = FileSystemWatcherErrorDetail::None,
                                      uint32_t                     nativeError = 0)
        : result(Result::Error(FileSystemWatcherResultCategory, error)), detail(detail), nativeError(nativeError)
    {}
    constexpr ResultFileSystemWatcher(Result result) : result(result) {}
 
    template <typename ResultLike>
    constexpr ResultFileSystemWatcher(const ResultLike& other) : result(other.toResult())
    {}
 
    explicit constexpr operator bool() const { return static_cast<bool>(result); }
 
    constexpr operator Result() const { return result; }
 
    constexpr Result toResult() const { return result; }
    constexpr bool   isError(FileSystemWatcherError error) const
    {
        return result.isError(FileSystemWatcherResultCategory, error);
    }
};
 
} // namespace SC