PdfPageCollection.h

// SPDX-FileCopyrightText: 2006 Dominik Seichter <domseichter@web.de>
// SPDX-FileCopyrightText: 2021 Francesco Pretto <ceztko@gmail.com>
// SPDX-License-Identifier: LGPL-2.0-or-later OR MPL-2.0
 
#ifndef PDF_PAGES_COLLECTION_H
#define PDF_PAGES_COLLECTION_H
 
#include "PdfDeclarations.h"
 
#include "PdfElement.h"
#include "PdfArray.h"
#include "PdfPage.h"
 
namespace PoDoFo {
 
    class PODOFO_API PdfObjectRelocationMap final
    {
        friend class PdfXObjectForm;
        friend class PdfPageCollection;
    public:
        PdfObjectRelocationMap();
 
        void Clear();
    private:
        PdfObjectRelocationMap(const PdfObjectRelocationMap&) = delete;
        PdfObjectRelocationMap& operator=(const PdfObjectRelocationMap& rhs) = delete;
 
    private:
        std::unordered_map<PdfReference, PdfObject*> Map;
    };
 
    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;
        bool TryGetPage(const PdfReference& ref, PdfPage*& page);
        bool TryGetPage(const PdfReference& ref, const PdfPage*& page) 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, PdfObjectRelocationMap* map = nullptr);
 
        void InsertDocumentPageAt(unsigned atIndex, const PdfDocument& doc, unsigned pageIndex, PdfObjectRelocationMap* map = nullptr);
 
        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, std::unique_ptr<PdfPage> page);
 
        void InsertPagesAt(unsigned atIndex, mspan<std::unique_ptr<PdfPage>> pages);
 
        bool TryMovePageTo(unsigned atIndex, unsigned toIndex);
 
    private:
        void insertPageAt(unsigned atIndex, std::unique_ptr<PdfPage> page);
        void insertPagesAt(unsigned atIndex, mspan<std::unique_ptr<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_COLLECTION_H