FileSystemError.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Common/Result.h"
 
namespace SC
{
 
enum class FileSystemError : uint32_t
{
    NotInitialized = 1,
    UnsupportedPathEncoding,
    InvalidPath,
    PathMustBeAbsolute,
    PathCapacityExceeded,
    InvalidState,
    EntryNotFound,
    EntryAlreadyExists,
    EntryTypeMismatch,
    AccessDenied,
    ReadOnlyFileSystem,
    StorageCapacityExceeded,
    DirectoryNotEmpty,
    TooManyLinks,
    SymbolicLinkLoop,
    CrossDeviceOperation,
    InvalidArgument,
    OperationUnsupported,
    OutOfMemory,
    BufferCapacityExceeded,
    FileTooLarge,
    IncompleteRead,
    IncompleteWrite,
    UnsupportedEntryType,
    IoFailure,
    OperationFailed,
};
 
enum class FileSystemErrorDetail : uint16_t
{
    None = 0,
    ValidatePathEncoding,
    NormalizePath,
    ValidateAbsoluteBasePath,
    BuildTransportPath,
    ChangeDirectory,
    CheckAccess,
    QueryEntryMetadata,
    OpenFileForRead,
    OpenFileForWrite,
    QueryFileSize,
    GrowReadBuffer,
    ReadFileContent,
    WriteFileContent,
    AppendFileContent,
    CreateDirectoryEntry,
    CreateParentDirectory,
    RemoveFileEntry,
    RemoveDirectoryEntry,
    RenameEntry,
    CreateSymbolicLinkEntry,
    CreateHardLinkEntry,
    ReadSymbolicLinkTarget,
    StoreSymbolicLinkTarget,
    ChangePermissions,
    ChangeOwnership,
    ChangeLinkPermissions,
    ChangeLinkOwnership,
    ChangeModifiedTime,
    CopyFileEntry,
    CopyDirectoryTree,
    CloneEntry,
    OpenSourceFile,
    OpenDestinationFile,
    OpenSourceDirectory,
    EnumerateDirectory,
    BuildChildPath,
    QueryChildMetadata,
    CopyChildEntry,
    RemoveChildEntry,
    WindowsQueryReparsePoint,
    QueryFileTimes,
    SetFileTimes,
};
 
enum class FileSystemErrorContextKind : uint16_t
{
    None = 0,
    NativeError,
    RequiredBytes,
    ActualBytes,
};
 
union FileSystemErrorContext
{
    struct RequiredBytes
    {
    };
    struct ActualBytes
    {
    };
 
    uint32_t nativeError;
    uint32_t requiredBytes;
    uint32_t actualBytes;
 
    constexpr FileSystemErrorContext(uint32_t value = 0) : nativeError(value) {}
    constexpr FileSystemErrorContext(RequiredBytes, uint32_t value) : requiredBytes(value) {}
    constexpr FileSystemErrorContext(ActualBytes, uint32_t value) : actualBytes(value) {}
};
 
static constexpr ResultCategory FileSystemResultCategory = ResultCategory(11);
 
struct [[nodiscard]] ResultFileSystem
{
    Result                     result;
    FileSystemErrorDetail      detail      = FileSystemErrorDetail::None;
    FileSystemErrorContextKind contextKind = FileSystemErrorContextKind::None;
    FileSystemErrorContext     context     = {};
 
    constexpr ResultFileSystem() : result(true) {}
    explicit constexpr ResultFileSystem(bool valid) : result(valid) {}
    constexpr ResultFileSystem(FileSystemError error, FileSystemErrorDetail detail = FileSystemErrorDetail::None)
        : result(Result::Error(FileSystemResultCategory, error)), detail(detail)
    {}
    constexpr ResultFileSystem(FileSystemError error, FileSystemErrorDetail detail,
                               FileSystemErrorContextKind contextKind, FileSystemErrorContext context)
        : result(Result::Error(FileSystemResultCategory, error)), detail(detail), contextKind(contextKind),
          context(context)
    {}
    constexpr ResultFileSystem(Result result) : result(result) {}
 
    template <typename ResultLike>
    constexpr ResultFileSystem(const ResultLike& other) : result(other.toResult())
    {}
 
    static constexpr ResultFileSystem withNativeError(FileSystemError error, FileSystemErrorDetail detail,
                                                      uint32_t nativeError)
    {
        return {error, detail, FileSystemErrorContextKind::NativeError, FileSystemErrorContext(nativeError)};
    }
 
    static constexpr ResultFileSystem withRequiredBytes(FileSystemError error, FileSystemErrorDetail detail,
                                                        uint32_t requiredBytes)
    {
        return {error, detail, FileSystemErrorContextKind::RequiredBytes,
                FileSystemErrorContext(FileSystemErrorContext::RequiredBytes{}, requiredBytes)};
    }
 
    static constexpr ResultFileSystem withActualBytes(FileSystemError error, FileSystemErrorDetail detail,
                                                      uint32_t actualBytes)
    {
        return {error, detail, FileSystemErrorContextKind::ActualBytes,
                FileSystemErrorContext(FileSystemErrorContext::ActualBytes{}, actualBytes)};
    }
 
    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(FileSystemError error) const { return result.isError(FileSystemResultCategory, error); }
};
 
} // namespace SC