codec_iterator.h

Go to the documentation of this file.

 
#ifndef DDL_CODEC_ITERATOR_CLASS_HEADER
#define DDL_CODEC_ITERATOR_CLASS_HEADER
 
#include <a_util/variant.h>
#include <ddl/codec/codec_index.h>
 
#include <functional>
 
namespace ddl {
namespace codec {
 
// forward declarations
template <typename ElementAccessType, typename ChildElementsType>
class FactoryElement;
template <typename ElementAccessType, typename ChildElementsType>
class DecoderElement;
template <typename ElementAccessType, typename ChildElementsType>
class CodecElement;
 
template <typename ElementAccessType>
class ElementIterator {
public:
    using element_type = typename ElementAccessType::element_type; 
    using value_type = element_type;                               
    using reference = value_type&;                                 
    using const_reference = const value_type&;                     
    using pointer = value_type*;                                   
    using const_pointer = const value_type*;             
    using difference_type = int;                         
    using iterator_category = std::forward_iterator_tag; 
 
    ElementIterator() = delete;
    ElementIterator(value_type&& element) : _element(std::move(element))
    {
    }
    ElementIterator& operator++()
    {
        next();
        return *this;
    }
    ElementIterator operator++(int)
    {
        const auto old_index = _element.getIndex();
        next();
        return ElementIterator(old_index, _element.getAccess());
    }
    bool operator==(const ElementIterator& rhs) const
    {
        return _element.getIndex() == rhs._element.getIndex();
    }
    bool operator!=(const ElementIterator& rhs) const
    {
        return _element.getIndex() != rhs._element.getIndex();
    }
    const_reference operator*() const
    {
        return _element;
    }
    const_pointer operator->() const
    {
        return &_element;
    }
    reference operator*()
    {
        return _element;
    }
    pointer operator->()
    {
        return &_element;
    }
 
private:
    void next()
    {
        _element.next();
    }
    element_type _element;
};
 
template <typename ElementAccessType>
class ElementIteratorConst {
public:
    using element_type = typename ElementAccessType::element_type; 
    using value_type = const element_type;               
    using const_reference = value_type&;                 
    using const_pointer = value_type*;                   
    using difference_type = int;                         
    using iterator_category = std::forward_iterator_tag; 
 
    ElementIteratorConst() = delete;
    ElementIteratorConst(value_type&& element) : _element(std::move(element))
    {
    }
    ElementIteratorConst& operator++()
    {
        next();
        return *this;
    }
    ElementIteratorConst operator++(int)
    {
        const auto old_index = _element.getIndex();
        next();
        return self_type(old_index, _element.getAccess());
    }
 
    bool operator==(const ElementIteratorConst& rhs) const
    {
        return _element.getIndex() == rhs._element.getIndex();
    }
    bool operator!=(const ElementIteratorConst& rhs) const
    {
        return _element.getIndex() != rhs._element.getIndex();
    }
    const_reference operator*() const
    {
        return _element;
    }
    const_pointer operator->() const
    {
        return &_element;
    }
 
private:
    void next()
    {
        _element.next();
    }
    element_type _element;
};
 
template <typename ElementAccessType>
class ChildElements {
public:
    using access_type = typename ElementAccessType::access_type;
    using element_type = typename ElementAccessType::element_type;
    using const_iterator = ElementIteratorConst<ElementAccessType>; 
    using iterator = ElementIterator<ElementAccessType>;            
 
    friend element_type;
    friend access_type;
    friend FactoryElement<ElementAccessType, ChildElements<ElementAccessType>>;
    friend DecoderElement<ElementAccessType, ChildElements<ElementAccessType>>;
    friend CodecElement<ElementAccessType, ChildElements<ElementAccessType>>;
 
    ChildElements(ChildElements&&) = default;
    ChildElements& operator=(ChildElements&&) = default;
    ChildElements(const ChildElements&) = delete;
    ChildElements& operator=(const ChildElements&) = delete;
    ~ChildElements() = default;
 
