File.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/CompilerMacrosExport.h"
#ifndef SC_EXPORT_LIBRARY_FILE
#define SC_EXPORT_LIBRARY_FILE 0
#endif
#define SC_FILE_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_FILE)
 
#include "../Common/IGrowableBufferSpan.h"
#include "../Common/IGrowableBufferStringPath.h"
#include "../Common/PlatformMacrosInstructionSet.h"
#include "../Common/PlatformMacrosType.h"
#include "../Common/PrimitiveDefinitions.h"
#include "../Common/Result.h"
#include "../Common/Span.h"
#include "../Common/StringSpan.h"
#include "../Common/UniqueHandle.h"
 
 
namespace SC
{
namespace detail
{
#if SC_PLATFORM_WINDOWS
struct SC_FILE_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_FILE_EXPORT FileDescriptorDefinition
{
    using Handle = int; // fd
    static Result releaseHandle(Handle& handle);
 
    static constexpr Handle Invalid = -1; // invalid fd
};
#endif
} // namespace detail
 
 
enum class FileDescriptorEntryType : uint8_t
{
    Unknown,
    File,
    Directory,
    SymbolicLink,
    Other,
};
 
struct FileDescriptorStat
{
    FileDescriptorEntryType entryType = FileDescriptorEntryType::Unknown; 
 
    size_t fileSize      = 0; 
    size_t hardLinkCount = 0; 
    TimeMs creationTime;      
    TimeMs accessedTime;      
    TimeMs modifiedTime;      
 
    struct
    {
        uint32_t mode          = 0; 
        uint32_t uid           = 0; 
        uint32_t gid           = 0; 
        uint64_t inode         = 0; 
        uint64_t device        = 0; 
        uint64_t specialDevice = 0; 
        uint64_t blocks        = 0; 
        uint64_t blockSize     = 0; 
    } posix;
 
    struct
    {
        uint32_t attributes         = 0; 
        uint32_t reparseTag         = 0; 
        uint32_t volumeSerialNumber = 0; 
        uint64_t fileIndex          = 0; 
    } windows;
};
 
struct SC_FILE_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_FILE_EXPORT FileDescriptor : public UniqueHandle<detail::FileDescriptorDefinition>
{
    using UniqueHandle::UniqueHandle;
 
 
    Result openForWriteToDevNull();
 
    Result openStdOutDuplicate();
 
    Result openStdErrDuplicate();
 
    Result openStdInDuplicate();
 
    Result open(StringSpan path, FileOpen mode);
 
    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 readUntilFullOrEOF(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 writeString(StringSpan data);
 
    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, int64_t offset);
 
    Result currentPosition(size_t& position) const;
 
    Result sizeInBytes(size_t& sizeInBytes) const;
 
    Result stat(FileDescriptorStat& fileStat) const;
 
    Result chmod(uint32_t mode);
 
    Result chown(uint32_t uid, uint32_t gid);
 
    Result sync();
 
    Result syncData();
 
    Result truncate(uint64_t sizeInBytes);
 
  private:
    friend struct File;
    friend struct PipeDescriptor;
    struct Internal;
};
 
struct SC_FILE_EXPORT PipeOptions
{
    bool readInheritable  = false; 
    bool writeInheritable = false; 
    bool blocking         = true;  
};
 
struct SC_FILE_EXPORT PipeDescriptor
{
    FileDescriptor readPipe;  
    FileDescriptor writePipe; 
 
    Result createPipe(PipeOptions options = {});
 
    Result close();
};
 
struct SC_FILE_EXPORT NamedPipeNameOptions
{
    StringSpan posixDirectory = "/tmp"; 
};
 
struct SC_FILE_EXPORT NamedPipeName
{
    static Result build(StringSpan logicalName, StringPath& outName, NamedPipeNameOptions options = {});
};
 
struct SC_FILE_EXPORT NamedPipeServerOptions
{
    PipeOptions connectionOptions     = {}; 
    uint32_t    maxPendingConnections = 16; 
 
    struct Posix
    {
        bool removeEndpointOnClose      = true;  
        bool removeEndpointBeforeCreate = false; 
    } posix;
};
 
struct SC_FILE_EXPORT NamedPipeClientOptions
{
    PipeOptions connectionOptions = {}; 
    struct Windows
    {
        uint32_t connectTimeoutMilliseconds = 0xffffffff; 
    } windows;
};
 
struct SC_FILE_EXPORT NamedPipeServer
{
    Result create(StringSpan name, NamedPipeServerOptions options = {});
    Result accept(PipeDescriptor& outConnection);
    Result close();
 
  private:
    NamedPipeServerOptions options;
    StringPath             name;
#if SC_PLATFORM_WINDOWS
    FileDescriptor pendingConnection;
    bool           firstInstance = true;
#else
    FileDescriptor listeningSocket;
#endif
    bool created = false;
};
 
struct SC_FILE_EXPORT NamedPipeClient
{
    static Result connect(StringSpan name, PipeDescriptor& outConnection, NamedPipeClientOptions options = {});
};
} // namespace SC