PdfMemDocument.h

// SPDX-FileCopyrightText: 2006 Dominik Seichter <domseichter@web.de>
// SPDX-FileCopyrightText: 2020 Francesco Pretto <ceztko@gmail.com>
// SPDX-License-Identifier: LGPL-2.0-or-later OR MPL-2.0
 
#ifndef PDF_MEM_DOCUMENT_H
#define PDF_MEM_DOCUMENT_H
 
#include <podofo/auxiliary/InputDevice.h>
#include <podofo/auxiliary/OutputDevice.h>
 
#include "PdfDocument.h"
#include "PdfEncrypt.h"
 
namespace PoDoFo {
 
class PdfParser;
class PdfEncryptSession;
 
class PODOFO_API PdfMemDocument final : public PdfDocument
{
    PODOFO_PRIVATE_FRIEND(class PdfWriter);
 
public:
    PdfMemDocument();
 
    PdfMemDocument(std::shared_ptr<InputStreamDevice> device, const std::string_view& password);
 
    PdfMemDocument(std::shared_ptr<InputStreamDevice> device, PdfLoadOptions opts = PdfLoadOptions::None, const std::string_view& password = { });
 
    PdfMemDocument(const PdfMemDocument& rhs);
 
    ~PdfMemDocument();
 
    void Load(const std::string_view& filename, const std::string_view& password);
 
    void Load(const std::string_view& filename, PdfLoadOptions opts = PdfLoadOptions::None, const std::string_view& password = { });
 
    void LoadFromBuffer(const bufferview& buffer, const std::string_view& password);
 
    void LoadFromBuffer(const bufferview& buffer, PdfLoadOptions opts = PdfLoadOptions::None, const std::string_view& password = { });
 
    void Load(std::shared_ptr<InputStreamDevice> device, const std::string_view& password);
 
    void Load(std::shared_ptr<InputStreamDevice> device, PdfLoadOptions opts = PdfLoadOptions::None, const std::string_view& password = { });
    void Save(const std::string_view& filename, PdfSaveOptions opts = PdfSaveOptions::None);
 
    void Save(OutputStreamDevice& device, PdfSaveOptions opts = PdfSaveOptions::None);
 
    void SaveUpdate(const std::string_view& filename, PdfSaveOptions opts = PdfSaveOptions::None);
 
    void SaveUpdate(OutputStreamDevice& device, PdfSaveOptions opts = PdfSaveOptions::None);
 
    void SetEncrypted(const std::string_view& userPassword, const std::string_view& ownerPassword,
        PdfPermissions protection = PdfPermissions::Default,
        PdfEncryptionAlgorithm algorithm = PdfEncryptionAlgorithm::AESV3R6,
        PdfKeyLength keyLength = PdfKeyLength::Unknown);
 
    void SetEncrypt(std::unique_ptr<PdfEncrypt>&& encrypt);
 
    bool HasOwnerPermissions() const override;
 
    const PdfEncrypt* GetEncrypt() const override;
 
    inline size_t GetMagicOffset() const { return m_MagicOffset; }
 
    inline bool HasBrokenXRef() const { return m_HasBrokenXRef; }
 
protected:
    void SetPdfVersion(PdfVersion version) override;
 
    PdfVersion GetPdfVersion() const override;
 
private:
    PdfMemDocument(bool empty);
 
private:
    void loadFromDevice(std::shared_ptr<InputStreamDevice>&& device, PdfLoadOptions opts, const std::string_view& password);
 
    void initFromParser(PdfParser& parser);
 
    void clear() override;
 
    void reset() override;
 
    void beforeWrite(PdfSaveOptions options, bool isUpdate);
 
    void pruneCompressedObjectStreams(PdfSaveOptions options);
 
private:
    PdfMemDocument& operator=(const PdfMemDocument&) = delete;
 
private:
    PdfVersion m_Version;
    PdfVersion m_InitialVersion;
    bool m_HasXRefStream;
    bool m_HasBrokenXRef;
    bool m_initiallyEncrypted;
    size_t m_MagicOffset;
    size_t m_PrevXRefOffset;
    std::unique_ptr<PdfEncryptSession> m_Encrypt;
    std::shared_ptr<InputStreamDevice> m_device;
};
 
};
 
 
#endif  // PDF_MEM_DOCUMENT_H