PdfObject.h

// SPDX-FileCopyrightText: 2005 Dominik Seichter <domseichter@web.de>
// SPDX-FileCopyrightText: 2020 Francesco Pretto <ceztko@gmail.com>
// SPDX-License-Identifier: LGPL-2.0-or-later OR MPL-2.0
 
#ifndef PDF_OBJECT_H
#define PDF_OBJECT_H
 
#include "PdfVariant.h"
#include "PdfObjectStream.h"
 
namespace PoDoFo {
 
class PdfEncrypt;
class PdfIndirectObjectList;
class PdfDictionary;
class PdfArray;
class PdfDocument;
class PdfDataContainer;
 
class PODOFO_API PdfObject
{
    friend class PdfIndirectObjectList;
    friend class PdfArray;
    friend class PdfDictionary;
    friend class PdfDocument;
    friend class PdfObjectStream;
    friend class PdfObjectOutputStream;
    friend class PdfDataContainer;
    friend class PdfDictionaryElement;
    friend class PdfArrayElement;
    friend class PdfTokenizer;
    PODOFO_PRIVATE_FRIEND(class PdfStreamedObjectStream);
    PODOFO_PRIVATE_FRIEND(class PdfObjectStreamParser);
    PODOFO_PRIVATE_FRIEND(class PdfParser);
    PODOFO_PRIVATE_FRIEND(class PdfParserObject);
    PODOFO_PRIVATE_FRIEND(class PdfWriter);
    PODOFO_PRIVATE_FRIEND(class PdfImmediateWriter);
    PODOFO_PRIVATE_FRIEND(class PdfXRef);
    PODOFO_PRIVATE_FRIEND(class PdfXRefStream);
 
public:
    static const PdfObject Null;
 
public:
 
    PdfObject();
 
    PdfObject(std::nullptr_t);
 
    virtual ~PdfObject();
 
    PdfObject(const PdfVariant& var);
    PdfObject(PdfVariant&& var) noexcept;
 
    PdfObject(bool b);
 
    PdfObject(int64_t l);
 
    PdfObject(double d);
 
    PdfObject(const PdfString& str);
 
    PdfObject(const PdfName& name);
 
    PdfObject(const PdfReference& ref);
 
    PdfObject(const PdfArray& arr);
    PdfObject(PdfArray&& arr) noexcept;
 
    PdfObject(const PdfDictionary& dict);
    PdfObject(PdfDictionary&& dict) noexcept;
 
    PdfObject(const PdfObject& rhs);
    PdfObject(PdfObject&& rhs) noexcept;
 
public:
    PdfDataType GetDataType() const;
 
    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);
    bool TryGetArray(PdfArray& arr) const;
 
    const PdfDictionary& GetDictionary() const;
    PdfDictionary& GetDictionary();
    bool TryGetDictionary(const PdfDictionary*& dict) const;
    bool TryGetDictionary(PdfDictionary*& dict);
    bool TryGetDictionary(PdfDictionary& dict) const;
 
    void SetBool(bool b);
 
    void SetNumber(int64_t l);
 
    void SetReal(double d);
 
    void SetName(const PdfName& name);
 
    void SetString(const PdfString& str);
 
    void SetReference(const PdfReference& ref);
 
    void ForceCreateStream();
 
    void Write(OutputStream& stream, PdfWriteFlags writeMode,
        const PdfStatefulEncrypt* encrypt, charbuff& buffer) const;
 
    PdfObjectStream& GetOrCreateStream();
 
    /* Remove the object stream, if it has one
     */
    void RemoveStream();
 
    const PdfObjectStream& MustGetStream() const;
 
    PdfObjectStream& MustGetStream();
 
    virtual bool TryUnload();
 
    bool HasStream() const;
 
    bool IsIndirect() const;
 
    const PdfVariant& GetVariant() const;
 
public:
    bool operator<(const PdfObject& rhs) const;
 
    bool operator==(const PdfObject& rhs) const;
 
    bool operator!=(const PdfObject& rhs) const;
 
    bool operator==(const PdfVariant& rhs) const;
 
    bool operator!=(const PdfVariant& rhs) const;
 
    PdfObject& operator=(const PdfObject& rhs);
    PdfObject& operator=(PdfObject&& rhs) noexcept;
 
    operator const PdfVariant& () const;
 
public:
    inline bool IsDirty() const { return m_IsDirty; }
 
    inline PdfDocument* GetDocument() const { return m_Document; }
 
    PdfDocument& MustGetDocument() const;
 
    inline const PdfReference& GetIndirectReference() const { return m_IndirectReference; }
 
    inline const PdfDataContainer* GetParent() const { return m_Parent; }
 
