codec_index.h

Go to the documentation of this file.

 
#ifndef DDL_CODEC_INDEX_CLASS_HEADER
#define DDL_CODEC_INDEX_CLASS_HEADER
 
#include <ddl/codec/codec_type_info.h>
#include <ddl/dd/dd_common_types.h>
 
#include <string>
#include <vector>
 
namespace ddl {
struct Position {
    size_t bit_offset = {};
    size_t bit_size = {};
};
namespace codec {
 
using Position = ddl::Position;
 
struct PositionWithTypeSize : public Position {
    size_t type_bit_size = {};
};
struct PositionWithAlignedTypeSize : public PositionWithTypeSize {
    size_t type_bit_size_aligned = {};
};
 
struct PositionWithUsedBitsTypeSize : public PositionWithTypeSize {
    size_t type_bit_size_used = {};
};
 
struct ElementLayoutBase {
    PositionWithAlignedTypeSize deserialized = {};
    PositionWithUsedBitsTypeSize serialized = {};
    ddl::dd::ByteOrder byte_order = {};
    size_t array_size = {};
    size_t child_element_count = {};
    const CodecTypeInfo* type_info = {};
    const CodecConstantInfo* constant_info = {};
    const CodecDefaultValueInfo* default_value_info = {};
};
 
struct ElementLayout : public ElementLayoutBase {
    size_t array_pos = {};
};
 
class CodecIndex {
public:
    class ElementIndex {
    public:
        ElementIndex() = default;
        ElementIndex(size_t element_index);
        ElementIndex(size_t element_index, size_t array_pos);
 
        bool operator==(const ElementIndex& other) const;
        bool operator!=(const ElementIndex& other) const;
 
        size_t getIndex() const;
        size_t getArrayPos() const;
 
        ElementIndex& operator++();
 
        static constexpr size_t _invalid_element_index = static_cast<size_t>(-1);
        static constexpr size_t _invalid_array_pos = static_cast<size_t>(-1);
 
    private:
        size_t _element_index = _invalid_element_index;
        size_t _array_pos = _invalid_array_pos;
    };
    CodecIndex() = default;
    const ElementIndex& operator[](size_t pos) const;
    bool operator==(const CodecIndex& other) const;
    bool operator!=(const CodecIndex& other) const;
    size_t getSize() const;
    size_t size() const;
    bool hasLayout() const;
    ElementType getType() const;
    const ElementLayout& getLayout() const;
 
private:
    friend class StructAccess;
    friend class ChildElementAccess;
    template <typename ElementAccessType, typename ChildElementsType>
    friend class FactoryElement;
    template <typename ElementAccessType, typename ChildElementsType>
    friend class DecoderElement;
    template <typename ElementAccessType, typename ChildElementsType>
    friend class CodecElement;
    template <typename ElementAccessType>
    friend class ChildElements;
 
    CodecIndex(const CodecIndex& codec_index, ElementIndex index);
    CodecIndex(ElementIndex index);
    CodecIndex(const CodecIndex& codec_index, size_t count, ElementIndex index);
    CodecIndex(const std::vector<ElementIndex>& indexes);
    CodecIndex(ElementIndex index, const ElementLayout& layout);
    CodecIndex(const CodecIndex& codec_index,
               size_t count,
               ElementIndex index,
               const ElementLayout& layout);
 
    CodecIndex& operator++();
    CodecIndex operator++(int);
 
    void setLayout(const ElementLayout& layout);
    void addElementIndex(ElementIndex index);
    CodecIndex::ElementIndex back() const noexcept;
    CodecIndex getIndexForArrayPos(size_t array_pos) const;
 
private:
    std::vector<ElementIndex> _indices = {};
    ElementLayout _layout = {};
    bool _layout_valid = {};
};
 
std::string toString(const CodecIndex& index);
 
} // namespace codec
} // namespace ddl
 
#endif // DDL_CODEC_INDEX_CLASS_HEADER