    const_iterator cbegin() const
    {
        if (_child_element_count > 0) {
            CodecIndex begin_index(_codec_base_index, {0, 0});
            ElementAccessType::resolve(_access, begin_index);
            size_t element_child_count = begin_index.getLayout().child_element_count;
            return const_iterator(element_type(
                std::move(begin_index), _child_element_count, element_child_count, _access));
        }
        else {
            return const_iterator(element_type(CodecIndex(), 0, 0, _access));
        }
    }
 
    const_iterator begin() const
    {
        return cbegin();
    }
    const_iterator cend() const
    {
        if (_child_element_count > 0) {
            return const_iterator(
                element_type(CodecIndex(_codec_base_index, {_child_element_count, 0}),
                             _child_element_count,
                             0,
                             _access));
        }
        else {
            return const_iterator(element_type(CodecIndex(), 0, 0, _access));
        }
    }
    const_iterator end() const
    {
        return cend();
    }
    iterator begin()
    {
        if (_child_element_count > 0) {
            CodecIndex begin_index(_codec_base_index, {0, 0});
            ElementAccessType::resolve(_access, begin_index);
            size_t element_child_count = begin_index.getLayout().child_element_count;
            return iterator(element_type(
                std::move(begin_index), _child_element_count, element_child_count, _access));
        }
        else {
            return iterator(element_type(CodecIndex(), 0, 0, _access));
        }
    }
    iterator end()
    {
        if (_child_element_count > 0) {
            return iterator(element_type(CodecIndex(_codec_base_index, {_child_element_count, 0}),
                                         _child_element_count,
                                         0,
                                         _access));
        }
        else {
            return iterator(element_type(CodecIndex(), 0, 0, _access));
        }
    }
    size_t size() const
    {
        return _child_element_count;
    }
 
private:
    ChildElements(const CodecIndex& base_index, access_type& access)
        : _codec_base_index(base_index),
          _child_element_count(ElementAccessType::getChildCount(access, base_index)),
          _access(access)
    {
    }
 
    ChildElements(const CodecIndex& base_index, size_t child_element_count, access_type& access)
        : _codec_base_index(base_index), _child_element_count(child_element_count), _access(access)
    {
    }
    void resetChildCount(size_t child_element_count)
    {
        _child_element_count = child_element_count;
    }
    void resetChildCount()
    {
        resetChildCount(ElementAccessType::getChildCount(_access, _codec_base_index));
    }
 
    const CodecIndex& _codec_base_index;
    size_t _child_element_count;
    access_type& _access;
};
 
template <typename AccessType>
class FactoryElementAccess {
public:
    using access_type = AccessType; 
    using self_type = FactoryElementAccess<AccessType>;                       
    using element_type = FactoryElement<self_type, ChildElements<self_type>>; 
 
    static element_type getElement(access_type& access, const std::string& full_element_name)
    {
        return access.getElement(full_element_name);
    };
    static element_type getElement(access_type& access, const CodecIndex& index)
    {
        return access.getElement(index);
    };
    static size_t getChildCount(access_type& access, const CodecIndex& index)
    {
        return access.getElementChildCount(index);
    };
    static std::string getFullName(access_type& access, const CodecIndex& index)
    {
        return access.getElementFullName(index);
    };
    static std::string getName(access_type& access, const CodecIndex& index)
    {
        return access.getElementName(index);
    };
    static std::string getBaseName(access_type& access, const CodecIndex& index)
    {
        return access.getElementBaseName(index);
    };
 
    static void resolve(access_type& access, CodecIndex& index)
    {
        return access.resolve(index);
    };
};
 
template <typename ElementAccessType, typename ChildElementsType = ChildElements<ElementAccessType>>
class FactoryElement {
public:
    using self_type = FactoryElement<ElementAccessType, ChildElementsType>; 
    using access_type = typename ElementAccessType::access_type;            
    using child_elements_type = ChildElementsType;                
    using iterator_type = typename child_elements_type::iterator; 
    using const_iterator_type = typename child_elements_type::const_iterator;
 