    inline bool IsDelayedLoadDone() const { return m_IsDelayedLoadDone; }
 
    inline bool IsDelayedLoadStreamDone() const { return m_IsDelayedLoadStreamDone; }
 
    const PdfObjectStream* GetStream() const;
    PdfObjectStream* GetStream();
 
private:
    PdfObject(PdfVariant&& var, const PdfReference& indirectReference, bool isDirty);
 
    PdfObject(PdfArray* arr);
 
protected:
    void DelayedLoad() const;
 
    virtual void delayedLoad();
 
    virtual void delayedLoadStream();
 
    virtual bool removeStream();
 
    virtual bool HasStreamToParse() const;
 
    void SetDirty();
 
    void resetDirty();
 
    void SetDocument(PdfDocument* document);
 
    void SetVariantOwner();
 
    void FreeStream();
 
    PdfObjectStream& getOrCreateStream();
 
    void forceCreateStream();
 
    PdfObjectStream* getStream();
 
    void DelayedLoadStream() const;
 
    void EnableDelayedLoadingStream();
 
    void MakeDelayedLoadingStreamDone();
 
    inline void SetIndirectReference(const PdfReference& reference) { m_IndirectReference = reference; }
 
    void EnableDelayedLoading();
 
    virtual void SetRevised();
 
private:
    // To be called privately by various classes
    PdfVariant& GetVariantUnsafe() { return m_Variant; }
    PdfReference GetReferenceUnsafe() const { return m_Variant.GetReferenceUnsafe(); }
    const PdfDictionary& GetDictionaryUnsafe() const { return m_Variant.GetDictionaryUnsafe(); }
    const PdfArray& GetArrayUnsafe() const { return m_Variant.GetArrayUnsafe(); }
    PdfDictionary& GetDictionaryUnsafe() { return m_Variant.GetDictionaryUnsafe(); }
    PdfArray& GetArrayUnsafe() { return m_Variant.GetArrayUnsafe(); }
    void WriteFinal(OutputStream& stream, PdfWriteFlags writeMode,
        const PdfStatefulEncrypt* encrypt, charbuff& buffer);
 
    // To be called by PdfStreamedObjectStream
    void SetNumberNoDirtySet(int64_t l);
 
    // To be called by PdfImmediateWriter
    void SetImmutable();
    void WriteHeader(OutputStream& stream, PdfWriteFlags writeMode, charbuff& buffer) const;
 
    // To be called by PdfDataContainer
    bool IsImmutable() const { return m_IsImmutable; }
 
    // NOTE: It also doesn't dirty set the moved "obj"
    void AssignNoDirtySet(PdfObject&& rhs);
    void AssignNoDirtySet(PdfVariant&& rhs);
    void AssignNoDirtySet(const PdfObject& rhs);
 
    void SetParent(PdfDataContainer& parent);
 
private:
    void write(OutputStream& stream, bool skipLengthFix,
        PdfWriteFlags writeMode, const PdfStatefulEncrypt* encrypt, charbuff& buffer) const;
 
    void assertMutable() const;
 
    void assign(const PdfObject& rhs);
 
    void moveFrom(PdfObject&& rhs) noexcept;
 
    void ResetDirty();
 
    void setDirty();
 
    // See PdfVariant.h for a detailed explanation of this member, which is
    // here to prevent accidental construction of a PdfObject of integer type
    // when passing a pointer. */
    template<typename T>
    PdfObject(T*) = delete;
 
    void copyStreamFrom(const PdfObject& obj);
 
