FileDescriptor.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Result.h"
#include "../Foundation/Span.h"
#include "../Foundation/UniqueHandle.h"
#include "../Strings/StringView.h"
 
namespace SC
{
struct String;
template <typename T>
struct Vector;
 
struct SC_COMPILER_EXPORT FileDescriptor;
struct SC_COMPILER_EXPORT PipeDescriptor;
namespace detail
{
struct SC_COMPILER_EXPORT FileDescriptorDefinition;
}
} // 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;
    enum OpenMode
    {
        ReadOnly,            
        WriteCreateTruncate, 
        WriteAppend,         
        ReadAndWrite         
    };
 
    struct OpenOptions
    {
        bool inheritable = false; 
        bool blocking    = true;  
    };
 
    [[nodiscard]] Result open(StringView path, OpenMode mode);
 
    [[nodiscard]] Result open(StringView path, OpenMode mode, OpenOptions options);
 
    [[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;
 
    [[nodiscard]] Result readUntilEOF(Vector<char>& destination);
 
    [[nodiscard]] Result readUntilEOF(Vector<uint8_t>& destination);
 
    [[nodiscard]] Result readUntilEOF(String& destination);
 
  private:
    struct Internal;
    struct ReadResult;
    template <typename T>
    Result readUntilEOFTemplate(Vector<T>& destination);
};
 
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();
};