dictionary.h

Go to the documentation of this file.

#pragma once
 
#include <tuple>
#include <memory>
#include <iterator>
#include <vector>
#include <type_traits>
#include <cassert>
 
extern "C" {
#include <libavutil/dict.h>
}
 
#include "averror.h"
 
#include "ffmpeg.h"
 
namespace av {
 
class Dictionary : public FFWrapperPtr<AVDictionary>
{
public:
    enum Flags
    {
        FlagMatchCase       = AV_DICT_MATCH_CASE,
        FlagIgnoreSuffix    = AV_DICT_IGNORE_SUFFIX,
        FlagDontStrdupKey   = AV_DICT_DONT_STRDUP_KEY,
        FlagDontStrdupVal   = AV_DICT_DONT_STRDUP_VAL,
        FlagDontOverwrite   = AV_DICT_DONT_OVERWRITE,
        FlagAppend          = AV_DICT_APPEND,
    };
 
    struct AvStringDeleter
    {
        void operator()(char *ptr)
        {
            av_freep(&ptr);
        }
    };
 
    // Back compatible
    using RawStringDeleter = AvStringDeleter;
 
    struct AvStringPtr : public std::unique_ptr<char, AvStringDeleter>
    {
        using base_class = std::unique_ptr<char, AvStringDeleter>;
        using base_class::unique_ptr;
 
        char* c_str() const noexcept
        {
            return get();
        }
 
        size_t length() const noexcept
        {
            return strlen(c_str());
        }
 
        char& operator[](size_t index) const noexcept
        {
            return c_str()[index];
        }
    };
    // Our contract
    static_assert (sizeof(AvStringPtr) == sizeof(char*), "Size must be same. Check and try again");
    using RawStringPtr = AvStringPtr;
 
    // Fwd
    template<bool constIterator>
    class DictionaryIterator;
 
    class Entry
    {
    public:
 
        template<bool>
        friend class DictionaryIterator;
        friend class Dictionary;
 
        const char* key() const noexcept;
        const char* value() const noexcept;
        void set(const char *value, int flags = 0) noexcept;
        void set(const std::string& value, int flags = 0) noexcept;
 
        Entry& operator=(const char *value) noexcept;
        Entry& operator=(const std::string &value) noexcept;
 
        operator bool() const;
        bool isNull() const;
 
        friend bool operator==(const Entry& lhs, const Entry& rhs);
        friend bool operator!=(const Entry& lhs, const Entry& rhs);
 
    private:
        AVDictionaryEntry *m_entry = nullptr;
    };
 
 
    template<bool constIterator = false>
    class DictionaryIterator
    {
    public:
        // Iterator interface
        using iterator_category = std::forward_iterator_tag;
        using value_type = typename std::conditional<constIterator, const Entry, Entry>::type;
        using difference_type = ptrdiff_t;
        using pointer = value_type*;
        using reference = value_type&;
 
    private:
        using DictType  = typename std::conditional<constIterator, const Dictionary, Dictionary>::type;
        using EntryType = typename std::conditional<constIterator, const Entry, Entry>::type;
 
        DictType &m_dict;
        Entry     m_entry;
 
    public:
        DictionaryIterator(DictType &dict, const Entry& entry) noexcept
            : m_dict(dict),
              m_entry(entry)
        {
        }
 
        DictionaryIterator(DictType &dict) noexcept
            : m_dict(dict)
        {
            operator++();
        }
 
        DictionaryIterator& operator++() noexcept
        {
            m_entry.m_entry = av_dict_get(m_dict.raw(), "", m_entry.m_entry, FlagIgnoreSuffix);
            return *this;
        }
 
        DictionaryIterator operator++(int) noexcept
        {
            DictionaryIterator tmp(*this);
            operator++();
            return tmp;
        }
 
        friend bool operator==(const DictionaryIterator& lhs, const DictionaryIterator& rhs) noexcept
        {
            return lhs.m_entry == rhs.m_entry;
        }
 
        friend bool operator!=(const DictionaryIterator& lhs, const DictionaryIterator& rhs) noexcept
        {
            return lhs.m_entry != rhs.m_entry;
        }
 
        EntryType& operator*() noexcept
        {
            return m_entry;
        }
 
        EntryType* operator->() noexcept
        {
            return &m_entry;
        }
 
    };
 
    using Iterator      = DictionaryIterator<false>;
    using ConstIterator = DictionaryIterator<true>;
 
    Dictionary();
 
    explicit Dictionary(AVDictionary *dict, bool takeOwning = true);
 
    ~Dictionary();
 
    Dictionary(const Dictionary& other);
 
    Dictionary& operator=(const Dictionary &rhs);
 
    Dictionary(Dictionary&& other);
 