    friend child_elements_type;
    friend iterator_type;
    friend const_iterator_type;
    friend access_type;
    friend DecoderElement<ElementAccessType, ChildElementsType>;
    friend CodecElement<ElementAccessType, ChildElementsType>;
 
    FactoryElement() = delete;
    FactoryElement(FactoryElement&& other)
        : _codec_index(std::move(other._codec_index)),
          _end_element_index(std::move(other._end_element_index)),
          _child_elements(_codec_index, other._child_elements.size(), other._access),
          _access(other._access)
    {
    }
    FactoryElement& operator=(FactoryElement&& other)
    {
        _codec_index = std::move(other._codec_index);
        _end_element_index = std::move(other._end_element_index);
        _child_elements = child_elements_type(_codec_index, other._child_elements.size(), _access);
    }
    FactoryElement(const FactoryElement& other)
        : _codec_index(other._codec_index),
          _end_element_index(other._end_element_index),
          _child_elements(_codec_index, other._child_elements.size(), other._access),
          _access(other._access)
    {
    }
    FactoryElement& operator=(const FactoryElement& other)
    {
        _codec_index = other._codec_index;
        _end_element_index = other._end_element_index;
        _child_elements = child_elements_type(_codec_index, other._child_elements.size(), _access);
    }
 
    ~FactoryElement() = default;
    const CodecIndex& getIndex() const
    {
        return _codec_index;
    }
    size_t getArraySize() const
    {
        return _codec_index.getLayout().array_size;
    }
    ddl::codec::ElementType getType() const
    {
        return _codec_index.getType();
    }
    std::string getFullName() const
    {
        return ElementAccessType::getFullName(_access, _codec_index);
    }
    std::string getName() const
    {
        return ElementAccessType::getName(_access, _codec_index);
    }
    std::string getBaseName() const
    {
        return ElementAccessType::getBaseName(_access, _codec_index);
    }
    bool isArray() const
    {
        return _codec_index.getLayout().array_size > 1;
    }
    bool hasChildren() const
    {
        return _child_elements.size() > 0;
    }
    const child_elements_type& getChildElements() const
    {
        return _child_elements;
    }
    self_type getChildElement(const std::string& name) const
    {
        auto full_name = getFullName();
        full_name.append(".");
        full_name.append(name);
        return self_type(full_name, getAccess());
    }
    self_type getArrayElement(size_t array_pos = 0) const
    {
        return self_type(_codec_index.getIndexForArrayPos(array_pos), getAccess());
    }
    bool isValid() const
    {
        return _codec_index != CodecIndex();
    }
 
private:
    FactoryElement(CodecIndex&& index,
                   size_t end_element_index,
                   size_t child_elements_count,
                   access_type& access)
        : _codec_index(std::move(index)),
          _end_element_index(end_element_index),
          _child_elements(_codec_index, child_elements_count, access),
          _access(access)
    {
    }
    FactoryElement(CodecIndex&& index, size_t end_element_index, access_type& access)
        : _codec_index(std::move(index)),
          _end_element_index(end_element_index),
          _child_elements(
              _codec_index, ElementAccessType::getChildCount(access, _codec_index), access),
          _access(access)
    {
    }
    FactoryElement(const std::string& element_name, access_type& access)
        : _codec_index(std::move(ElementAccessType::getElement(access, element_name)._codec_index)),
          _end_element_index(CodecIndex::ElementIndex::_invalid_element_index),
          _child_elements(_codec_index, access),
          _access(access)
    {
    }
 
    FactoryElement(CodecIndex&& index, access_type& access)
        : _codec_index(std::move(index)),
          _end_element_index(CodecIndex::ElementIndex::_invalid_element_index),
          _child_elements(_codec_index, access),
          _access(access)
    {
    }
    FactoryElement(access_type& access)
        : _codec_index(CodecIndex()),
          _end_element_index(CodecIndex::ElementIndex::_invalid_element_index),
          _child_elements(_codec_index, 0, access),
          _access(access)
    {
    }
    void next()
    {
        auto break_increasing = false;
        auto index_valid = false;
        while (!break_increasing) {
            ++_codec_index;
            const auto element_index = _codec_index.back();
            if (element_index.getIndex() != CodecIndex::ElementIndex::_invalid_element_index &&
                element_index.getIndex() < _end_element_index) {
                ElementAccessType::resolve(_access, _codec_index);
                if (_codec_index.getLayout().array_size != 0) {
                    break_increasing = true;
                    index_valid = true;
                }
            }
            else {
                break_increasing = true;
            }
        }
        if (index_valid) {
            _child_elements.resetChildCount(_codec_index.getLayout().child_element_count);
        }
    }
    access_type& getAccess() const
    {
        return _access;
    }
 
