FileDescriptor.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Result.h"
#include "../Foundation/Span.h"
#include "../Foundation/UniqueHandle.h"
 
 
namespace SC
{
struct SC_COMPILER_EXPORT FileDescriptor;
struct SC_COMPILER_EXPORT PipeDescriptor;
namespace detail
{
struct SC_COMPILER_EXPORT FileDescriptorDefinition;
}
struct SC_COMPILER_EXPORT File;
} // namespace SC
 
#if SC_PLATFORM_WINDOWS
 
struct SC::detail::FileDescriptorDefinition
{
    using Handle = void*; // HANDLE
    static Result releaseHandle(Handle& handle);
#ifdef __clang__
    static constexpr void* Invalid = __builtin_constant_p(-1) ? (void*)-1 : (void*)-1; // INVALID_HANDLE_VALUE
#else
    static constexpr void* Invalid = (void*)-1; // INVALID_HANDLE_VALUE
#endif
};
 
#else
struct SC::detail::FileDescriptorDefinition
{
    using Handle = int; // fd
    static Result releaseHandle(Handle& handle);
 
    static constexpr Handle Invalid = -1; // invalid fd
};
 
#endif
 
 
struct SC::FileDescriptor : public SC::UniqueHandle<SC::detail::FileDescriptorDefinition>
{
    using UniqueHandle::UniqueHandle;
 
    [[nodiscard]] Result openForWriteToDevNull();
 
    [[nodiscard]] Result setBlocking(bool blocking);
 
    [[nodiscard]] Result setInheritable(bool inheritable);
 
    [[nodiscard]] Result isInheritable(bool& hasValue) const;
 
    [[nodiscard]] Result read(Span<char> data, Span<char>& actuallyRead, uint64_t offset);
 
    [[nodiscard]] Result read(Span<uint8_t> data, Span<uint8_t>& actuallyRead, uint64_t offset);
 
    [[nodiscard]] Result read(Span<char> data, Span<char>& actuallyRead);
 
    [[nodiscard]] Result read(Span<uint8_t> data, Span<uint8_t>& actuallyRead);
 
    [[nodiscard]] Result write(Span<const char> data, uint64_t offset);
 
    [[nodiscard]] Result write(Span<const uint8_t> data, uint64_t offset);
 
    [[nodiscard]] Result write(Span<const char> data);
 
    [[nodiscard]] Result write(Span<const uint8_t> data);
 
    enum SeekMode
    {
        SeekStart,   
        SeekEnd,     
        SeekCurrent, 
    };
 
    [[nodiscard]] Result seek(SeekMode seekMode, uint64_t offset);
 
    [[nodiscard]] Result currentPosition(size_t& position) const;
 
    [[nodiscard]] Result sizeInBytes(size_t& sizeInBytes) const;
 
  private:
    friend struct File;
    struct Internal;
};
 
struct SC::PipeDescriptor
{
    enum InheritableReadFlag
    {
        ReadInheritable,   
        ReadNonInheritable 
    };
 
    enum InheritableWriteFlag
    {
        WriteInheritable,   
        WriteNonInheritable 
    };
    FileDescriptor readPipe;  
    FileDescriptor writePipe; 
 
    [[nodiscard]] Result createPipe(InheritableReadFlag  readFlag  = ReadNonInheritable,
                                    InheritableWriteFlag writeFlag = WriteNonInheritable);
 
    [[nodiscard]] Result close();
};