PdfVariant.h

 
#ifndef PDF_VARIANT_H
#define PDF_VARIANT_H
 
#include "PdfReference.h"
#include "PdfName.h"
#include "PdfString.h"
 
namespace PoDoFo {
 
class PdfArray;
class PdfData;
class PdfDictionary;
class PdfString;
class PdfDataContainer;
 
class PODOFO_API PdfVariant final
{
    friend class PdfObject;
    friend class PdfArray;
    friend class PdfDictionary;
    friend class PdfTokenizer;
    PODOFO_PRIVATE_FRIEND(class PdfParserObject);
 
public:
 
    static const PdfVariant Null;
 
    PdfVariant();
 
    PdfVariant(bool value);
 
    PdfVariant(int64_t value);
 
    PdfVariant(double value);
 
    PdfVariant(const PdfString& str);
 
    PdfVariant(const PdfName& name);
 
    PdfVariant(const PdfReference& ref);
 
    PdfVariant(const PdfArray& arr);
    PdfVariant(PdfArray&& arr) noexcept;
 
    PdfVariant(const PdfDictionary& dict);
    PdfVariant(PdfDictionary&& dict) noexcept;
 
    PdfVariant(const PdfData& data);
    PdfVariant(PdfData&& data) noexcept;
 
    PdfVariant(const PdfVariant& rhs);
    PdfVariant(PdfVariant&& rhs) noexcept;
 
    ~PdfVariant();
 
    std::string_view GetDataTypeString() const;
 
    bool IsBool() const;
 
    bool IsNumber() const;
 
    bool IsRealStrict() const;
 
    bool IsNumberOrReal() const;
 
    bool IsString() const;
 
    bool IsName() const;
 
    bool IsArray() const;
 
    bool IsDictionary() const;
 
    bool IsRawData() const;
 
    bool IsNull() const;
 
    bool IsReference() const;
 
    std::string ToString(PdfWriteFlags writeFlags = PdfWriteFlags::None) const;
    void ToString(std::string& str, PdfWriteFlags writeFlags = PdfWriteFlags::None) const;
 
    bool GetBool() const;
    bool TryGetBool(bool& value) const;
 
    int64_t GetNumberLenient() const;
    bool TryGetNumberLenient(int64_t& value) const;
 
    int64_t GetNumber() const;
    bool TryGetNumber(int64_t& value) const;
 
    double GetReal() const;
    bool TryGetReal(double& value) const;
 
    double GetRealStrict() const;
    bool TryGetRealStrict(double& value) const;
 
    const PdfString& GetString() const;
    bool TryGetString(PdfString& str) const;
    bool TryGetString(const PdfString*& str) const;
 
    const PdfName& GetName() const;
    bool TryGetName(PdfName& name) const;
    bool TryGetName(const PdfName*& name) const;
 
    PdfReference GetReference() const;
    bool TryGetReference(PdfReference& ref) const;
 
    const PdfArray& GetArray() const;
    PdfArray& GetArray();
    bool TryGetArray(const PdfArray*& arr) const;
    bool TryGetArray(PdfArray*& arr);
 
    const PdfDictionary& GetDictionary() const;
    PdfDictionary& GetDictionary();
    bool TryGetDictionary(const PdfDictionary*& dict) const;
    bool TryGetDictionary(PdfDictionary*& dict);
 
    void SetBool(bool value);
 
    void SetNumber(int64_t value);
 
    void SetReal(double value);
 
    void SetName(const PdfName& name);
 
    void SetString(const PdfString& str);
 
    void SetReference(const PdfReference& ref);
 
    void Write(OutputStream& stream, PdfWriteFlags writeMode,
        const PdfStatefulEncrypt* encrypt, charbuff& buffer) const;
 
    PdfVariant& operator=(const PdfVariant& rhs);
    PdfVariant& operator=(PdfVariant&& rhs) noexcept;
 
    bool operator==(const PdfVariant& rhs) const;
 
    bool operator!=(const PdfVariant& rhs) const;
 
    PdfDataType GetDataType() const;
 
private:
    // Delete constructor with nullptr
    PdfVariant(std::nullptr_t) = delete;
 
    PdfReference GetReferenceUnsafe() const;
    const PdfDictionary& GetDictionaryUnsafe() const;
    const PdfArray& GetArrayUnsafe() const;
    PdfDictionary& GetDictionaryUnsafe();
    PdfArray& GetArrayUnsafe();
 
private:
    void assign(const PdfVariant& rhs);
    bool tryGetDictionary(PdfDictionary*& dict) const;
    bool tryGetArray(PdfArray*& arr) const;
    bool tryGetName(const PdfName*& name) const;
    bool tryGetString(const PdfString*& str) const;
    void moveFrom(PdfVariant&& rhs);
 
private:
    // Reset the variant to "null" type. To be called by PdfTokenizer
    void Reset();
 
    template<typename T>
    PdfVariant(T*) = delete;
 
    template <typename T>
    class PrimitiveMember : PdfDataMember
    {
    public:
        PrimitiveMember(T value)
            : PdfDataMember(getDataType()), Value(value) { }
 
        constexpr PdfDataType getDataType()
        {
            if (std::is_same_v<T, int64_t>)
                return PdfDataType::Number;
            else if (std::is_same_v<T, double>)
                return PdfDataType::Real;
            else if (std::is_same_v<T, bool>)
                return PdfDataType::Bool;
            else if (std::is_same_v<T, PdfDictionary*>)
                return PdfDataType::Dictionary;
            else if (std::is_same_v<T, PdfArray*>)
                return PdfDataType::Array;
            else if (std::is_same_v<T, PdfData*>)
                return PdfDataType::RawData;
            else
                return PdfDataType::Unknown;
        }
 
    public:
        T Value;
    };
 
    class NullMember : PdfDataMember
    {
    public:
        NullMember();
    };
 
    union
    {
        PdfString m_String;
        PdfName m_Name;
        PdfReference m_Reference;
        PrimitiveMember<int64_t> m_Number;
        PrimitiveMember<double> m_Real;
        PrimitiveMember<bool> m_Bool;
        PrimitiveMember<PdfDictionary*> m_Dictionary;
        PrimitiveMember<PdfArray*> m_Array;
        PrimitiveMember<PdfData*> m_Data;
        NullMember m_Null;
    };
};
 
};
 
#endif // PDF_VARIANT_H