PdfEncoding.h

 
#ifndef PDF_ENCODING_H
#define PDF_ENCODING_H
 
#include "PdfEncodingMap.h"
#include "PdfString.h"
#include "PdfObject.h"
#include "PdfCIDToGIDMap.h"
 
namespace PoDoFo
{
    class PdfFont;
    class PdfEncoding;
    class PdfFontSimple;
 
    class PODOFO_API PdfStringScanContext
    {
        friend class PdfEncoding;
 
    private:
        PdfStringScanContext(const std::string_view& encodedstr, const PdfEncoding& encoding);
 
    public:
        bool IsEndOfString() const;
 
        bool TryScan(PdfCID& cid, std::string& utf8str, CodePointSpan& codepoints);
 
    private:
        std::string_view::iterator m_it;
        std::string_view::iterator m_end;
        const PdfEncodingMap* m_encoding;
        PdfEncodingLimits m_limits;
        const PdfEncodingMap* m_toUnicode;
    };
 
    class PODOFO_API PdfEncoding final
    {
        friend class PdfEncodingFactory;
        friend class PdfFont;
        friend class PdfFontCID;
        friend class PdfFontCIDTrueType;
        friend class PdfFontSimple;
 
    public:
        PdfEncoding();
        PdfEncoding(PdfEncodingMapConstPtr encoding, PdfToUnicodeMapConstPtr toUnicode = nullptr);
        PdfEncoding(const PdfEncoding&) = default;
 
    private:
        PdfEncoding(unsigned id, PdfEncodingMapConstPtr&& encoding,
            PdfEncodingMapConstPtr&& toUnicode);
        PdfEncoding(unsigned id, bool isObjectLoaded, const PdfEncodingLimits& limits, PdfFont* font,
            PdfEncodingMapConstPtr&& encoding, PdfEncodingMapConstPtr&& toUnicode,
            PdfCIDToGIDMapConstPtr&& cidToGidMap);
 
        static PdfEncoding Create(const PdfEncodingLimits& parsedLimits, PdfEncodingMapConstPtr&& encoding,
            PdfEncodingMapConstPtr&& toUnicode, PdfCIDToGIDMapConstPtr&& cidToGidMap);
 
        static PdfEncoding Create(const PdfEncoding& ref, PdfToUnicodeMapConstPtr&& toUnicode);
 
        static std::unique_ptr<PdfEncoding> CreateSchim(const PdfEncoding& encoding, PdfFont& font);
 
        static std::unique_ptr<PdfEncoding> CreateDynamicEncoding(const std::shared_ptr<PdfCharCodeMap>& cidMap,
            const std::shared_ptr<PdfCharCodeMap>& toUnicodeMap, PdfFont& font);
 
    public:
        std::string ConvertToUtf8(const PdfString& encodedStr) const;
 
        bool TryConvertToUtf8(const PdfString& encodedStr, std::string& str) const;
 
        charbuff ConvertToEncoded(const std::string_view& str) const;
 
        bool TryConvertToEncoded(const std::string_view& str, charbuff& encoded) const;
 
        std::vector<PdfCID> ConvertToCIDs(const PdfString& encodedStr) const;
 
        bool TryConvertToCIDs(const PdfString& encodedStr, std::vector<PdfCID>& cids) const;
 
        char32_t GetCodePoint(const PdfCharCode& codeUnit) const;
 
        char32_t GetCodePoint(unsigned charCode) const;
 
        PdfStringScanContext StartStringScan(const PdfString& encodedStr);
 
    public:
        const PdfCharCode& GetFirstChar() const;
 
        const PdfCharCode& GetLastChar() const;
 
        bool IsNull() const;
 
        bool HasCIDMapping() const;
 
        bool IsSimpleEncoding() const;
 
        bool HasParsedLimits() const;
 
        bool IsDynamicEncoding() const;
 
        unsigned GetId() const { return m_Id; }
 
        bool IsObjectLoaded() const { return m_IsObjectLoaded; }
 
        const PdfEncodingLimits& GetLimits() const;
 
        bool HasValidToUnicodeMap() const;
 
        const PdfEncodingMap& GetToUnicodeMap() const;
 
        bool GetToUnicodeMapSafe(const PdfEncodingMap*& toUnicode) const;
 
        const PdfEncodingMap& GetToUnicodeMapSafe() const;
 
        const PdfEncodingMap& GetEncodingMap() const { return *m_Encoding; }
 
        PdfEncodingMapConstPtr GetEncodingMapPtr() const { return m_Encoding; }
 
        PdfEncodingMapConstPtr GetToUnicodeMapPtr() const;
 
    public:
        PdfEncoding& operator=(const PdfEncoding&) = default;
 
    private:
        // These methods will be called by PdfFont
        void ExportToFont(PdfFont& font, const PdfCIDSystemInfo& cidInfo) const;
        void ExportToFont(PdfFont& font) const;
        bool TryGetCIDId(const PdfCharCode& codeUnit, unsigned& cid) const;
        const PdfCIDToGIDMap* GetCIDToGIDMap() const { return m_CIDToGIDMap.get(); }
 
        static unsigned GetNextId();
 
    private:
        void exportToFont(PdfFont& font, const PdfCIDSystemInfo* cidInfo) const;
        bool tryExportEncodingTo(PdfDictionary& dictionary, bool wantCidMapping) const;
        bool tryConvertEncodedToUtf8(const std::string_view& encoded, std::string& str) const;
        bool tryConvertEncodedToCIDs(const std::string_view& encoded, std::vector<PdfCID>& cids) const;
        void writeCIDMapping(PdfObject& cmapObj, const PdfFont& font, const PdfCIDSystemInfo& info) const;
        void writeToUnicodeCMap(PdfObject& cmapObj, const PdfFont& font) const;
        bool tryGetCharCode(PdfFont& font, unsigned gid, const unicodeview& codePoints, PdfCharCode& unit) const;
 
    private:
        unsigned m_Id;
        bool m_IsObjectLoaded;
        PdfEncodingLimits m_ParsedLimits;
        PdfFont* m_Font;
        PdfEncodingMapConstPtr m_Encoding;
        PdfEncodingMapConstPtr m_ToUnicode;
        PdfCIDToGIDMapConstPtr m_CIDToGIDMap;
    };
}
 
#endif // PDF_ENCODING_H