    void resetIndex(CodecIndex&& codec_index)
    {
        _codec_index = std::move(codec_index);
        _child_elements.resetChildCount();
    }
    CodecIndex _codec_index;
    size_t _end_element_index;
    child_elements_type _child_elements;
    access_type& _access;
};
 
template <typename AccessType>
class DecoderElementAccess : public FactoryElementAccess<AccessType> {
public:
    using access_type = AccessType;                     
    using self_type = DecoderElementAccess<AccessType>; 
    using element_type = DecoderElement<self_type, ChildElements<self_type>>;
 
    static element_type getElement(access_type& access, const std::string& full_element_name)
    {
        return access.getElement(full_element_name);
    };
    static element_type getElement(access_type& access, const CodecIndex& index)
    {
        return access.getElement(index);
    };
    template <typename T>
    static T getValue(access_type& access, const CodecIndex& index)
    {
        return access.template getElementValue<T>(index);
    }
    static a_util::variant::Variant getVariantValue(access_type& access, const CodecIndex& index)
    {
        return access.getElementVariantValue(index);
    };
    static std::string getStringValue(access_type& access, const CodecIndex& index)
    {
        return access.getElementStringValue(index);
    };
    static void getRawValue(access_type& access,
                            const CodecIndex& index,
                            void* value,
                            size_t value_size)
    {
        access.getElementRawValue(index, value, value_size);
    };
    static const void* getAddress(access_type& access, const CodecIndex& index)
    {
        return access.getElementAddress(index);
    };
};
 
template <typename ElementAccessType, typename ChildElementsType = ChildElements<ElementAccessType>>
class DecoderElement : public FactoryElement<ElementAccessType, ChildElementsType> {
public:
    using base_type = FactoryElement<ElementAccessType, ChildElementsType>; 
    using self_type = DecoderElement<ElementAccessType, ChildElementsType>; 
    using access_type = typename ElementAccessType::access_type;
    using child_elements_type = typename base_type::child_elements_type; 
    using iterator_type = typename child_elements_type::iterator;        
    using const_iterator_type = typename child_elements_type::const_iterator;
 
    friend child_elements_type;
    friend iterator_type;
    friend const_iterator_type;
    friend access_type;
    friend base_type;
    friend CodecElement<ElementAccessType, ChildElementsType>;
 
    DecoderElement() = delete;
    template <typename T>
    T getValue() const
    {
        return ElementAccessType::template getValue<T>(base_type::getAccess(),
                                                       base_type::getIndex());
    }
    a_util::variant::Variant getVariantValue() const
    {
        return ElementAccessType::getVariantValue(base_type::getAccess(), base_type::getIndex());
    };
    std::string getStringValue() const
    {
        return ElementAccessType::getStringValue(base_type::getAccess(), base_type::getIndex());
    };
    void getRawValue(void* value, size_t value_size) const
    {
        ElementAccessType::getRawValue(
            base_type::getAccess(), base_type::getIndex(), value, value_size);
    }
    const void* getAddress() const
    {
        return ElementAccessType::getAddress(base_type::getAccess(), base_type::getIndex());
    }
    self_type getChildElement(const std::string& name) const
    {
        auto full_name = base_type::getFullName();
        full_name.append(".");
        full_name.append(name);
        return self_type(full_name, base_type::getAccess());
    }
    self_type getArrayElement(size_t array_pos = 0) const
    {
        return self_type(base_type::getIndex().getIndexForArrayPos(array_pos),
                         base_type::getAccess());
    }
 
private:
    DecoderElement(CodecIndex&& index,
                   size_t end_element_index,
                   size_t child_elements_count,
                   access_type& access)
        : base_type(std::move(index), end_element_index, child_elements_count, access)
    {
    }
    DecoderElement(CodecIndex&& index, size_t end_element_index, access_type& access)
        : base_type(std::move(index), end_element_index, access)
    {
    }
    DecoderElement(const std::string& element_name, access_type& access)
        : base_type(element_name, access)
    {
    }
    DecoderElement(CodecIndex&& index, access_type& access) : base_type(std::move(index), access)
    {
    }
    DecoderElement(access_type& access) : base_type(access)
    {
    }
    void next()
    {
        base_type::next();
    }
};
 
template <typename AccessType>
class CodecElementAccess : public DecoderElementAccess<AccessType> {
public:
    using access_type = AccessType;                   
    using self_type = CodecElementAccess<AccessType>; 
    using element_type = CodecElement<self_type, ChildElements<self_type>>;
 
