dd_struct_access.h

Go to the documentation of this file.

 
#ifndef DD_DDL_STRUCT_ACCESS_H_INCLUDED
#define DD_DDL_STRUCT_ACCESS_H_INCLUDED
 
#include <ddl/dd/datamodel/datamodel_datadefinition.h>
 
#include <cstddef>
#include <functional>
#include <string>
 
namespace ddl {
namespace dd {
 
class TypeInfo;
class ElementTypeInfo;
class StructTypeAccess;
class StructArrayElementAccessIterator;

class StructElementAccess {
public:
    friend class StructTypeAccess;
    friend class StructElementAccessIterator;
    friend class StructArrayElementAccessIterator;

    StructElementAccess() = delete;
    StructElementAccess(StructElementAccess&&) noexcept;
    StructElementAccess& operator=(StructElementAccess&&) noexcept;
    StructElementAccess(const StructElementAccess&);
    StructElementAccess& operator=(const StructElementAccess&);
    StructElementAccess(std::nullptr_t);

    ~StructElementAccess();

    operator bool() const;
    TypeOfType getTypeOfType() const;

    std::string getName() const;
    std::shared_ptr<const datamodel::StructType> getStructType() const;
    std::shared_ptr<const datamodel::EnumType> getEnumType() const;
    std::shared_ptr<const datamodel::DataType> getDataType() const;

    StructTypeAccess getStructTypeAccess(size_t array_pos = 0) const;

    bool isStruct() const;

    bool isLeaf() const;

    bool isArray() const;

    bool isPadding() const;

    size_t getArraySize() const;

    StructElementAccess getArrayElement(size_t array_pos = 0) const;

    const datamodel::StructType::Element& getElement() const;
    bool isDynamic() const;
    bool isAfterDynamic() const;
    OptionalSize getArrayPos() const;
    size_t getDeserializedBytePos(size_t array_pos = 0) const;
    size_t getDeserializedByteSize() const;

    size_t getDeserializedTypeByteSize() const;

    size_t getDeserializedTypeAlignedByteSize() const;
    size_t getSerializedBytePos(size_t array_pos = 0) const;
    size_t getSerializedBitOffset(size_t array_pos = 0) const;
    size_t getSerializedBitSize() const;
    size_t getSerializedTypeBitSize() const;

    bool hasValidElementCount() const;

    const std::string& getValidElementCount() const;

    typedef StructArrayElementAccessIterator const_iterator;

    const_iterator cbegin() const;
    const_iterator cend() const;
    const_iterator begin() const;
    const_iterator end() const;
 
private:
    StructElementAccess(const std::shared_ptr<const datamodel::StructType::Element>& elem,
                        OptionalSize serialized_element_bit_offset,
                        OptionalSize deserialized_element_byte_offset,
                        OptionalSize array_pos);
    StructElementAccess(const std::shared_ptr<const datamodel::StructType::Element>& elem,
                        const ElementTypeInfo* element_type_info,
                        OptionalSize serialized_element_bit_offset,
                        OptionalSize deserialized_element_byte_offset,
                        OptionalSize array_pos);
 
private:
    std::shared_ptr<const datamodel::StructType::Element> _element = {};
    const ElementTypeInfo* _element_type_info = nullptr;
    OptionalSize _deserialized_struct_byte_offset = {};
    OptionalSize _serialized_struct_bit_offset = {};
    OptionalSize _array_pos = {};
};

class StructArrayElementAccessIterator {
public:
    StructArrayElementAccessIterator() = delete;
    StructArrayElementAccessIterator(const StructArrayElementAccessIterator&);
    StructArrayElementAccessIterator& operator=(const StructArrayElementAccessIterator&);
    StructArrayElementAccessIterator(StructArrayElementAccessIterator&&) noexcept;
    StructArrayElementAccessIterator& operator=(StructArrayElementAccessIterator&&) noexcept;
    ~StructArrayElementAccessIterator();
    typedef StructArrayElementAccessIterator self_type;
    typedef StructElementAccess value_type;
    typedef StructElementAccess& reference;
    typedef const StructElementAccess& const_reference;
    typedef StructElementAccess* pointer;
    typedef const StructElementAccess* const_pointer;
    typedef int difference_type;
    typedef std::forward_iterator_tag iterator_category;