    // Shared initialization between all the ctors
    void initObject();
 
protected:
    PdfVariant m_Variant;
 
private:
    PdfReference m_IndirectReference;
    PdfDocument* m_Document;
    PdfDataContainer* m_Parent;
    std::unique_ptr<PdfObjectStream> m_Stream;
    bool m_IsDirty; // Indicates if this object was modified after construction
    bool m_IsImmutable;
    mutable bool m_IsDelayedLoadDone;
    mutable bool m_IsDelayedLoadStreamDone;
    // Tracks whether deferred loading is still pending (in which case it'll be
    // false). If true, deferred loading is not required or has been completed.
};
 
    template <typename T>
    struct ObjectAdapter
    {
        using TRet = T;
 
        static TRet Get(const PdfObject& obj)
        {
            (void)obj;
            static_assert(always_false<T>, "Unsupported type");
            return TRet{ };
        }
 
        static TRet Get(const PdfObject& obj, const T& defVal)
        {
            (void)obj;
            (void)defVal;
            static_assert(always_false<T>, "Unsupported type");
            return TRet{ };
        }
 
        static bool TryGet(const PdfObject& obj, T& value)
        {
            (void)obj;
            (void)value;
            static_assert(always_false<T>, "Unsupported type");
            return false;
        }
    };
 
    template <>
    struct ObjectAdapter<bool>
    {
        using TRet = bool;
 
        static bool Get(const PdfObject& obj)
        {
            return obj.GetBool();
        }
 
        static bool Get(const PdfObject& obj, bool fallback)
        {
            bool ret;
            if (obj.TryGetBool(ret))
                return ret;
            else
                return fallback;
        }
 
        static bool TryGet(const PdfObject& obj, bool& value)
        {
            return obj.TryGetBool(value);
        }
    };
 
    template <>
    struct ObjectAdapter<int64_t>
    {
        using TRet = int64_t;
 
        static int64_t Get(const PdfObject& obj)
        {
            return obj.GetNumber();
        }
 
        static int64_t Get(const PdfObject& obj, int64_t fallback)
        {
            int64_t ret;
            if (obj.TryGetNumber(ret))
                return ret;
            else
                return fallback;
        }
 
        static bool TryGet(const PdfObject& obj, int64_t& value)
        {
            return obj.TryGetNumber(value);
        }
    };
 
    template <>
    struct ObjectAdapter<double>
    {
        using TRet = double;
 
        static double Get(const PdfObject& obj)
        {
            return obj.GetReal();
        }
 
        static double Get(const PdfObject& obj, double fallback)
        {
            double ret;
            if (obj.TryGetReal(ret))
                return ret;
            else
                return fallback;
        }
 
        static bool TryGet(const PdfObject& obj, double& value)
        {
            return obj.TryGetReal(value);
        }
    };
 
    template <>
    struct ObjectAdapter<PdfReference>
    {
        using TRet = PdfReference;
 
        static PdfReference Get(const PdfObject& obj)
        {
            return obj.GetReference();
        }
 
        static PdfReference Get(const PdfObject& obj, const PdfReference& fallback)
        {
            PdfReference ret;
            if (obj.TryGetReference(ret))
                return ret;
            else
                return fallback;
        }
 
        static bool TryGet(const PdfObject& obj, PdfReference& value)
        {
            return obj.TryGetReference(value);
        }
    };
 
    template <>
    struct ObjectAdapter<PdfName>
    {
        using TRet = const PdfName&;
 
        static const PdfName& Get(const PdfObject& obj)
        {
            return obj.GetName();
        }
 
        static const PdfName& Get(const PdfObject& obj, const PdfName& fallback)
        {
            const PdfName* ret;
            if (obj.TryGetName(ret))
                return *ret;
            else
                return fallback;
        }
 
        static bool TryGet(const PdfObject& obj, PdfName& value)
        {
            return obj.TryGetName(value);
        }
    };
 
    template <>
    struct ObjectAdapter<const PdfName*>
    {
        using TRet = const PdfName*;
 
        static const PdfName* Get(const PdfObject& obj)
        {
            const PdfName* ret;
            (void)obj.TryGetName(ret);
            return ret;
        }
 
        static const PdfName* Get(const PdfObject& obj, const PdfName* fallback)
        {
            const PdfName* ret;
            if (obj.TryGetName(ret))
                return ret;
            else
                return fallback;
        }
 
        static bool TryGet(const PdfObject& obj, const PdfName*& value)
        {
            return obj.TryGetName(value);
        }
    };
 
    template <>
    struct ObjectAdapter<PdfString>
    {
        using TRet = const PdfString&;
 
        static const PdfString& Get(const PdfObject& obj)
        {
            return obj.GetString();
        }
 
        static const PdfString& Get(const PdfObject& obj, const PdfString& fallback)
        {
            const PdfString* ret;
            if (obj.TryGetString(ret))
                return *ret;
            else
                return fallback;
        }
 
        static bool TryGet(const PdfObject& obj, PdfString& value)
        {
            return obj.TryGetString(value);
        }
    };
 
    template <>
    struct ObjectAdapter<const PdfString*>
    {
        using TRet = const PdfString*;
 
        static const PdfString* Get(PdfObject& obj)
        {
            const PdfString* ret;
            (void)obj.TryGetString(ret);
            return ret;
        }
 
        static const PdfString* Get(const PdfObject& obj, const PdfString* fallback)
        {
            const PdfString* ret;
            if (obj.TryGetString(ret))
                return ret;
            else
                return fallback;
        }
 
        static bool TryGet(const PdfObject& obj, const PdfString*& value)
        {
            return obj.TryGetString(value);
        }
    };
 
    template <>
    struct ObjectAdapter<PdfDictionary*>
    {
        using TRet = PdfDictionary*;
 
        static PdfDictionary* Get(PdfObject& obj)
        {
            PdfDictionary* ret;
            (void)obj.TryGetDictionary(ret);
            return ret;
        }
 
        static PdfDictionary* Get(PdfObject& obj, PdfDictionary* fallback)
        {
            PdfDictionary* ret;
            if (obj.TryGetDictionary(ret))
                return ret;
            else
                return fallback;
        }
 
        static bool TryGet(PdfObject& obj, PdfDictionary*& value)
        {
            return obj.TryGetDictionary(value);
        }
    };
 
    template <>
    struct ObjectAdapter<const PdfDictionary*>
    {
        using TRet = const PdfDictionary*;
 
        static const PdfDictionary* Get(const PdfObject& obj)
        {
            const PdfDictionary* ret;
            (void)obj.TryGetDictionary(ret);
            return ret;
        }
 
        static const PdfDictionary* Get(const PdfObject& obj, const PdfDictionary* fallback)
        {
            const PdfDictionary* ret;
            if (obj.TryGetDictionary(ret))
                return ret;
            else
                return fallback;
        }
 
        static bool TryGet(const PdfObject& obj, const PdfDictionary*& value)
        {
            return obj.TryGetDictionary(value);
        }
    };
 
    template <>
    struct ObjectAdapter<PdfDictionary>
    {
        using TRet = PdfDictionary&;
 
        static PdfDictionary& Get(PdfObject& obj)
        {
            return obj.GetDictionary();
        }
 
        static PdfDictionary& Get(PdfObject& obj, PdfDictionary& fallback)
        {
            PdfDictionary* ret;
            if (obj.TryGetDictionary(ret))
                return *ret;
            else
                return fallback;
        }
 
        static bool TryGet(const PdfObject& obj, PdfDictionary& value)
        {
            return obj.TryGetDictionary(value);
        }
    };
 
    template <>
    struct ObjectAdapter<PdfArray*>
    {
        using TRet = PdfArray*;
 
        static PdfArray* Get(PdfObject& obj)
        {
            PdfArray* ret;
            (void)obj.TryGetArray(ret);
            return ret;
        }
 
        static PdfArray* Get(PdfObject& obj, PdfArray* fallback)
        {
            PdfArray* ret;
            if (obj.TryGetArray(ret))
                return ret;
            else
                return fallback;
        }
 
        static bool TryGet(PdfObject& obj, PdfArray*& value)
        {
            return obj.TryGetArray(value);
        }
    };
 
    template <>
    struct ObjectAdapter<const PdfArray*>
    {
        using TRet = const PdfArray*;
 
        static const PdfArray* Get(const PdfObject& obj)
        {
            const PdfArray* ret;
            (void)obj.TryGetArray(ret);
            return ret;
        }
 
        static const PdfArray* Get(PdfObject& obj, const PdfArray* fallback)
        {
            const PdfArray* ret;
            if (obj.TryGetArray(ret))
                return ret;
            else
                return fallback;
        }
 
        static bool TryGet(const PdfObject& obj, const PdfArray*& value)
        {
            return obj.TryGetArray(value);
        }
    };
 
    template <>
    struct ObjectAdapter<PdfArray>
    {
        using TRet = PdfArray&;
 
        static PdfArray& Get(PdfObject& obj)
        {
            return obj.GetArray();
        }
 
        static PdfArray& Get(PdfObject& obj, PdfArray& fallback)
        {
            PdfArray* ret;
            if (obj.TryGetArray(ret))
                return *ret;
            else
                return fallback;
        }
 
        static bool TryGet(const PdfObject& obj, PdfArray& value)
        {
            return obj.TryGetArray(value);
        }
    };
 
    // Comparator to enable heterogeneous lookup with
    // both objects and references
    // See https://stackoverflow.com/a/31924435/213871
    struct PODOFO_API PdfObjectInequality final
    {
        using is_transparent = std::true_type;
 
        bool operator()(const PdfObject* lhs, const PdfObject* rhs) const
        {
            return lhs->GetIndirectReference() < rhs->GetIndirectReference();
        }
        bool operator()(const PdfObject* lhs, const PdfReference& rhs) const
        {
            return lhs->GetIndirectReference() < rhs;
        }
        bool operator()(const PdfReference& lhs, const PdfObject* rhs) const
        {
            return lhs < rhs->GetIndirectReference();
        }
        bool operator()(const PdfObject& lhs, const PdfObject& rhs) const
        {
            return lhs.GetIndirectReference() < rhs.GetIndirectReference();
        }
        bool operator()(const PdfObject& lhs, const PdfReference& rhs) const
        {
            return lhs.GetIndirectReference() < rhs;
        }
        bool operator()(const PdfReference& lhs, const PdfObject& rhs) const
        {
            return lhs < rhs.GetIndirectReference();
        }
    };
}
 
#endif // PDF_OBJECT_H