PdfDictionary.h

// SPDX-FileCopyrightText: 2011 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_DICTIONARY_H
#define PDF_DICTIONARY_H
 
#include "PdfDeclarations.h"
#include "PdfDataContainer.h"
 
namespace PoDoFo {
 
class PdfDictionary;
 
template <typename TObject, typename TMapIterator>
class PdfDictionaryIndirectIterableBase final : public PdfIndirectIterableBase
{
    friend class PdfDictionary;
 
public:
    PdfDictionaryIndirectIterableBase();
 
private:
    PdfDictionaryIndirectIterableBase(PdfDictionary& dict);
 
public:
    class Iterator final
    {
        friend class PdfDictionaryIndirectIterableBase;
    public:
        using difference_type = void;
        using value_type = std::pair<PdfName, TObject*>;
        using pointer = const value_type*;
        using reference = const value_type&;
        using iterator_category = std::forward_iterator_tag;
    public:
        Iterator();
    private:
        Iterator(TMapIterator&& iterator, PdfIndirectObjectList* objects);
    public:
        Iterator(const Iterator&) = default;
        Iterator& operator=(const Iterator&) = default;
        bool operator==(const Iterator& rhs) const;
        bool operator!=(const Iterator& rhs) const;
        Iterator& operator++();
        Iterator operator++(int);
        reference operator*();
        pointer operator->();
    private:
        void resolve();
    private:
        TMapIterator m_iterator;
        PdfIndirectObjectList* m_objects;
        value_type m_pair;
    };
 
public:
    Iterator begin() const;
    Iterator end() const;
 
private:
    PdfDictionary* m_dict;
};
 
using PdfDictionaryIndirectIterable = PdfDictionaryIndirectIterableBase<PdfObject, PdfNameMap<PdfObject>::iterator>;
using PdfDictionaryConstIndirectIterable = PdfDictionaryIndirectIterableBase<const PdfObject, PdfNameMap<PdfObject>::const_iterator>;
 
class PODOFO_API PdfDictionary final : public PdfDataContainer
{
    friend class PdfObject;
    friend class PdfTokenizer;
    friend class PdfSignature;
    friend class PdfObjectStream;
    friend class PdfObjectOutputStream;
 
public:
    PdfDictionary();
 
    PdfDictionary(const PdfDictionary& rhs);
    PdfDictionary(PdfDictionary&& rhs) noexcept;
 
    PdfDictionary& operator=(const PdfDictionary& rhs);
    PdfDictionary& operator=(PdfDictionary&& rhs) noexcept;
 
    bool operator==(const PdfDictionary& rhs) const;
 
    bool operator!=(const PdfDictionary& rhs) const;
 
    void Clear();
 
    PdfObject& AddKey(const PdfName& key, const PdfObject& obj);
    PdfObject& AddKey(const PdfName& key, PdfObject&& obj);
 
    void AddKeyIndirect(const PdfName& key, const PdfObject& obj);
 
    PdfObject& AddKeyIndirectSafe(const PdfName& key, const PdfObject& obj);
 
    const PdfObject* GetKey(const std::string_view& key) const;
 
    PdfObject* GetKey(const std::string_view& key);
 
    const PdfObject* FindKey(const std::string_view& key) const;
    PdfObject* FindKey(const std::string_view& key);
    const PdfObject& MustFindKey(const std::string_view& key) const;
    PdfObject& MustFindKey(const std::string_view& key);
 
    const PdfObject* FindKeyParent(const std::string_view& key) const;
    PdfObject* FindKeyParent(const std::string_view& key);
    const PdfObject& MustFindKeyParent(const std::string_view& key) const;
    PdfObject& MustFindKeyParent(const std::string_view& key);
 
    const PdfObject& MustGetKey(const std::string_view& key) const;
    PdfObject& MustGetKey(const std::string_view& key);
 
    template <typename T>
    const typename ObjectAdapter<T>::TRet GetKeyAs(const std::string_view& key) const;
 
    template <typename T>
    typename ObjectAdapter<T>::TRet GetKeyAs(const std::string_view& key);
 
    template <typename T>
    const typename ObjectAdapter<T>::TRet FindKeyAs(const std::string_view& key) const;
 
    template <typename T>
    typename ObjectAdapter<T>::TRet FindKeyAs(const std::string_view& key);
 
    template <typename T>
    const typename ObjectAdapter<T>::TRet FindKeyParentAs(const std::string_view& key) const;
 
    template <typename T>
    typename ObjectAdapter<T>::TRet FindKeyParentAs(const std::string_view& key);
 
    template <typename T>
    const typename ObjectAdapter<T>::TRet GetKeyAsSafe(const std::string_view& key, const std::common_type_t<T>& fallback = { }) const;
 
    template <typename T>
    typename ObjectAdapter<T>::TRet GetKeyAsSafe(const std::string_view& key, const std::common_type_t<T>& fallback = { });
 
    template <typename T>
    const typename ObjectAdapter<T>::TRet FindKeyAsSafe(const std::string_view& key, const std::common_type_t<T>& fallback = { }) const;
 
