FileError.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Common/Result.h"
 
namespace SC
{
 
enum class FileError : uint32_t
{
    InvalidHandle = 1,
    UnsupportedPathEncoding,
    InvalidPath,
    PathMustBeAbsolute,
    PathCapacityExceeded,
    InvalidNamedPipeName,
    InvalidState,
    OperationUnsupported,
    OpenFailed,
    CloseFailed,
    ReadFailed,
    WriteFailed,
    IncompleteWrite,
    SeekFailed,
    MetadataQueryFailed,
    PermissionsChangeFailed,
    OwnershipChangeFailed,
    SyncFailed,
    TruncateFailed,
    DuplicateFailed,
    DescriptorConfigurationFailed,
    PipeCreationFailed,
    NamedPipeCreationFailed,
    NamedPipeConnectionFailed,
    NamedPipeAcceptFailed,
    EndpointCleanupFailed,
    BufferCapacityExceeded,
    WouldBlock,
    TimedOut,
    OperationCancelled,
    PipeDisconnected,
};
 
enum class FileErrorDetail : uint16_t
{
    None = 0,
    ValidatePathEncoding,
    NormalizePath,
    ValidateAbsolutePath,
    BuildTransportPath,
    OpenFile,
    CloseDescriptor,
    ReadDescriptor,
    ReadDescriptorAtOffset,
    GrowReadBuffer,
    ResetReadBuffer,
    WriteDescriptor,
    WriteDescriptorAtOffset,
    SeekDescriptor,
    QueryDescriptorPosition,
    QueryDescriptorSize,
    QueryDescriptorMetadata,
    ChangeDescriptorPermissions,
    ChangeDescriptorOwnership,
    SynchronizeDescriptor,
    SynchronizeDescriptorData,
    TruncateDescriptor,
    GetStandardHandle,
    DuplicateStandardHandle,
    CreateAnonymousPipe,
    DuplicatePipeDescriptor,
    AssignPipeDescriptor,
    QueryDescriptorFlags,
    ConfigureDescriptorFlags,
    ValidateNamedPipeLogicalName,
    BuildNamedPipePath,
    ValidateNamedPipePath,
    CreateNamedPipeServer,
    RemoveNamedPipeEndpoint,
    BindNamedPipeServer,
    ListenNamedPipeServer,
    AcceptNamedPipeConnection,
    WaitNamedPipeClient,
    ConnectNamedPipeClient,
    DuplicateNamedPipeConnection,
};
 
enum class FileErrorContextKind : uint16_t
{
    None = 0,
    NativeError,
    RequiredBytes,
    ActualBytes,
};
 
union FileErrorContext
{
    struct RequiredBytes
    {
    };
    struct ActualBytes
    {
    };
 
    uint32_t nativeError;
    uint32_t requiredBytes;
    uint32_t actualBytes;
 
    constexpr FileErrorContext(uint32_t value = 0) : nativeError(value) {}
    constexpr FileErrorContext(RequiredBytes, uint32_t value) : requiredBytes(value) {}
    constexpr FileErrorContext(ActualBytes, uint32_t value) : actualBytes(value) {}
};
 
static constexpr ResultCategory FileResultCategory = ResultCategory(10);
 
struct [[nodiscard]] ResultFile
{
    Result               result;
    FileErrorDetail      detail      = FileErrorDetail::None;
    FileErrorContextKind contextKind = FileErrorContextKind::None;
    FileErrorContext     context     = {};
 
    constexpr ResultFile() : result(true) {}
    explicit constexpr ResultFile(bool valid) : result(valid) {}
    constexpr ResultFile(FileError error, FileErrorDetail detail = FileErrorDetail::None)
        : result(Result::Error(FileResultCategory, error)), detail(detail)
    {}
    constexpr ResultFile(FileError error, FileErrorDetail detail, FileErrorContextKind contextKind,
                         FileErrorContext context)
        : result(Result::Error(FileResultCategory, error)), detail(detail), contextKind(contextKind), context(context)
    {}
    constexpr ResultFile(Result result) : result(result) {}
 
    template <typename ResultLike>
    constexpr ResultFile(const ResultLike& other) : result(other.toResult())
    {}
 
    static constexpr ResultFile withNativeError(FileError error, FileErrorDetail detail, uint32_t nativeError)
    {
        return {error, detail, FileErrorContextKind::NativeError, FileErrorContext(nativeError)};
    }
 
    static constexpr ResultFile withRequiredBytes(FileError error, FileErrorDetail detail, uint32_t requiredBytes)
    {
        return {error, detail, FileErrorContextKind::RequiredBytes,
                FileErrorContext(FileErrorContext::RequiredBytes{}, requiredBytes)};
    }
 
    static constexpr ResultFile withActualBytes(FileError error, FileErrorDetail detail, uint32_t actualBytes)
    {
        return {error, detail, FileErrorContextKind::ActualBytes,
                FileErrorContext(FileErrorContext::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(FileError error) const { return result.isError(FileResultCategory, error); }
};
 
} // namespace SC