    static element_type getElement(access_type& access, const std::string& full_element_name)
    {
        return access.getElement(full_element_name);
    };
    static element_type getElement(access_type& access, const CodecIndex& index)
    {
        return access.getElement(index);
    };
    template <typename T>
    static void setValue(access_type& access, const CodecIndex& index, const T& value)
    {
        access.template setElementValue<T>(index, value);
    }
    static void setVariantValue(access_type& access,
                                const CodecIndex& index,
                                const a_util::variant::Variant& value)
    {
        access.setElementVariantValue(index, value);
    };
    static void setStringValue(access_type& access,
                               const CodecIndex& index,
                               const std::string& value)
    {
        access.setElementStringValue(index, value);
    };
    static void setRawValue(access_type& access,
                            const CodecIndex& index,
                            const void* value,
                            size_t value_size)
    {
        access.setElementRawValue(index, value, value_size);
    };
    static void* getAddress(access_type& access, const CodecIndex& index)
    {
        return access.getElementAddress(index);
    };
};
 
template <typename ElementAccessType, typename ChildElementsType = ChildElements<ElementAccessType>>
class CodecElement : public DecoderElement<ElementAccessType, ChildElementsType> {
public:
    using factory_base_type = FactoryElement<ElementAccessType, ChildElementsType>;
    using base_type = DecoderElement<ElementAccessType, ChildElementsType>; 
    using self_type = CodecElement<ElementAccessType, ChildElementsType>;   
    using access_type = typename ElementAccessType::access_type; 
    using child_elements_type = typename factory_base_type::child_elements_type;
    using iterator_type = typename child_elements_type::iterator; 
    using const_iterator_type = typename child_elements_type::const_iterator;
 
    friend child_elements_type;
    friend iterator_type;
    friend const_iterator_type;
    friend access_type;
    friend base_type;
    friend factory_base_type;
    CodecElement() = delete;
    template <typename T>
    void setValue(const T& value)
    {
        return ElementAccessType::template setValue<T>(
            base_type::getAccess(), base_type::getIndex(), value);
    }
    void setVariantValue(const a_util::variant::Variant& value)
    {
        return ElementAccessType::setVariantValue(
            base_type::getAccess(), base_type::getIndex(), value);
    };
    void setStringValue(const std::string& value)
    {
        return ElementAccessType::setStringValue(
            base_type::getAccess(), base_type::getIndex(), value);
    };
    void setRawValue(const void* value, size_t value_size)
    {
        return ElementAccessType::setRawValue(
            base_type::getAccess(), base_type::getIndex(), value, value_size);
    };
 
