File.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Internal/IGrowableBuffer.h"
#include "../Foundation/Result.h"
#include "../Foundation/Span.h"
#include "../Foundation/StringSpan.h"
#include "../Foundation/UniqueHandle.h"
 
 
namespace SC
{
namespace detail
{
#if SC_PLATFORM_WINDOWS
struct SC_COMPILER_EXPORT 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_COMPILER_EXPORT FileDescriptorDefinition
{
    using Handle = int; // fd
    static Result releaseHandle(Handle& handle);
 
    static constexpr Handle Invalid = -1; // invalid fd
};
#endif
} // namespace detail
 
 
struct SC_COMPILER_EXPORT FileOpen
{
    enum Mode : uint8_t
    {
        Read = 0,   
        ReadWrite,  
        Append,     
        AppendRead, 
        Write,      
        WriteRead,  
    };
 
    FileOpen(Mode mode = Read) : mode(mode) {}
 
    Mode mode;                
    bool inheritable = false; 
    bool blocking    = true;  
    bool sync        = false; 
    bool exclusive   = false; 
 
#if !SC_PLATFORM_WINDOWS
    int toPosixFlags() const;
    int toPosixAccess() const;
#endif
};
 
struct SC_COMPILER_EXPORT FileDescriptor : public UniqueHandle<detail::FileDescriptorDefinition>
{
    using UniqueHandle::UniqueHandle;
 
 
    Result openForWriteToDevNull();
 
    Result open(StringSpan path, FileOpen mode);
 
    Result setBlocking(bool blocking);
 
    Result setInheritable(bool inheritable);
 
    Result isInheritable(bool& hasValue) const;
 
    Result read(Span<char> data, Span<char>& actuallyRead, uint64_t offset);
 
    Result read(Span<uint8_t> data, Span<uint8_t>& actuallyRead, uint64_t offset);
 
    Result read(Span<char> data, Span<char>& actuallyRead);
 
    Result read(Span<uint8_t> data, Span<uint8_t>& actuallyRead);
 
    template <typename T>
    Result readUntilEOF(T& destination)
    {
        return readUntilEOF(GrowableBuffer<T>{destination});
    }
 
    Result readUntilEOF(IGrowableBuffer&& buffer);
 
    Result write(Span<const char> data, uint64_t offset);
 
    Result write(Span<const uint8_t> data, uint64_t offset);
 
    Result write(Span<const char> data);
 
    Result write(Span<const uint8_t> data);
 
    enum SeekMode
    {
        SeekStart,   
        SeekEnd,     
        SeekCurrent, 
    };
 
    Result seek(SeekMode seekMode, uint64_t offset);
 
    Result currentPosition(size_t& position) const;
 
    Result sizeInBytes(size_t& sizeInBytes) const;
 
  private:
    friend struct File;
    struct Internal;
};
 
struct SC_COMPILER_EXPORT PipeDescriptor
{
    enum InheritableReadFlag
    {
        ReadInheritable,   
        ReadNonInheritable 
    };
 
    enum InheritableWriteFlag
    {
        WriteInheritable,   
        WriteNonInheritable 
    };
    FileDescriptor readPipe;  
    FileDescriptor writePipe; 
 
    Result createPipe(InheritableReadFlag  readFlag  = ReadNonInheritable,
                      InheritableWriteFlag writeFlag = WriteNonInheritable);
 
    Result close();
};
} // namespace SC