    template <typename T>
    typename ObjectAdapter<T>::TRet FindKeyAsSafe(const std::string_view& key, const std::common_type_t<T>& fallback = { });
 
    template <typename T>
    const typename ObjectAdapter<T>::TRet FindKeyParentAsSafe(const std::string_view& key, const std::common_type_t<T>& fallback = { }) const;
 
    template <typename T>
    typename ObjectAdapter<T>::TRet FindKeyParentAsSafe(const std::string_view& key, const std::common_type_t<T>& fallback = { });
 
    template <typename T>
    bool TryFindKeyAs(const std::string_view& key, T& value) const;
 
    template <typename T>
    bool TryFindKeyAs(const std::string_view& key, T& value);
 
    template <typename T>
    bool TryFindKeyParentAs(const std::string_view& key, T& value) const;
 
    template <typename T>
    bool TryFindKeyParentAs(const std::string_view& key, T& value);
 
    bool HasKey(const std::string_view& key) const;
 
    bool RemoveKey(const std::string_view& key);
 
    void Write(OutputStream& stream, PdfWriteFlags writeMode,
        const PdfStatefulEncrypt* encrypt, charbuff& buffer) const override;
 
    unsigned GetSize() const;
 
    PdfDictionaryIndirectIterable GetIndirectIterator();
 
