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;

    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;
};

using CallbackStructElementAccess =
    std::function<void(const StructElementAccess& /*child*/, const StructTypeAccess& /*parent*/)>;
using CallbackStructElementAccessControl =
    std::function<bool(const StructElementAccess& /*child*/, const StructTypeAccess& /*parent*/)>;

void forEachElementInfix(
    const StructTypeAccess& parent,
    const CallbackStructElementAccess& access_leaf_callback,
    const CallbackStructElementAccessControl& enter_element_member_callback =
        [](auto&, auto&) { return true; },
    const CallbackStructElementAccess& leave_element_member_callback = [](auto&, auto&) {},
    const CallbackStructElementAccessControl& enter_array_element_member_callback =
        [](auto&, auto&) { return true; },
    const CallbackStructElementAccess& leave_array_element_member_callback = [](auto&, auto&) {},
    bool filter_padding_elements = true);

void forEachElementInPathInfix(
    const StructTypeAccess& parent,
    std::string_view path,
    const CallbackStructElementAccess& target_element_callback,
    const CallbackStructElementAccess& enter_element_member_callback = [](auto&, auto&) {},
    const CallbackStructElementAccess& leave_element_member_callback = [](auto&, auto&) {},
    const CallbackStructElementAccess& enter_array_element_member_callback = [](auto&, auto&) {},
    const CallbackStructElementAccess& leave_array_element_member_callback = [](auto&, auto&) {});
 
} // namespace dd
} // namespace ddl
 
#endif // DD_DDL_STRUCT_ACCESS_H_INCLUDED