PdfCharCodeMap.h

 
#ifndef PDF_CHAR_CODE_MAP_H
#define PDF_CHAR_CODE_MAP_H
 
#include "PdfDeclarations.h"
#include "PdfEncodingCommon.h"
 
namespace PoDoFo
{
    using codepoint = char32_t;
    using codepointview = cspan<codepoint>;
 
    class PODOFO_API CodePointSpan final
    {
    public:
        CodePointSpan();
        ~CodePointSpan();
        CodePointSpan(codepoint codepoint);
        CodePointSpan(const codepointview& view);
        CodePointSpan(const codepointview& view, codepoint codepoint);
        CodePointSpan(const CodePointSpan&);
        void CopyTo(std::vector<codepoint>& codePoints) const;
        codepointview view() const;
        unsigned GetSize() const;
        CodePointSpan& operator=(const CodePointSpan&);
        operator codepointview() const;
 
        codepoint operator*() const;
 
    private:
        union
        {
            struct
            {
                uint32_t Size;
                std::array<codepoint, 3> Data;
            } m_Block;
 
            struct
            {
                uint32_t Size;
                std::unique_ptr<codepoint[]> Data;
            } m_Array;
        };
    };
 
    // Map code units -> code point(s)
    // pp. 474-475 of PdfReference 1.7 "The value of dstString can be a string of up to 512 bytes"
    using CodeUnitMap = std::unordered_map<PdfCharCode, CodePointSpan>;
 
    struct PODOFO_API CodeUnitRange final
    {
        PdfCharCode SrcCodeLo;
        unsigned Size = 0;
        CodePointSpan DstCodeLo;
 
        PdfCharCode GetSrcCodeHi() const;
    };
 
    struct PODOFO_API CodeUnitRangeInequality
    {
        using is_transparent = std::true_type;
 
        bool operator()(const CodeUnitRange& lhs, const PdfCharCode& rhs) const
        {
            return lhs.SrcCodeLo < rhs;
        }
        bool operator()(const PdfCharCode& lhs, const CodeUnitRange& rhs) const
        {
            return lhs < rhs.SrcCodeLo;
        }
        bool operator()(const CodeUnitRange& lhs, const CodeUnitRange& rhs) const
        {
            return lhs.SrcCodeLo < rhs.SrcCodeLo;
        }
    };
 
    using CodeUnitRanges = std::set<CodeUnitRange, CodeUnitRangeInequality>;
 
    class PODOFO_API PdfCharCodeMap final
    {
        PODOFO_PRIVATE_FRIEND(class PdfCMapEncodingFactory);
 
    public:
        PdfCharCodeMap();
 
        PdfCharCodeMap(PdfCharCodeMap&& map) noexcept;
 
        ~PdfCharCodeMap();
 
    private:
        PdfCharCodeMap(CodeUnitMap&& mapping, CodeUnitRanges&& ranges, const PdfEncodingLimits& limits);
 
    public:
        void PushMapping(const PdfCharCode& codeUnit, const codepointview& codePoints);
 
        void PushMapping(const PdfCharCode& codeUnit, codepoint codePoint);
 
        void PushRange(const PdfCharCode& srcCodeLo, unsigned size, codepoint dstCodeLo);
 
        void PushRange(const PdfCharCode& srcCodeLo, unsigned size, const codepointview& dstCodeLo);
 
        bool TryGetCodePoints(const PdfCharCode& codeUnit, CodePointSpan& codePoints) const;
 
        bool TryGetNextCharCode(std::string_view::iterator& it,
            const std::string_view::iterator& end, PdfCharCode& code) const;
 
        bool TryGetCharCode(const codepointview& codePoints, PdfCharCode& code) const;
 
        bool TryGetCharCode(codepoint codePoint, PdfCharCode& code) const;
 
        PdfCharCodeMap& operator=(PdfCharCodeMap&& map) noexcept;
 
        const PdfEncodingLimits& GetLimits() const { return m_Limits; }
 
        bool IsEmpty() const;
 
        bool IsTrivialIdentity() const;
 
        std::vector<unsigned char> GetCodeRangeSizes() const;
 
    public:
        const CodeUnitMap& GetMappings() const { return m_Mappings; }
 
        const CodeUnitRanges& GetRanges() const { return m_Ranges; }
 
    private:
        void move(PdfCharCodeMap& map) noexcept;
        void pushMapping(const PdfCharCode& codeUnit, const codepointview& codePoints);
 
        // Map code point(s) -> code units
        struct CodePointMapNode
        {
            codepoint CodePoint;
            PdfCharCode CodeUnit;
            CodePointMapNode* Ligatures;
            CodePointMapNode* Left;
            CodePointMapNode* Right;
        };
 
    private:
        PdfCharCodeMap(const PdfCharCodeMap&) = delete;
        PdfCharCodeMap& operator=(const PdfCharCodeMap&) = delete;
 
    private:
        void updateLimits(const PdfCharCode& codeUnit);
        void reviseCodePointMap();
        bool tryFixNextRanges(const CodeUnitRanges::iterator& it, unsigned prevRangeCodeUpper);
        static bool tryFindNextCharacterId(const CodePointMapNode* node, std::string_view::iterator &it,
            const std::string_view::iterator& end, PdfCharCode& cid);
        static const CodePointMapNode* findNode(const CodePointMapNode* node, codepoint codePoint);
        static void deleteNode(CodePointMapNode* node);
        static CodePointMapNode* findOrAddNode(CodePointMapNode*& node, codepoint codePoint);
 
    private:
        PdfEncodingLimits m_Limits;
        CodeUnitMap m_Mappings;
        CodeUnitRanges m_Ranges;
        bool m_MapDirty;
        CodePointMapNode* m_codePointMapHead;           // Head of a BST to lookup code points
    };
}
 
#endif // PDF_CHAR_CODE_MAP_H