    self_type& operator++();
    self_type operator++(int);
    const_reference operator*() const;
    const_pointer operator->() const;
    bool operator==(const self_type& rhs) const;
    bool operator!=(const self_type& rhs) const;
 
private:
    friend class StructElementAccess;
    StructArrayElementAccessIterator(const StructElementAccess* parent,
                                     StructElementAccess array_element);
    const StructElementAccess* _parent;
    StructElementAccess _current_array_element;
};

class StructElementAccessIterator {
public:
    StructElementAccessIterator() = delete;
    StructElementAccessIterator(const StructElementAccessIterator&);
    StructElementAccessIterator& operator=(const StructElementAccessIterator&);
    StructElementAccessIterator(StructElementAccessIterator&&) noexcept;
    StructElementAccessIterator& operator=(StructElementAccessIterator&&) noexcept;
    ~StructElementAccessIterator();
    typedef StructElementAccessIterator self_type;
    typedef StructElementAccess value_type;
    typedef StructElementAccess& reference;
    typedef const StructElementAccess& const_reference;
    typedef StructElementAccess* pointer;
    typedef const StructElementAccess* const_pointer;
    typedef int difference_type;
    typedef std::forward_iterator_tag iterator_category;

    self_type operator++();
    self_type operator++(int junk);
    const_reference operator*() const;
    const_pointer operator->() const;
    bool operator==(const self_type& rhs) const;
    bool operator!=(const self_type& rhs) const;
 
private:
    friend StructTypeAccess;
    StructElementAccessIterator(datamodel::StructType::Elements::const_iterator other_it,
                                datamodel::StructType::Elements::const_iterator end_it,
                                OptionalSize struct_ser,
                                OptionalSize struct_deser);
    datamodel::StructType::Elements::const_iterator _base_it;
    datamodel::StructType::Elements::const_iterator _end_it;
    StructElementAccess _ref;
    OptionalSize _struct_ser;
    OptionalSize _struct_deser;
};

class StructTypeAccess {
public:
    friend class DataDefinition;
    friend class StructElementAccess;
    friend class ElementTypeInfo;
    StructTypeAccess() = delete;
    StructTypeAccess(StructTypeAccess&&) noexcept;
    StructTypeAccess& operator=(StructTypeAccess&&) noexcept;
    StructTypeAccess(const StructTypeAccess&);
    StructTypeAccess& operator=(const StructTypeAccess&);

    StructTypeAccess(const std::shared_ptr<const datamodel::StructType>& struct_type);

    StructTypeAccess(std::nullptr_t);

    ~StructTypeAccess();
 
private:
    StructTypeAccess(const std::shared_ptr<const datamodel::StructType>& struct_type,
                     OptionalSize serialized_struct_offset,
                     OptionalSize deserialized_struct_offset);
 
public:
    StructElementAccess getElementByPath(std::string_view name_path) const;
    operator bool() const;
    size_t getStaticStructSize() const;

    size_t getStaticUnalignedStructSize() const;

    size_t getStaticSerializedBitSize() const;

    bool isDynamic() const;

    const datamodel::StructType& getStructType() const;

