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

    constexpr bool operator==(const Position& other) const noexcept
    {
        return bit_offset == other.bit_offset && bit_size == other.bit_size;
    }

    constexpr bool operator!=(const Position& other) const noexcept
    {
        return !operator==(other);
    }
};

namespace codec {

using Position = ddl::Position;

struct PositionWithTypeSize : public Position {
    size_t type_bit_size = {};

    constexpr bool operator==(const PositionWithTypeSize& other) const noexcept
    {
        return Position::operator==(other) && type_bit_size == other.type_bit_size;
    }

    constexpr bool operator!=(const PositionWithTypeSize& other) const noexcept
    {
        return !operator==(other);
    }
};

struct PositionWithAlignedTypeSize : public PositionWithTypeSize {
    size_t type_bit_size_aligned = {};

    constexpr bool operator==(const PositionWithAlignedTypeSize& other) const noexcept
    {
        return PositionWithTypeSize::operator==(other) &&
               type_bit_size_aligned == other.type_bit_size_aligned;
    }

    constexpr bool operator!=(const PositionWithAlignedTypeSize& other) const noexcept
    {
        return !operator==(other);
    }
};

struct PositionWithUsedBitsTypeSize : public PositionWithTypeSize {
    size_t type_bit_size_used = {};

    constexpr bool operator==(const PositionWithUsedBitsTypeSize& other) const noexcept
    {
        return PositionWithTypeSize::operator==(other) &&
               type_bit_size_used == other.type_bit_size_used;
    }

    constexpr bool operator!=(const PositionWithUsedBitsTypeSize& other) const noexcept
    {
        return !operator==(other);
    }
};

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

    constexpr bool operator==(const ElementLayoutBase& other) const noexcept
    {
        return deserialized == other.deserialized && serialized == other.serialized &&
               byte_order == other.byte_order && array_size == other.array_size &&
               child_element_count == other.child_element_count && type_info == other.type_info &&
               constant_info == other.constant_info &&
               default_value_info == other.default_value_info;
    }

    constexpr bool operator!=(const ElementLayoutBase& other) const noexcept
    {
        return !operator==(other);
    }
};

struct ElementLayout : public ElementLayoutBase {
    size_t array_pos = {};

    constexpr bool operator==(const ElementLayout& other) const noexcept
    {
        return ElementLayoutBase::operator==(other) && array_pos == other.array_pos;
    }

    constexpr bool operator!=(const ElementLayout& other) const noexcept
    {
        return !operator==(other);
    }
};

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(const CodecIndex& codec_index, size_t reserved_count);
    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 reserve(size_t size);
    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