    Dictionary& operator=(Dictionary&& rhs);
 
    Dictionary(std::initializer_list<std::pair<const char*, const char*>> list, int flags = 0);
 
    Dictionary& operator=(std::initializer_list<std::pair<const char*, const char*>> list);
 
    Iterator      begin();
    Iterator      end();
    ConstIterator begin() const;
    ConstIterator end() const;
    ConstIterator cbegin() const;
    ConstIterator cend() const;
 
    bool isOwning() const noexcept;
 
    void assign(AVDictionary *dict, bool takeOwning = true) noexcept;
 
    const char* operator[](size_t index) const;
    Entry       operator[](size_t index);
 
    const char* operator[](const char* key) const;
    Entry       operator[](const char* key) noexcept;
 
    size_t      count() const noexcept;
    size_t      size() const noexcept;
 
    const char *get(const char* key, int flags = 0) const noexcept;
    const char *get(const std::string& key, int flags = 0) const noexcept;
 
 
    template<typename Key, typename Value = Key>
    auto set(const Key& key, const Value& value, OptionalErrorCode ec = throws(), int flags = 0) ->
         typename std::enable_if
         <
             (std::is_same<Key, std::string>::value || std::is_same<typename std::remove_cv<typename std::decay<Key>::type>::type, char*>::value) &&
             (std::is_same<Value, std::string>::value || std::is_same<typename std::remove_cv<typename std::decay<Value>::type>::type, char*>::value || std::is_integral<Value>::value)
             ,void
         >::type
    {
        clear_if(ec);
        int sts;
        if ((sts = set_priv(key, value, flags)) < 0) {
            throws_if(ec, sts, ffmpeg_category());
        }
    }
 
    template<typename Str, typename Sep1, typename Sep2>
    void parseString(const Str& str, const Sep1& keyValSep, const Sep2& pairsSep, int flags = 0, OptionalErrorCode ec = throws())
    {
        parseString_priv(ec,
                         _to_const_char_ptr(str),
                         _to_const_char_ptr(keyValSep),
                         _to_const_char_ptr(pairsSep),
                         flags);
    }
 
    std::string toString(const char keyValSep, const char pairsSep, OptionalErrorCode ec = throws()) const;
 
    AvStringPtr toRawStringPtr(const char keyValSep, const char pairsSep, OptionalErrorCode ec = throws()) const;
 
    void copyFrom(const Dictionary& other, int flags = 0) noexcept;
 
    void swap(Dictionary& other) noexcept;
 
    AVDictionary* release();
 
 
    AVDictionary **rawPtr() noexcept;
 
private:
    // Discard access to the reset() method
    using FFWrapperPtr<AVDictionary>::reset;
 
    int set_priv(const char* key, const char *value, int flags = 0) noexcept;
    int set_priv(const std::string& key, const std::string& value, int flags = 0) noexcept;
    int set_priv(const char* key, int64_t value, int flags = 0) noexcept;
    int set_priv(const std::string& key, int64_t value, int flags = 0) noexcept;
 
    const char* _to_const_char_ptr(const char *str)
    {
        return str;
    }
 
    const char* _to_const_char_ptr(const std::string &str)
    {
        return str.c_str();
    }
 
    int  parseString_priv(const char* str, const char* keyvalSep, const char* pairsSep, int flags);
    void parseString_priv(OptionalErrorCode ec, const char* str, const char* keyvalSep, const char* pairsSep, int flags);
 
 
private:
    bool m_owning = true;
};
 
 
class DictionaryArray
{
public:
 
    DictionaryArray() = default;
    DictionaryArray(std::initializer_list<Dictionary> dicts);
    DictionaryArray(AVDictionary **dicts, size_t count, bool takeOwning = true);
 
    DictionaryArray(const DictionaryArray& rhs);
    DictionaryArray& operator=(const DictionaryArray& rhs);
 
    DictionaryArray(DictionaryArray&&) = default;
    DictionaryArray& operator=(DictionaryArray&&) = default;
 
    void assign(AVDictionary **dicts, size_t count, bool takeOwning = true);
    void reserve(size_t size);
    void resize(size_t size);
 
    size_t size() const;
 
    void pushBack(const Dictionary &dict);
    void pushBack(Dictionary &&dict);
 
    const Dictionary& operator[](size_t index) const;
    Dictionary&       operator[](size_t index);
    const Dictionary& at(size_t index) const;
    Dictionary&       at(size_t index);
 
    const AVDictionary* const* raws() const;
    AVDictionary**             raws();
 
    AVDictionary** release();
    void swap(DictionaryArray &rhs);
private:
    std::vector<AVDictionary*> m_raws;
    std::vector<Dictionary>    m_dicts;
};
 
} // namespace av