PdfPageCollection.h

 
#ifndef PDF_PAGES_TREE_H
#define PDF_PAGES_TREE_H
 
#include "PdfDeclarations.h"
 
#include "PdfElement.h"
#include "PdfArray.h"
#include "PdfPage.h"
 
namespace PoDoFo {
 
class PODOFO_API PdfPageCollection final : public PdfDictionaryElement
{
    friend class PdfDocument;
    friend class PdfPage;
 
public:
    PdfPageCollection(PdfDocument& doc);
 
    PdfPageCollection(PdfObject& pagesRoot);
 
    virtual ~PdfPageCollection();
 
    unsigned GetCount() const;
 
    PdfPage& GetPageAt(unsigned index);
    const PdfPage& GetPageAt(unsigned index) const;
 
    PdfPage& GetPage(const PdfReference& ref);
    const PdfPage& GetPage(const PdfReference& ref) const;
 
    PdfPage& CreatePage(const nullable<Rect>& size = nullptr);
    PdfPage& CreatePage(PdfPageSize pageSize);
 
    PdfPage& CreatePageAt(unsigned atIndex, const nullable<Rect>& size = nullptr);
    PdfPage& CreatePageAt(unsigned atIndex, PdfPageSize pageSize);
 
    void CreatePagesAt(unsigned atIndex, unsigned count, const nullable<Rect>& size = nullptr);
    void CreatePagesAt(unsigned atIndex, unsigned count, PdfPageSize pageSize);
 
    void AppendDocumentPages(const PdfDocument& doc);
 
    void AppendDocumentPages(const PdfDocument& doc, unsigned pageIndex, unsigned pageCount);
 
    void InsertDocumentPageAt(unsigned atIndex, const PdfDocument& doc, unsigned pageIndex);
 
    void RemovePageAt(unsigned atIndex);
 
    void FlattenStructure();
 
public:
    template <typename TObject, typename TListIterator>
    class Iterator final
    {
        friend class PdfPageCollection;
    public:
        using difference_type = void;
        using value_type = TObject*;
        using pointer = void;
        using reference = void;
        using iterator_category = std::forward_iterator_tag;
    public:
        Iterator() { }
    private:
        Iterator(const TListIterator& iterator) : m_iterator(iterator) { }
    public:
        Iterator(const Iterator&) = default;
        Iterator& operator=(const Iterator&) = default;
        bool operator==(const Iterator& rhs) const
        {
            return m_iterator == rhs.m_iterator;
        }
        bool operator!=(const Iterator& rhs) const
        {
            return m_iterator != rhs.m_iterator;
        }
        Iterator& operator++()
        {
            m_iterator++;
            return *this;
        }
        Iterator operator++(int)
        {
            auto copy = *this;
            m_iterator++;
            return copy;
        }
        value_type operator*()
        {
            return *m_iterator;
        }
        value_type operator->()
        {
            return *m_iterator;
        }
    private:
        TListIterator m_iterator;
    };
 
    using PageList = std::vector<PdfPage*>;
 
    using iterator = Iterator<PdfPage, PageList::iterator>;
    using const_iterator = Iterator<const PdfPage, PageList::const_iterator>;
 
    public:
        iterator begin();
        iterator end();
        const_iterator begin() const;
        const_iterator end() const;
 
private:
    void InsertPageAt(unsigned atIndex, PdfPage& page);
 
    void InsertPagesAt(unsigned atIndex, cspan<PdfPage*> pages);
 
    bool TryMovePageTo(unsigned atIndex, unsigned toIndex);
 
private:
    void insertPageAt(unsigned atIndex, PdfPage& page);
    void insertPagesAt(unsigned atIndex, cspan<PdfPage*> pages);
    Rect getActualRect(const nullable<Rect>& size);
 
    PdfPage& getPage(const PdfReference& ref) const;
 
    void initPages();
 
    unsigned traversePageTreeNode(PdfObject& obj, unsigned count,
        std::vector<PdfObject*>& parents, std::unordered_set<PdfObject*>& visitedNodes);
 
    PdfPageCollection(PdfPageCollection&) = delete;
    PdfPageCollection& operator=(PdfPageCollection&) = delete;
 
private:
    bool m_initialized;
    PageList m_Pages;
    PdfArray* m_kidsArray;
};
 
};
 
#endif // PDF_PAGES_TREE_H