FileSystemIteratorError.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/Result.h"
 
namespace SC
{
 
enum class FileSystemIteratorError : uint32_t
{
    NotInitialized = 1,
    InvalidRecursionState,
    UnsupportedPathEncoding,
    PathTooLong,
    RecursionLimitExceeded,
    PathResolutionFailed,
    OpenDirectoryFailed,
    DirectoryEnumerationFailed,
};
 
enum class FileSystemIteratorErrorDetail : uint16_t
{
    None = 0,
    WindowsResolveLogicalPath,
    BuildPath,
    PosixOpen,
    PosixFdOpenDir,
    WindowsFindFirstFile,
    PushRecursionState,
    PosixReadDir,
    WindowsFindNextFile,
};
 
static constexpr ResultCategory FileSystemIteratorResultCategory = ResultCategory(4);
 
struct [[nodiscard]] ResultFileSystemIterator
{
    Result result;
 
    uint32_t                      nativeError = 0;
    uint16_t                      depth       = 0;
    FileSystemIteratorErrorDetail detail      = FileSystemIteratorErrorDetail::None;
 
    explicit constexpr ResultFileSystemIterator(bool valid = true) : result(valid) {}
    constexpr ResultFileSystemIterator(FileSystemIteratorError       error,
                                       FileSystemIteratorErrorDetail detail = FileSystemIteratorErrorDetail::None,
                                       uint32_t nativeError = 0, uint32_t depth = 0)
        : result(Result::Error(FileSystemIteratorResultCategory, error)), nativeError(nativeError),
          depth(static_cast<uint16_t>(depth)), detail(detail)
    {}
    constexpr ResultFileSystemIterator(Result result) : result(result) {}
 
    template <typename ResultLike>
    constexpr ResultFileSystemIterator(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(FileSystemIteratorError error) const
    {
        return result.isError(FileSystemIteratorResultCategory, error);
    }
};
 
} // namespace SC