PdfObjectStream.h

 
#ifndef PDF_OBJECT_STREAM_H
#define PDF_OBJECT_STREAM_H
 
#include "PdfDeclarations.h"
 
#include "PdfEncrypt.h"
#include <podofo/auxiliary/OutputStream.h>
#include <podofo/auxiliary/InputStream.h>
#include "PdfObjectStreamProvider.h"
 
namespace PoDoFo {
 
class PdfObject;
class PdfObjectStream;
 
class PODOFO_API PdfObjectInputStream final : public InputStream
{
    friend class PdfObjectStream;
public:
    PdfObjectInputStream();
    ~PdfObjectInputStream();
    PdfObjectInputStream(PdfObjectInputStream&& rhs) noexcept;
private:
    PdfObjectInputStream(PdfObjectStream& stream, bool raw);
public:
    const PdfFilterList& GetMediaFilters() const { return m_MediaFilters; }
    const std::vector<const PdfDictionary*>& GetMediaDecodeParms() const { return m_MediaDecodeParms; }
protected:
    size_t readBuffer(char* buffer, size_t size, bool& eof) override;
    bool readChar(char& ch) override;
public:
    PdfObjectInputStream& operator=(PdfObjectInputStream&& rhs) noexcept;
private:
    PdfObjectStream* m_stream;
    std::unique_ptr<InputStream> m_input;
    PdfFilterList m_MediaFilters;
    std::vector<const PdfDictionary*> m_MediaDecodeParms;
};
 
class PODOFO_API PdfObjectOutputStream final : public OutputStream
{
    friend class PdfObjectStream;
public:
    PdfObjectOutputStream();
    ~PdfObjectOutputStream();
    PdfObjectOutputStream(PdfObjectOutputStream&& rhs) noexcept;
private:
    PdfObjectOutputStream(PdfObjectStream& stream, PdfFilterList&& filters,
        bool raw, bool append);
    PdfObjectOutputStream(PdfObjectStream& stream);
private:
    PdfObjectOutputStream(PdfObjectStream& stream, nullable<PdfFilterList> filters,
        bool raw, bool append, bool skipSetDirty);
protected:
    void writeBuffer(const char* buffer, size_t size) override;
    void flush() override;
public:
    PdfObjectOutputStream& operator=(PdfObjectOutputStream&& rhs) noexcept;
private:
    PdfObjectStream* m_stream;
    std::unique_ptr<OutputStream> m_output;
};
 
class PODOFO_API PdfObjectStream final
{
    friend class PdfObject;
    friend class PdfObjectInputStream;
    friend class PdfObjectOutputStream;
    PODOFO_PRIVATE_FRIEND(class PdfParserObject);
    PODOFO_PRIVATE_FRIEND(class PdfImmediateWriter);
 
private:
    PdfObjectStream(PdfObject& parent, std::unique_ptr<PdfObjectStreamProvider>&& provider);
 
public:
    virtual ~PdfObjectStream();
 
    PdfObjectOutputStream GetOutputStreamRaw(bool append = false);
 
    PdfObjectOutputStream GetOutputStreamRaw(const PdfFilterList& filters, bool append = false);
 
    PdfObjectOutputStream GetOutputStream(bool append = false);
 
    PdfObjectOutputStream GetOutputStream(const PdfFilterList& filters, bool append = false);
 
    PdfObjectInputStream GetInputStream(bool raw = false) const;
 
    void SetData(const bufferview& buffer, bool raw = false);
 
    void SetData(const bufferview& buffer, const PdfFilterList& filters, bool raw = false);
 
    void SetData(InputStream& stream, bool raw = false);
 
    void SetData(InputStream& stream, const PdfFilterList& filters, bool raw = false);
 
    charbuff GetCopy(bool raw = false) const;
 
    charbuff GetCopySafe() const;
 
    void CopyTo(charbuff& buffer, bool raw = false) const;
 
    void CopyToSafe(charbuff& buffer) const;
 
    void CopyTo(OutputStream& stream, bool raw = false) const;
 
    void CopyToSafe(OutputStream& stream) const;
 
    void Unwrap();
 
    void Clear();
 
    size_t GetLength() const;
 
    const PdfFilterList& GetFilters() { return m_Filters; }
 
    PdfObjectStream& operator=(const PdfObjectStream& rhs);
 
    PdfObjectStream& operator=(PdfObjectStream&& rhs) noexcept;
 
    const PdfObjectStreamProvider& GetProvider() const { return *m_Provider; }
 
    const PdfObject& GetParent() const { return *m_Parent; }
 
    PdfObject& GetParent() { return *m_Parent; }
 
private:
    void Write(OutputStream& stream, const PdfStatefulEncrypt* encrypt);
 
    void SetParent(PdfObject& parent) { m_Parent = &parent; }
 
    void InitData(InputStream& stream, size_t len, PdfFilterList&& filterList);
 
    void CopyFrom(const PdfObjectStream& rhs);
 
    void MoveFrom(PdfObjectStream& rhs);
 
    PdfObjectStreamProvider& GetProvider() { return *m_Provider; }
 
private:
    void ensureClosed() const;
 
    std::unique_ptr<InputStream> getInputStream(bool raw, PdfFilterList& mediaFilters,
        std::vector<const PdfDictionary*>& decodeParms);
 
    void setData(InputStream& stream, PdfFilterList filters, bool raw,
        ssize_t size, bool markObjectDirty);
 
private:
    PdfObjectStream(const PdfObjectStream& rhs) = delete;
 
private:
    PdfObject* m_Parent;
    std::unique_ptr<PdfObjectStreamProvider> m_Provider;
    PdfFilterList m_Filters;
    bool m_locked;
};
 
};
 
#endif // PDF_OBJECT_STREAM_H