    void reset(bool zero_value_of_known_type = false)
    {
        const auto& layout = base_type::getIndex().getLayout();
        if (layout.constant_info->isConstant()) {
            return ElementAccessType::setVariantValue(base_type::getAccess(),
                                                      base_type::getIndex(),
                                                      layout.constant_info->getConstantValue());
        }
        else if (layout.default_value_info->hasDefaultValue()) {
            return ElementAccessType::setVariantValue(base_type::getAccess(),
                                                      base_type::getIndex(),
                                                      layout.default_value_info->getDefaultValue());
        }
        else {
            // we can only reset known types
            if (zero_value_of_known_type) {
                auto known_type = base_type::getType();
                if (known_type != ElementType::cet_empty &&
                    known_type != ElementType::cet_sub_codec &&
                    known_type != ElementType::cet_user_type) {
                    uint64_t null_value = 0;
                    return ElementAccessType::setRawValue(base_type::getAccess(),
                                                          base_type::getIndex(),
                                                          &null_value,
                                                          sizeof(null_value));
                }
            }
        }
    }
 
    using base_type::getAddress;
    void* getAddress()
    {
        return ElementAccessType::getAddress(base_type::getAccess(), base_type::getIndex());
    }
 
    using factory_base_type::getChildElements;
    child_elements_type& getChildElements()
    {
        return factory_base_type::_child_elements;
    }
    self_type getChildElement(const std::string& name) const
    {
        auto full_name = base_type::getFullName();
        full_name.append(".");
        full_name.append(name);
        return self_type(full_name, base_type::getAccess());
    }
 
    self_type getChildElement(const std::string& name)
    {
        auto full_name = base_type::getFullName();
        full_name.append(".");
        full_name.append(name);
        return self_type(full_name, base_type::getAccess());
    }
    self_type getArrayElement(size_t array_pos = 0) const
    {
        return self_type(base_type::getIndex().getIndexForArrayPos(array_pos),
                         base_type::getAccess());
    }
 
    self_type getArrayElement(size_t array_pos = 0)
    {
        return self_type(base_type::getIndex().getIndexForArrayPos(array_pos),
                         base_type::getAccess());
    }
 
private:
    CodecElement(CodecIndex&& index,
                 size_t end_element_index,
                 size_t child_elements_count,
                 access_type& access)
        : base_type(std::move(index), end_element_index, child_elements_count, access)
    {
    }
    CodecElement(CodecIndex&& index, size_t end_element_index, access_type& access)
        : base_type(std::move(index), end_element_index, access)
    {
    }
    CodecElement(const std::string& element_name, access_type& access)
        : base_type(element_name, access)
    {
    }
    CodecElement(CodecIndex&& index, access_type& access) : base_type(std::move(index), access)
    {
    }
    CodecElement(access_type& access) : base_type(access)
    {
    }
    void next()
    {
        base_type::next();
    }
};
 
template <typename ElementsType>
void forEachLeafElement(
    ElementsType& elements,
    const std::function<void(std::conditional_t<std::is_const<ElementsType>::value,
                                                const typename ElementsType::element_type,
                                                typename ElementsType::element_type>&)>& func)
{
    for (auto& element: elements) {
        if (element.hasChildren()) {
            if (element.isArray()) {
                for (size_t array_pos = 0; array_pos < element.getArraySize(); ++array_pos) {
                    auto array_element = element.getArrayElement(array_pos);
                    auto& children = array_element.getChildElements();
                    forEachLeafElement(children, func);
                }
            }
            else {
                auto& children = element.getChildElements();
                forEachLeafElement(children, func);
            }
        }
        else {
            if (element.isArray()) {
                for (size_t array_pos = 0; array_pos < element.getArraySize(); ++array_pos) {
                    auto array_element = element.getArrayElement(array_pos);
                    func(array_element);
                }
            }
            else {
                func(element);
            }
        }
    }
}
 
template <typename ElementsType>
void forEachElement(
    ElementsType& elements,
    const std::function<void(std::conditional_t<std::is_const<ElementsType>::value,
                                                const typename ElementsType::element_type,
                                                typename ElementsType::element_type>&)>& func)
{
    for (auto& element: elements) {
        func(element);
        if (element.hasChildren()) {
            auto& children = element.getChildElements();
            forEachElement(children, func);
        }
    }
}
 
} // namespace codec
} // namespace ddl
 
#endif // DDL_CODEC_ITERATOR_CLASS_HEADER