StreamDevice.h

 
#ifndef AUX_STREAM_DEVICE_H
#define AUX_STREAM_DEVICE_H
 
#include <cstring>
#include <ostream>
#include <fstream>
#include <cstdio>
#include <vector>
 
#include "basetypes.h"
 
#include "InputDevice.h"
#include "OutputDevice.h"
 
namespace PoDoFo {
 
class PODOFO_API StreamDevice : public InputStreamDevice, public OutputStreamDevice
{
protected:
    StreamDevice(DeviceAccess access);
 
protected:
    static size_t SeekPosition(size_t curpos, size_t devlen, ssize_t offset, SeekDirection direction);
};
 
class PODOFO_API StandardStreamDevice : public StreamDevice
{
public:
    StandardStreamDevice(std::ostream& stream);
 
    StandardStreamDevice(std::istream& stream);
 
    StandardStreamDevice(std::iostream& stream);
 
    ~StandardStreamDevice();
 
public:
    size_t GetLength() const override;
 
    size_t GetPosition() const override;
 
    bool CanSeek() const override;
 
    bool Eof() const override;
 
protected:
    StandardStreamDevice(DeviceAccess access, std::ios& stream, bool streamOwned);
    void writeBuffer(const char* buffer, size_t size) override;
    void flush() override;
    size_t readBuffer(char* buffer, size_t size, bool& eof) override;
    bool readChar(char& ch) override;
    bool peek(char& ch) const override;
    void seek(ssize_t offset, SeekDirection direction) override;
    void truncate() override;
 
    inline std::ios& GetStream() { return *m_Stream; }
 
private:
    StandardStreamDevice(DeviceAccess access, std::ios* stream, std::istream* istream, std::ostream* ostream, bool streamOwned);
 
private:
    std::ios* m_Stream;
    std::istream* m_istream;
    std::ostream* m_ostream;
    bool m_StreamOwned;
};
 
// These are the .NET System.IO file opening modes
// https://docs.microsoft.com/en-us/dotnet/api/system.io.filemode?view=net-6.0
enum class FileMode : uint8_t
{
    CreateNew = 1,     
    Create,            
    Open,              
    OpenOrCreate,      
    Truncate,          
    Append,            
};
 
class PODOFO_API FileStreamDevice : public StreamDevice
{
public:
    FileStreamDevice(const std::string_view & filepath);
 
    FileStreamDevice(const std::string_view & filepath, FileMode mode);
 
    FileStreamDevice(const std::string_view& filepath, FileMode mode,
        DeviceAccess access);
 
    ~FileStreamDevice();
 
public:
    const std::string& GetFilepath() const { return m_Filepath; }
 
    size_t GetLength() const override;
 
    size_t GetPosition() const override;
 
    bool CanSeek() const override;
 
    bool Eof() const override;
 
protected:
    void writeBuffer(const char* buffer, size_t size) override;
    void flush() override;
    size_t readBuffer(char* buffer, size_t size, bool& eof) override;
    bool readChar(char& ch) override;
    bool peek(char& ch) const override;
    void seek(ssize_t offset, SeekDirection direction) override;
    void close() override;
    void truncate() override;
 
private:
    FILE* m_file;
    std::string m_Filepath;
};
 
template <typename TContainer>
class ContainerStreamDevice : public StreamDevice
{
public:
    ContainerStreamDevice(TContainer& container,
        DeviceAccess access, bool ate) :
        StreamDevice(access),
        m_container(&container),
        m_Position(ate ? container.size() : 0) { }
 
    ContainerStreamDevice(const TContainer& container) :
        ContainerStreamDevice(const_cast<TContainer&>(container), DeviceAccess::Read, false) { }
 
    ContainerStreamDevice(TContainer& container) :
        ContainerStreamDevice(container, DeviceAccess::ReadWrite, true) { }
 
public:
    size_t GetLength() const override { return m_container->size(); }
 
    size_t GetPosition() const override { return m_Position; }
 
    bool CanSeek() const override { return true; }
 
    bool Eof() const override { return m_Position == m_container->size(); }
 
protected:
    void writeBuffer(const char* buffer, size_t size) override
    {
        if (m_Position + size > m_container->size())
            m_container->resize(m_Position + size);
 
        std::memcpy(m_container->data() + m_Position, buffer, size);
        m_Position += size;
    }
 
    size_t readBuffer(char* buffer, size_t size, bool& eof) override
    {
        size_t readCount = std::min(size, m_container->size() - m_Position);
        std::memcpy(buffer, m_container->data() + m_Position, readCount);
        m_Position += readCount;
        eof = m_Position == m_container->size();
        return readCount;
    }
 
    bool readChar(char& ch) override
    {
        if (m_Position == m_container->size())
        {
            ch = '\0';
            return false;
        }
 
        ch = m_container->data()[m_Position];
        m_Position++;
        return true;
    }
 
    bool peek(char& ch) const override
    {
        if (m_Position == m_container->size())
        {
            ch = '\0';
            return false;
        }
 
        ch = m_container->data()[m_Position];
        return true;
    }
 
    void seek(ssize_t offset, SeekDirection direction) override
    {
        m_Position = SeekPosition(m_Position, m_container->size(), offset, direction);
    }
 
    void truncate() override
    {
        m_container->resize(m_Position);
    }
 
private:
    TContainer* m_container;
    size_t m_Position;
};
 
class PODOFO_API SpanStreamDevice : public StreamDevice
{
public:
    SpanStreamDevice(const char* buffer, size_t size);
    SpanStreamDevice(const bufferview& buffer);
    SpanStreamDevice(const std::string_view& view);
    SpanStreamDevice(const std::string& str);
    SpanStreamDevice(std::string& str,
        DeviceAccess access = DeviceAccess::ReadWrite);
    SpanStreamDevice(const char* str);
    SpanStreamDevice(char* buffer, size_t size,
        DeviceAccess access = DeviceAccess::ReadWrite);
    SpanStreamDevice(const bufferspan& span,
        DeviceAccess access = DeviceAccess::ReadWrite);
 
public:
    size_t GetLength() const override;
 
    size_t GetPosition() const override;
 
    bool Eof() const override;
 
    bool CanSeek() const override;
 
protected:
    void writeBuffer(const char* buffer, size_t size) override;
    size_t readBuffer(char* buffer, size_t size, bool& eof) override;
    bool readChar(char& ch) override;
    bool peek(char& ch) const override;
    void seek(ssize_t offset, SeekDirection direction) override;
    void truncate() override;
 
private:
    SpanStreamDevice(std::nullptr_t) = delete;
 
private:
    char* m_buffer;
    size_t m_Length;
    size_t m_Position;
};
 
class PODOFO_API NullStreamDevice final : public StreamDevice
{
public:
    NullStreamDevice();
 
public:
    size_t GetLength() const override;
 
    size_t GetPosition() const override;
 
    bool Eof() const override;
 
protected:
    void writeBuffer(const char* buffer, size_t size) override;
    size_t readBuffer(char* buffer, size_t size, bool& eof) override;
    bool readChar(char& ch) override;
    bool peek(char& ch) const override;
    void seek(ssize_t offset, SeekDirection direction) override;
    void truncate() override;
 
private:
    size_t m_Length;
    size_t m_Position;
};
 
using VectorStreamDevice = ContainerStreamDevice<std::vector<char>>;
using StringStreamDevice = ContainerStreamDevice<std::string>;
using BufferStreamDevice = ContainerStreamDevice<charbuff>;
 
}
 
#endif // AUX_STREAM_DEVICE_H