PdfName.h

 
#ifndef PDF_NAME_H
#define PDF_NAME_H
 
#include "PdfBaseDataTypes.h"
 
namespace PoDoFo {
 
class PODOFO_API PdfName final : private PdfDataMember, public PdfDataProvider<PdfName>
{
public:
    static const PdfName Null;
 
public:
    PdfName();
 
    ~PdfName();
 
    template<std::size_t N>
    PdfName(const char(&str)[N])
        : PdfDataMember(PdfDataType::Name)
    {
        initFromUtf8String(str, N - 1);
    }
 
    template<typename T, typename = std::enable_if_t<std::is_same_v<T, const char*>>>
    PdfName(T str)
        : PdfDataMember(PdfDataType::Name)
    {
        initFromUtf8String(str, std::char_traits<char>::length(str));
    }
 
    PdfName(const std::string_view& str);
    PdfName(const std::string& str);
    PdfName(charbuff&& buff);
 
    PdfName(const char& str, size_t length);
 
    PdfName(const PdfName& rhs);
    PdfName(PdfName&& rhs) noexcept;
 
    static PdfName FromRaw(const bufferview& rawcontent);
 
    static PdfName FromEscaped(const std::string_view& name);
 
    std::string GetEscapedName() const;
 
    void Write(OutputStream& stream, PdfWriteFlags writeMode,
        const PdfStatefulEncrypt* encrypt, charbuff& buffer) const;
 
    std::string_view GetString() const;
 
    bool IsNull() const;
 
    std::string_view GetRawData() const;
 
    PdfName& operator=(const PdfName& rhs);
    PdfName& operator=(PdfName&& rhs) noexcept;
 
    bool operator==(const PdfName& 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 PdfName& 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
    PdfName(std::nullptr_t) = delete;
 
    void expandUtf8String();
    void initFromUtf8String(const char* str, size_t length);
    void initFromUtf8String(const std::string_view& view);
    void moveFrom(PdfName&& rhs);
 
private:
    struct NameData
    {
        // The unescaped name raw data, without leading '/'.
        // It can store also the utf8 expanded string, if coincident
        charbuff Chars;
        std::unique_ptr<std::string> Utf8String;
        bool IsUtf8Expanded;
    };
private:
    bool m_dataAllocated;
    union
    {
        std::shared_ptr<NameData> m_data;
        std::string_view m_Utf8View;       // Holds only global read-only string literal
    };
};
 
inline PdfName operator""_n(const char* name, size_t length)
{
    return PdfName(*name, length);
}
 
// Comparator to enable heterogeneous lookup in
// PdfDictionary with both PdfName and string_view
// See https://stackoverflow.com/a/31924435/213871
struct PODOFO_API PdfNameInequality
{
    using is_transparent = std::true_type;
 
    bool operator()(const PdfName& lhs, const PdfName& rhs) const
    {
        return lhs.GetRawData() < rhs.GetRawData();
    }
    bool operator()(const PdfName& lhs, const std::string_view& rhs) const
    {
        return lhs.GetRawData() < rhs;
    }
    bool operator()(const std::string_view& lhs, const PdfName& rhs) const
    {
        return lhs < rhs.GetRawData();
    }
};
 
struct PODOFO_API PdfNameHashing
{
    using is_transparent = std::true_type;
 
    inline std::size_t operator()(const std::string_view& name) const
    {
        return std::hash<std::string_view>()(name);
    }
    inline std::size_t operator()(const PdfName& name) const
    {
        return std::hash<std::string_view>()(name);
    }
};
 
struct PODOFO_API PdfNameEquality
{
    using is_transparent = std::true_type;
 
    inline bool operator()(const PdfName& lhs, const PdfName& rhs) const
    {
        return lhs.GetRawData() == rhs.GetRawData();
    }
    inline bool operator()(const PdfName& lhs, const std::string_view& rhs) const
    {
        return lhs.GetRawData() == rhs;
    }
    inline bool operator()(const std::string_view& lhs, const PdfName& rhs) const
    {
        return lhs == rhs.GetRawData();
    }
};
 
template<typename TValue>
using PdfNameMap = std::map<PdfName, TValue, PdfNameInequality>;
 
template<typename TValue>
using PdfNameHashMap = std::unordered_map<PdfName, TValue, PdfNameHashing, PdfNameEquality>;
 
};
 
#endif // PDF_NAME_H