PdfIndirectObjectList.h

// SPDX-FileCopyrightText: 2005 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_INDIRECT_OBJECT_LIST_H
#define PDF_INDIRECT_OBJECT_LIST_H
 
#include "PdfObject.h"
 
namespace PoDoFo {
 
class PdfObjectStreamProvider;
using PdfFreeObjectList = std::deque<PdfReference>;
using PdfObjectNumSet = std::set<uint32_t>;
 
enum class PdfGarbageCollectionFlags : uint32_t
{
    None = 0,
    SkipFixInvalidRefs = 1,      
};
 
class PODOFO_API PdfIndirectObjectList final
{
    friend class PdfDocument;
    friend class PdfMemDocument;
    friend class PdfObject;
    friend class PdfObjectOutputStream;
    PODOFO_PRIVATE_FRIEND(class PdfObjectStreamParser);
    PODOFO_PRIVATE_FRIEND(class PdfImmediateWriter);
    PODOFO_PRIVATE_FRIEND(class PdfParser);
    PODOFO_PRIVATE_FRIEND(class PdfWriter);
    PODOFO_PRIVATE_FRIEND(class PdfParserTest);
    PODOFO_PRIVATE_FRIEND(class PdfEncodingTest);
    PODOFO_PRIVATE_FRIEND(class PdfEncryptTest);
 
private:
    // NOTE: For testing only
    PdfIndirectObjectList();
 
public:
    ~PdfIndirectObjectList();
 
public:
    PdfObject& MustGetObject(const PdfReference& ref) const;
 
    PdfObject* GetObject(const PdfReference& ref) const;
 
    PdfObject& CreateDictionaryObject(const PdfName& type = PdfName::Null,
        const PdfName& subtype = PdfName::Null);
 
    PdfObject& CreateArrayObject();
 
    PdfObject& CreateObject(const PdfObject& obj);
    PdfObject& CreateObject(PdfObject&& obj);
 
    void CollectGarbage(PdfGarbageCollectionFlags flags = PdfGarbageCollectionFlags::None);
 
public:
    unsigned GetSize() const;
 
    unsigned GetObjectCount() const;
 
    inline uint32_t GetLastObjectNumber() const { return m_LastObjectNumber; }
 
    inline const PdfFreeObjectList& GetFreeObjects() const { return m_FreeObjects; }
 
    inline const PdfObjectNumSet& GetUnavailableObjects() const { return m_UnavailableObjects; }
 
    inline PdfDocument& GetDocument() const { return *m_Document; }
 
private:
    class PODOFO_API Observer
    {
        friend class PdfIndirectObjectList;
    public:
        virtual ~Observer() { }
 
        virtual void BeginAppendStream(PdfObjectStream& stream) = 0;
 
        virtual void EndAppendStream(PdfObjectStream& stream) = 0;
    };
 
    class PODOFO_API StreamFactory
    {
    public:
        virtual ~StreamFactory() { }
 
        virtual std::unique_ptr<PdfObjectStreamProvider> CreateStream() = 0;
    };
 
    using ReferenceSet = std::set<PdfReference>;
    using ObserverList = std::vector<Observer*>;
    using ObjectList = std::set<PdfObject*, PdfObjectInequality>;
 
public:
 
    // An incomplete set of container typedefs, just enough to handle
    // the begin() and end() methods we wrap from the internal vector.
    // TODO: proper wrapper iterator class.
    using iterator = ObjectList::const_iterator;
    using reverse_iterator = ObjectList::const_reverse_iterator;
 
    iterator begin() const;
 
    iterator end() const;
 
    reverse_iterator rbegin() const;
 
    reverse_iterator rend() const;
 
    size_t size() const;
 
private:
    PdfIndirectObjectList(PdfDocument& document);
    PdfIndirectObjectList(PdfDocument& document, const PdfIndirectObjectList& rhs);
 
    PdfIndirectObjectList(const PdfIndirectObjectList&) = delete;
    PdfIndirectObjectList& operator=(const PdfIndirectObjectList&) = delete;
 
private:
    void CollectGarbage(PdfObject& trailer, bool fixInvalidReference);
 
    std::unique_ptr<PdfObjectStreamProvider> CreateStream();
 
    std::unique_ptr<PdfObject> RemoveObject(const PdfReference& ref);
 
    std::unique_ptr<PdfObject> RemoveObject(const iterator& it);
 
    void Clear();
 
    void AttachObserver(Observer& observer);
 
    void DetachObserver(Observer& observer);
 
    void BeginAppendStream(PdfObjectStream& stream);
 
    void EndAppendStream(PdfObjectStream& stream);
 
    void PushObject(std::unique_ptr<PdfObject> obj);
 
    void AddFreeObjectSafe(const PdfReference& reference);
 
    void AddFreeObjectUnchecked(const PdfReference& reference);
 
    void AddUnavailableObject(uint32_t objNum);
 
    void AddCompressedObjectStream(uint32_t objectNum);
 
    void ClearCompressedObjectStreams();
 
    void RemoveCompressedObjectStream(uint32_t objectNum);
 
    bool IsCompressedObjectStream(uint32_t objectNum) const;
 
    inline const PdfObjectNumSet& GetCompressedObjectStreams() const { return m_compressedObjectStreams; }
 
    std::unique_ptr<PdfObject> RemoveObject(const PdfReference& ref, bool markAsFree);
 
    void SetStreamFactory(StreamFactory* factory);
 
    void ResetFreeObjectsInvalidated();
 
    bool AreFreeObjectsInvalidated() const { return m_FreeObjectsInvalidated; }
 
private:
    void markObjectFree(const PdfReference& reference, bool doConsistencyCheck);
 
    void pushObject(const ObjectList::const_iterator& hintpos, ObjectList::node_type& node, PdfObject* obj);
 
    std::unique_ptr<PdfObject> removeObject(const iterator& it, bool markAsFree);
 
    void addNewObject(std::unique_ptr<PdfObject>&& obj);
 
    PdfReference getNextFreeObject();
 
    void visitObject(PdfObject& obj, std::unordered_set<PdfReference>& referencedObj, bool fixInvalidReference);
 
    void tryIncrementLastObjectNumber(uint32_t objNum);
 
private:
    PdfDocument* m_Document;
    ObjectList m_Objects;
    unsigned m_LastObjectNumber;
    bool m_FreeObjectsInvalidated;
    PdfFreeObjectList m_FreeObjects;
    PdfObjectNumSet m_UnavailableObjects;
    PdfObjectNumSet m_compressedObjectStreams;
 
    ObserverList m_observers;
    StreamFactory* m_StreamFactory;
};
 
};
 
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfGarbageCollectionFlags);
 
#endif // PDF_INDIRECT_OBJECT_LIST_H