PdfString.h

 
#ifndef PDF_STRING_H
#define PDF_STRING_H
 
#include "PdfBaseDataTypes.h"
 
namespace PoDoFo {
 
class PODOFO_API PdfString final : private PdfDataMember, public PdfDataProvider<PdfString>
{
public:
    PdfString();
 
    PdfString(charbuff&& buff, bool isHex);
 
    ~PdfString();
 
    template<std::size_t N>
    PdfString(const char(&str)[N])
        : PdfDataMember(PdfDataType::String), m_isHex(false)
    {
        initFromUtf8String(str, N - 1, true);
    }
 
    template<typename T, typename = std::enable_if_t<std::is_same_v<T, const char*>>>
    PdfString(T str)
        : PdfDataMember(PdfDataType::String), m_isHex(false)
    {
        initFromUtf8String(str, std::char_traits<char>::length(str), false);
    }
 
    PdfString(const std::string_view& view);
    PdfString(const std::string& str);
 
    PdfString(std::string&& str);
 
    PdfString(const PdfString& rhs);
 
    PdfString(PdfString&& rhs) noexcept;
 
    static PdfString FromRaw(const bufferview& view, bool hex = true);
 
    static PdfString FromHexData(const std::string_view& hexView, const PdfStatefulEncrypt* encrypt = { });
 
    inline bool IsHex() const { return m_isHex; }
 
    PdfStringCharset GetCharset() const;
 
    bool IsEmpty() const;
 
    bool IsStringEvaluated() const;
 
    std::string_view GetString() const;
 
    std::string_view GetRawData() const;
 
    void Write(OutputStream& stream, PdfWriteFlags writeMode,
        const PdfStatefulEncrypt* encrypt, charbuff& buffer) const;
 
    PdfString& operator=(const PdfString& rhs);
    PdfString& operator=(PdfString&& rhs) noexcept;
 
    bool operator==(const PdfString& rhs) const;
    bool operator==(const char* str) const;
    bool operator==(const std::string& str) const;
    bool operator==(const std::string_view& view) const;
 
    bool operator!=(const PdfString& rhs) const;
    bool operator!=(const char* str) const;
    bool operator!=(const std::string& str) const;
    bool operator!=(const std::string_view& view) const;
 
    operator std::string_view() const;
 
private:
    // Delete constructor with nullptr
    PdfString(std::nullptr_t) = delete;
 
    void initFromUtf8String(const char* str, size_t length, bool literal);
    void ensureCharsEvaluated() const;
    void moveFrom(PdfString&& rhs);
 
private:
    struct StringData
    {
        StringData(charbuff&& buff, bool stringEvaluated);
 
        charbuff Chars;
        bool StringEvaluated;
    };
 
private:
    bool m_dataAllocated;
    bool m_isHex;    // This string is converted to hex during writing it out
    union
    {
        std::string_view m_Utf8View;
        std::shared_ptr<StringData> m_data;
    };
};
 
// Comparator to enable heterogeneous lookup in
// PdfDictionary with both PdfString and string_view
// See https://stackoverflow.com/a/31924435/213871
struct PODOFO_API PdfStringInequality
{
    using is_transparent = std::true_type;
 
    inline bool operator()(const PdfString& lhs, const PdfString& rhs) const
    {
        return lhs.GetString() < rhs.GetString();
    }
    inline bool operator()(const PdfString& lhs, const std::string_view& rhs) const
    {
        return lhs.GetString() < rhs;
    }
    bool operator()(const std::string_view& lhs, const PdfString& rhs) const
    {
        return lhs < rhs.GetString();
    }
};
 
struct PODOFO_API PdfStringHashing
{
    using is_transparent = std::true_type;
 
    inline std::size_t operator()(const std::string_view& str) const
    {
        return std::hash<std::string_view>()(str);
    }
    inline std::size_t operator()(const PdfString& str) const
    {
        return std::hash<std::string_view>()(str);
    }
};
 
struct PODOFO_API PdfStringEquality
{
    using is_transparent = std::true_type;
 
    inline bool operator()(const PdfString& lhs, const PdfString& rhs) const
    {
        return lhs.GetString() == rhs.GetString();
    }
    inline bool operator()(const PdfString& lhs, const std::string_view& rhs) const
    {
        return lhs.GetString() == rhs;
    }
    inline bool operator()(const std::string_view& lhs, const PdfString& rhs) const
    {
        return lhs == rhs.GetString();
    }
};
 
template<typename TValue>
using PdfStringMap = std::map<PdfString, TValue, PdfStringInequality>;
 
template<typename TValue>
using PdfStringHashMap = std::unordered_map<PdfString, TValue, PdfStringHashing, PdfStringEquality>;
 
}
 
#endif // PDF_STRING_H