    typedef const StructElementAccessIterator const_iterator;
    const_iterator cbegin() const;
    const_iterator begin() const;
    const_iterator cend() const;
    const_iterator end() const;
 
private:
    std::shared_ptr<const datamodel::StructType> _struct_type;
    OptionalSize _serialized_struct_as_element_offset =
        {}; // these values are greater 0 if the struct is used within another struct and we
            // calculate that element
    OptionalSize _deserialized_struct_as_element_offset =
        {}; // these values are greater 0 if the struct is used within another struct and we
            // calculate that element
    const TypeInfo* _type_info = nullptr;
};

std::pair<std::string_view, std::string_view> findFirstNameInPath(std::string_view name_path);

std::pair<std::string_view, OptionalSize> findArrayPos(std::string_view name);

using CallbackStructElementAccess =
    std::function<void(const StructElementAccess& /*child*/, const StructTypeAccess& /*parent*/)>;
using CallbackStructElementAccessControl =
    std::function<bool(const StructElementAccess& /*child*/, const StructTypeAccess& /*parent*/)>;
 
/*
 * @brief Helper to assert proper visitor callbacks
 * @see @ref forEachElementInfix
 * @see @ref forEachElementInPathInfix
 */
template <class RETURN_VALUE, class CALLBACK>
inline constexpr bool is_for_each_element_callback_v =
    std::is_invocable_r_v<RETURN_VALUE,
                          std::decay_t<CALLBACK>,
                          const StructElementAccess&,
                          const StructTypeAccess&>;

 
template <typename ACCESS_LEAF_CALLBACK,
          typename ENTER_ELEMENT_MEMBER_CALLBACK,
          typename LEAVE_ELEMENT_MEMBER_CALLBACK,
          typename ENTER_ARRAY_ELEMENT_MEMBER_CALLBACK,
          typename LEAVE_ARRAY_ELEMENT_MEMBER_CALLBACK>
void forEachElementInfix(const StructTypeAccess& parent,
                         ACCESS_LEAF_CALLBACK&& access_leaf_callback,
                         ENTER_ELEMENT_MEMBER_CALLBACK&& enter_element_member_callback,
                         LEAVE_ELEMENT_MEMBER_CALLBACK&& leave_element_member_callback,
                         ENTER_ARRAY_ELEMENT_MEMBER_CALLBACK&& enter_array_element_member_callback,
                         LEAVE_ARRAY_ELEMENT_MEMBER_CALLBACK&& leave_array_element_member_callback,
                         bool filter_padding_elements = true,
                         bool continue_arrays_after_skip = true)
{
    static_assert(is_for_each_element_callback_v<void, ACCESS_LEAF_CALLBACK>);
    static_assert(is_for_each_element_callback_v<bool, ENTER_ELEMENT_MEMBER_CALLBACK>);
    static_assert(is_for_each_element_callback_v<void, LEAVE_ELEMENT_MEMBER_CALLBACK>);
    static_assert(is_for_each_element_callback_v<bool, ENTER_ARRAY_ELEMENT_MEMBER_CALLBACK>);
    static_assert(is_for_each_element_callback_v<void, LEAVE_ARRAY_ELEMENT_MEMBER_CALLBACK>);
 
    for (const auto& child: parent) {
        if (filter_padding_elements && child.isPadding()) {
            continue;
        }
        if (enter_element_member_callback(child, parent)) {
            if (child.isArray()) {
                for (const auto& array_element: child) {
                    if (array_element.isStruct()) {
                        const auto child_array_struct_access = array_element.getStructTypeAccess();
                        if (enter_array_element_member_callback(array_element,
                                                                child_array_struct_access)) {
                            forEachElementInfix(child_array_struct_access,
                                                access_leaf_callback,
                                                enter_element_member_callback,
                                                leave_element_member_callback,
                                                enter_array_element_member_callback,
                                                leave_array_element_member_callback,
                                                filter_padding_elements,
                                                continue_arrays_after_skip);
                            leave_array_element_member_callback(array_element,
                                                                child_array_struct_access);
                        }
                        else if (!continue_arrays_after_skip) {
                            break;
                        }
                    }
                    else {
                        if (enter_array_element_member_callback(array_element, parent)) {
                            access_leaf_callback(array_element, parent);
                            leave_array_element_member_callback(array_element, parent);
                        }
                        else if (!continue_arrays_after_skip) {
                            break;
                        }
                    }
                }
            }
            else {
                if (child.isStruct()) {
                    forEachElementInfix(child.getStructTypeAccess(),
                                        access_leaf_callback,
                                        enter_element_member_callback,
                                        leave_element_member_callback,
                                        enter_array_element_member_callback,
                                        leave_array_element_member_callback,
                                        filter_padding_elements,
                                        continue_arrays_after_skip);
                }
                else {
                    access_leaf_callback(child, parent);
                }
            }
            leave_element_member_callback(child, parent);
        }
    }
}

template <typename ACCESS_LEAF_CALLBACK,
          typename ENTER_ELEMENT_MEMBER_CALLBACK,
          typename LEAVE_ELEMENT_MEMBER_CALLBACK>
void forEachElementInfix(const StructTypeAccess& parent,
                         ACCESS_LEAF_CALLBACK&& access_leaf_callback,
                         ENTER_ELEMENT_MEMBER_CALLBACK&& enter_element_member_callback,
                         LEAVE_ELEMENT_MEMBER_CALLBACK&& leave_element_member_callback,
                         bool filter_padding_elements = true)
{
    forEachElementInfix(
        parent,
        std::forward<ACCESS_LEAF_CALLBACK>(access_leaf_callback),
        std::forward<ENTER_ELEMENT_MEMBER_CALLBACK>(enter_element_member_callback),
        std::forward<LEAVE_ELEMENT_MEMBER_CALLBACK>(leave_element_member_callback),
        [](const auto&, const auto&) noexcept -> bool { return true; },
        [](const auto&, const auto&) noexcept -> void {},
        filter_padding_elements,
        true);
}

template <typename ACCESS_LEAF_CALLBACK>
void forEachElementInfix(const StructTypeAccess& parent,
                         ACCESS_LEAF_CALLBACK&& access_leaf_callback,
                         bool filter_padding_elements = true)
{
    forEachElementInfix(
        parent,
        std::forward<ACCESS_LEAF_CALLBACK>(access_leaf_callback),
        [](const auto&, const auto&) noexcept -> bool { return true; },
        [](const auto&, const auto&) noexcept -> void {},
        [](const auto&, const auto&) noexcept -> bool { return true; },
        [](const auto&, const auto&) noexcept -> void {},
        filter_padding_elements,
        true);
}

template <typename TARGET_ELEMENT_CALLBACK,
          typename ENTER_ELEMENT_MEMBER_CALLBACK,
          typename LEAVE_ELEMENT_MEMBER_CALLBACK,
          typename ENTER_ARRAY_ELEMENT_MEMBER_CALLBACK,
          typename LEAVE_ARRAY_ELEMENT_MEMBER_CALLBACK>
void forEachElementInPathInfix(
    const StructTypeAccess& parent,
    std::string_view path,
    TARGET_ELEMENT_CALLBACK&& target_element_callback,
    ENTER_ELEMENT_MEMBER_CALLBACK&& enter_element_member_callback,
    LEAVE_ELEMENT_MEMBER_CALLBACK&& leave_element_member_callback,
    ENTER_ARRAY_ELEMENT_MEMBER_CALLBACK&& enter_array_element_member_callback,
    LEAVE_ARRAY_ELEMENT_MEMBER_CALLBACK&& leave_array_element_member_callback)
{
    static_assert(is_for_each_element_callback_v<void, TARGET_ELEMENT_CALLBACK>);
    static_assert(is_for_each_element_callback_v<void, ENTER_ELEMENT_MEMBER_CALLBACK>);
    static_assert(is_for_each_element_callback_v<void, LEAVE_ELEMENT_MEMBER_CALLBACK>);
    static_assert(is_for_each_element_callback_v<void, ENTER_ARRAY_ELEMENT_MEMBER_CALLBACK>);
    static_assert(is_for_each_element_callback_v<void, LEAVE_ARRAY_ELEMENT_MEMBER_CALLBACK>);
 
    if (parent) {
        auto [name, tail] = findFirstNameInPath(path);
        const auto [element_name, array_pos] = findArrayPos(name);
        const auto child = parent.getElementByPath(element_name);
        if (child) {
            enter_element_member_callback(child, parent);
            if (array_pos) {
                const auto array_element_child = child.getArrayElement(array_pos.get());
                if (array_element_child) {
                    enter_array_element_member_callback(array_element_child, parent);
                    if (tail.empty()) {
                        target_element_callback(array_element_child, parent);
                    }
                    else {
                        forEachElementInPathInfix(array_element_child.getStructTypeAccess(),
                                                  tail,
                                                  target_element_callback,
                                                  enter_element_member_callback,
                                                  leave_element_member_callback,
                                                  enter_array_element_member_callback,
                                                  leave_array_element_member_callback);
                    }
                    leave_array_element_member_callback(array_element_child, parent);
                }
            }
            else {
                if (tail.empty()) {
                    target_element_callback(child, parent);
                }
                else {
                    forEachElementInPathInfix(child.getStructTypeAccess(),
                                              tail,
                                              target_element_callback,
                                              enter_element_member_callback,
                                              leave_element_member_callback,
                                              enter_array_element_member_callback,
                                              leave_array_element_member_callback);
                }
            }
            leave_element_member_callback(child, parent);
        }
    }
}

template <typename TARGET_ELEMENT_CALLBACK,
          typename ENTER_ELEMENT_MEMBER_CALLBACK,
          typename LEAVE_ELEMENT_MEMBER_CALLBACK>
void forEachElementInPathInfix(const StructTypeAccess& parent,
                               std::string_view path,
                               TARGET_ELEMENT_CALLBACK&& target_element_callback,
                               ENTER_ELEMENT_MEMBER_CALLBACK&& enter_element_member_callback,
                               LEAVE_ELEMENT_MEMBER_CALLBACK&& leave_element_member_callback)
{
    forEachElementInPathInfix(
        parent,
        path,
        std::forward<TARGET_ELEMENT_CALLBACK>(target_element_callback),
        std::forward<ENTER_ELEMENT_MEMBER_CALLBACK>(enter_element_member_callback),
        std::forward<LEAVE_ELEMENT_MEMBER_CALLBACK>(leave_element_member_callback),
        [](const auto&, const auto&) noexcept -> void {},
        [](const auto&, const auto&) noexcept -> void {});
}
 
} // namespace dd
} // namespace ddl
 
#endif // DD_DDL_STRUCT_ACCESS_H_INCLUDED