    PdfDictionaryConstIndirectIterable GetIndirectIterator() const;
 
public:
    using iterator = PdfNameMap<PdfObject>::iterator;
    using const_iterator = PdfNameMap<PdfObject>::const_iterator;
 
public:
    iterator begin();
    iterator end();
    const_iterator begin() const;
    const_iterator end() const;
    size_t size() const;
 
protected:
    void resetDirty() override;
    void setChildrenParent() override;
 
private:
    // NOTE: It also doesn't dirty set the moved "obj"
    void AddKeyNoDirtySet(const PdfName& key, PdfObject&& obj);
    void AddKeyNoDirtySet(const PdfName& key, PdfVariant&& var);
    void RemoveKeyNoDirtySet(const std::string_view& key);
    // Append a new "null" object with the given key
    PdfObject& EmplaceNoDirtySet(const PdfName& key);
 
private:
    PdfObject& addKey(const PdfName& key, PdfObject&& obj);
    PdfObject* getKey(const std::string_view& key) const;
    PdfObject* findKey(const std::string_view& key) const;
    PdfObject* findKeyParent(const std::string_view& key) const;
    void write(OutputStream& stream, PdfWriteFlags writeMode, bool addDelimiters,
        const PdfStatefulEncrypt* encrypt, charbuff& buffer) const;
 
private:
    PdfNameMap<PdfObject> m_Map;
};
 
template<typename T>
const typename ObjectAdapter<T>::TRet PdfDictionary::GetKeyAs(const std::string_view& key) const
{
    return ObjectAdapter<T>::Get(MustGetKey(key));
}
 
template<typename T>
typename ObjectAdapter<T>::TRet PdfDictionary::GetKeyAs(const std::string_view& key)
{
    return ObjectAdapter<T>::Get(MustGetKey(key));
}
 
template<typename T>
const typename ObjectAdapter<T>::TRet PdfDictionary::FindKeyAs(const std::string_view& key) const
{
    return ObjectAdapter<T>::Get(MustFindKey(key));
}
 
template<typename T>
typename ObjectAdapter<T>::TRet PdfDictionary::FindKeyAs(const std::string_view& key)
{
    return ObjectAdapter<T>::Get(MustFindKey(key));
}
 
template<typename T>
const typename ObjectAdapter<T>::TRet PdfDictionary::FindKeyParentAs(const std::string_view& key) const
{
    return ObjectAdapter<T>::Get(MustFindKeyParent(key));
}
 
template<typename T>
typename ObjectAdapter<T>::TRet PdfDictionary::FindKeyParentAs(const std::string_view& key)
{
    return ObjectAdapter<T>::Get(MustFindKeyParent(key));
}
 
template<typename T>
const typename ObjectAdapter<T>::TRet PdfDictionary::GetKeyAsSafe(const std::string_view& key, const std::common_type_t<T>& fallback) const
{
    auto obj = getKey(key);
    if (obj == nullptr)
        return fallback;
    else
        return ObjectAdapter<T>::Get(const_cast<const PdfObject&>(*obj), fallback);
}
 
template<typename T>
typename ObjectAdapter<T>::TRet PdfDictionary::GetKeyAsSafe(const std::string_view& key, const std::common_type_t<T>& fallback)
{
    auto obj = getKey(key);
    if (obj == nullptr)
        return fallback;
    else
        return ObjectAdapter<T>::Get(*obj, fallback);
}
 
template<typename T>
const typename ObjectAdapter<T>::TRet PdfDictionary::FindKeyAsSafe(const std::string_view& key, const std::common_type_t<T>& fallback) const
{
    auto obj = findKey(key);
    if (obj == nullptr)
        return fallback;
    else
        return ObjectAdapter<T>::Get(const_cast<const PdfObject&>(*obj), fallback);
}
 
template<typename T>
typename ObjectAdapter<T>::TRet PdfDictionary::FindKeyAsSafe(const std::string_view& key, const std::common_type_t<T>& fallback)
{
    auto obj = findKey(key);
    if (obj == nullptr)
        return fallback;
    else
        return ObjectAdapter<T>::Get(*obj, fallback);
}
 
template<typename T>
const typename ObjectAdapter<T>::TRet PdfDictionary::FindKeyParentAsSafe(const std::string_view& key, const std::common_type_t<T>& fallback) const
{
    auto obj = findKeyParent(key);
    if (obj == nullptr)
        return fallback;
    else
        return ObjectAdapter<T>::Get(const_cast<const PdfObject&>(*obj), fallback);
}
 
template<typename T>
typename ObjectAdapter<T>::TRet PdfDictionary::FindKeyParentAsSafe(const std::string_view& key, const std::common_type_t<T>& fallback)
{
    auto obj = findKeyParent(key);
    if (obj == nullptr)
        return fallback;
    else
        return ObjectAdapter<T>::Get(*obj, fallback);
}
 
template <typename T>
bool PdfDictionary::TryFindKeyAs(const std::string_view& key, T& value) const
{
    auto obj = findKey(key);
    if (obj != nullptr && ObjectAdapter<T>::TryGet(const_cast<const PdfObject&>(*obj), value))
    {
        return true;
    }
    else
    {
        value = { };
        return false;
    }
}
 
template<typename T>
bool PdfDictionary::TryFindKeyAs(const std::string_view& key, T& value)
{
    auto obj = findKey(key);
    if (obj != nullptr && ObjectAdapter<T>::TryGet(*obj, value))
    {
        return true;
    }
    else
    {
        value = { };
        return false;
    }
}
 
template <typename T>
bool PdfDictionary::TryFindKeyParentAs(const std::string_view& key, T& value) const
{
    auto obj = findKeyParent(key);
    if (obj != nullptr && ObjectAdapter<T>::TryGet(const_cast<const PdfObject&>(*obj), value))
    {
        return true;
    }
    else
    {
        value = { };
        return false;
    }
}
 
template<typename T>
bool PdfDictionary::TryFindKeyParentAs(const std::string_view& key, T& value)
{
    auto obj = findKeyParent(key);
    if (obj != nullptr && ObjectAdapter<T>::TryGet(*obj, value))
    {
        return true;
    }
    else
    {
        value = { };
        return false;
    }
}
 
template <typename TObject, typename TMapIterator>
PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::PdfDictionaryIndirectIterableBase()
    : m_dict(nullptr) { }
 
template <typename TObject, typename TMapIterator>
PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::PdfDictionaryIndirectIterableBase(PdfDictionary& dict)
    : PdfIndirectIterableBase(dict), m_dict(&dict) { }
 
template <typename TObject, typename TMapIterator>
typename PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::begin() const
{
    if (m_dict == nullptr)
        return Iterator();
    else
        return Iterator(m_dict->begin(), GetObjects());
}
 
template <typename TObject, typename TMapIterator>
typename PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::end() const
{
    if (m_dict == nullptr)
        return Iterator();
    else
        return Iterator(m_dict->end(), GetObjects());
}
 
template<typename TObject, typename TMapIterator>
PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator::Iterator() : m_objects(nullptr) { }
 
template<typename TObject, typename TMapIterator>
PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator::Iterator(TMapIterator&& iterator, PdfIndirectObjectList* objects)
    : m_iterator(std::move(iterator)), m_objects(objects) { }
 
template<typename TObject, typename TMapIterator>
bool PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator::operator==(const Iterator& rhs) const
{
    return m_iterator == rhs.m_iterator;
}
 
template<typename TObject, typename TMapIterator>
bool PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator::operator!=(const Iterator& rhs) const
{
    return m_iterator != rhs.m_iterator;
}
 
template<typename TObject, typename TMapIterator>
typename PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator& PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator::operator++()
{
    m_iterator++;
    return *this;
}
 
template<typename TObject, typename TMapIterator>
typename PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator::operator++(int)
{
    auto copy = *this;
    m_iterator++;
    return copy;
}
 
template<typename TObject, typename TMapIterator>
typename PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator::reference PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator::operator*()
{
    resolve();
    return m_pair;
}
 
template<typename TObject, typename TMapIterator>
typename PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator::pointer PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator::operator->()
{
    resolve();
    return &m_pair;
}
 
template<typename TObject, typename TMapIterator>
void PdfDictionaryIndirectIterableBase<TObject, TMapIterator>::Iterator::resolve()
{
    TObject& robj = m_iterator->second;
    TObject* indirectobj;
    PdfReference ref;
    if (m_objects != nullptr
        && robj.TryGetReference(ref)
        && ref.IsIndirect()
        && (indirectobj = GetObject(*m_objects, ref)) != nullptr)
    {
        m_pair = value_type(m_iterator->first, indirectobj);
    }
    else
    {
        m_pair = value_type(m_iterator->first, &robj);
    }
}
 
}
 
#endif // PDF_DICTIONARY_H