ArrayTraits.h

Go to the documentation of this file.

#ifndef ZSERIO_ARRAY_TRAITS_H_INC
#define ZSERIO_ARRAY_TRAITS_H_INC
 
#include <string>
#include <type_traits>
#include <vector>
 
#include "zserio/BitPositionUtil.h"
#include "zserio/BitSizeOfCalculator.h"
#include "zserio/BitStreamReader.h"
#include "zserio/BitStreamWriter.h"
#include "zserio/DeltaContext.h"
#include "zserio/Enums.h"
#include "zserio/SizeConvertUtil.h"
#include "zserio/Traits.h"
#include "zserio/Types.h"
 
namespace zserio
{
 
namespace detail
{
 
template <typename T>
T read_bits(BitStreamReader& in, uint8_t numBits);
 
template <>
inline int8_t read_bits<int8_t>(BitStreamReader& in, uint8_t numBits)
{
    return static_cast<int8_t>(in.readSignedBits(numBits));
}
 
template <>
inline int16_t read_bits<int16_t>(BitStreamReader& in, uint8_t numBits)
{
    return static_cast<int16_t>(in.readSignedBits(numBits));
}
 
template <>
inline int32_t read_bits<int32_t>(BitStreamReader& in, uint8_t numBits)
{
    return in.readSignedBits(numBits);
}
 
template <>
inline int64_t read_bits<int64_t>(BitStreamReader& in, uint8_t numBits)
{
    return in.readSignedBits64(numBits);
}
 
template <>
inline uint8_t read_bits<uint8_t>(BitStreamReader& in, uint8_t numBits)
{
    return static_cast<uint8_t>(in.readBits(numBits));
}
 
template <>
inline uint16_t read_bits<uint16_t>(BitStreamReader& in, uint8_t numBits)
{
    return static_cast<uint16_t>(in.readBits(numBits));
}
 
template <>
inline uint32_t read_bits<uint32_t>(BitStreamReader& in, uint8_t numBits)
{
    return in.readBits(numBits);
}
 
template <>
inline uint64_t read_bits<uint64_t>(BitStreamReader& in, uint8_t numBits)
{
    return in.readBits64(numBits);
}
 
template <typename T>
void write_bits(BitStreamWriter& out, T value, uint8_t numBits);
 
template <>
inline void write_bits<int8_t>(BitStreamWriter& out, int8_t value, uint8_t numBits)
{
    out.writeSignedBits(static_cast<int32_t>(value), numBits);
}
 
template <>
inline void write_bits<int16_t>(BitStreamWriter& out, int16_t value, uint8_t numBits)
{
    out.writeSignedBits(static_cast<int32_t>(value), numBits);
}
 
template <>
inline void write_bits<int32_t>(BitStreamWriter& out, int32_t value, uint8_t numBits)
{
    out.writeSignedBits(value, numBits);
}
 
template <>
inline void write_bits<int64_t>(BitStreamWriter& out, int64_t value, uint8_t numBits)
{
    out.writeSignedBits64(value, numBits);
}
 
template <>
inline void write_bits<uint8_t>(BitStreamWriter& out, uint8_t value, uint8_t numBits)
{
    out.writeBits(static_cast<uint32_t>(value), numBits);
}
 
template <>
inline void write_bits<uint16_t>(BitStreamWriter& out, uint16_t value, uint8_t numBits)
{
    out.writeBits(static_cast<uint32_t>(value), numBits);
}
 
template <>
inline void write_bits<uint32_t>(BitStreamWriter& out, uint32_t value, uint8_t numBits)
{
    out.writeBits(value, numBits);
}
 
template <>
inline void write_bits<uint64_t>(BitStreamWriter& out, uint64_t value, uint8_t numBits)
{
    out.writeBits64(value, numBits);
}
 
} // namespace detail
 
template <typename T, uint8_t NUM_BITS>
class BitFieldArrayTraits
{
public:
    using ElementType = T;
 
    static size_t bitSizeOf()
    {
        return NUM_BITS;
    }
 
    static size_t bitSizeOf(ElementType)
    {
        return bitSizeOf();
    }
 
    static size_t bitSizeOf(size_t, ElementType)
    {
        return bitSizeOf();
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType)
    {
        return bitPosition + NUM_BITS;
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return detail::read_bits<T>(in, NUM_BITS);
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        detail::write_bits(out, element, NUM_BITS);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = true;
};
 
template <typename T, typename ELEMENT_BIT_SIZE, typename = void>
class DynamicBitFieldArrayTraits
{
public:
    using ElementType = T;
 
    static size_t bitSizeOf()
    {
        return ELEMENT_BIT_SIZE::get();
    }
 
    static size_t bitSizeOf(ElementType)
    {
        return bitSizeOf();
    }
 
    static size_t bitSizeOf(size_t, ElementType)
    {
        return bitSizeOf();
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType)
    {
        return bitPosition + bitSizeOf();
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return detail::read_bits<T>(in, ELEMENT_BIT_SIZE::get());
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        detail::write_bits(out, element, ELEMENT_BIT_SIZE::get());
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = true;
};
 
template <typename T, typename ELEMENT_BIT_SIZE>
class DynamicBitFieldArrayTraits<T, ELEMENT_BIT_SIZE,
        typename std::enable_if<has_owner_type<ELEMENT_BIT_SIZE>::value>::type>
{
public:
    using ElementType = T;
 
    using OwnerType = typename ELEMENT_BIT_SIZE::OwnerType;
 
    static size_t bitSizeOf(const OwnerType& owner)
    {
        return ELEMENT_BIT_SIZE::get(owner);
    }
 
    static size_t bitSizeOf(const OwnerType& owner, ElementType)
    {
        return bitSizeOf(owner);
    }
 
    static size_t bitSizeOf(const OwnerType& owner, size_t, ElementType)
    {
        return bitSizeOf(owner);
    }
 
    static size_t initializeOffsets(const OwnerType& owner, size_t bitPosition, ElementType)
    {
        return bitPosition + bitSizeOf(owner);
    }
 
    static ElementType read(const OwnerType& owner, BitStreamReader& in, size_t = 0)
    {
        return detail::read_bits<T>(in, ELEMENT_BIT_SIZE::get(owner));
    }
 
    static void write(const OwnerType& owner, BitStreamWriter& out, ElementType element)
    {
        detail::write_bits(out, element, ELEMENT_BIT_SIZE::get(owner));
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = true;
};
 
template <typename T>
struct StdIntArrayTraits
{
    using ElementType = T;
 
    static size_t bitSizeOf()
    {
        return NUM_BITS;
    }
 
    static size_t bitSizeOf(ElementType)
    {
        return bitSizeOf();
    }
 
    static size_t bitSizeOf(size_t, ElementType)
    {
        return bitSizeOf();
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType)
    {
        return bitPosition + NUM_BITS;
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return detail::read_bits<T>(in, NUM_BITS);
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        detail::write_bits(out, element, NUM_BITS);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = true;
 
private:
    static constexpr uint8_t NUM_BITS = sizeof(T) * 8;
};
 
template <typename T>
struct VarIntNNArrayTraits;
 
template <>
struct VarIntNNArrayTraits<int16_t>
{
    using ElementType = int16_t;
 
    static size_t bitSizeOf(ElementType element)
    {
        return zserio::bitSizeOfVarInt16(element);
    }
 
    static size_t bitSizeOf(size_t, ElementType element)
    {
        return bitSizeOf(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readVarInt16();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeVarInt16(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
template <>
struct VarIntNNArrayTraits<int32_t>
{
    using ElementType = int32_t;
 
    static size_t bitSizeOf(ElementType element)
    {
        return zserio::bitSizeOfVarInt32(element);
    }
 
    static size_t bitSizeOf(size_t, ElementType element)
    {
        return bitSizeOf(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readVarInt32();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeVarInt32(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
template <>
struct VarIntNNArrayTraits<int64_t>
{
    using ElementType = int64_t;
 
    static size_t bitSizeOf(ElementType element)
    {
        return zserio::bitSizeOfVarInt64(element);
    }
 
    static size_t bitSizeOf(size_t, ElementType element)
    {
        return bitSizeOf(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readVarInt64();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeVarInt64(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
template <>
struct VarIntNNArrayTraits<uint16_t>
{
    using ElementType = uint16_t;
 
    static size_t bitSizeOf(ElementType element)
    {
        return zserio::bitSizeOfVarUInt16(element);
    }
 
    static size_t bitSizeOf(size_t, ElementType element)
    {
        return bitSizeOf(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readVarUInt16();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeVarUInt16(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
template <>
struct VarIntNNArrayTraits<uint32_t>
{
    using ElementType = uint32_t;
 
    static size_t bitSizeOf(ElementType element)
    {
        return zserio::bitSizeOfVarUInt32(element);
    }
 
    static size_t bitSizeOf(size_t, ElementType element)
    {
        return bitSizeOf(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readVarUInt32();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeVarUInt32(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
template <>
struct VarIntNNArrayTraits<uint64_t>
{
    using ElementType = uint64_t;
 
    static size_t bitSizeOf(ElementType element)
    {
        return zserio::bitSizeOfVarUInt64(element);
    }
 
    static size_t bitSizeOf(size_t, ElementType element)
    {
        return bitSizeOf(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readVarUInt64();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeVarUInt64(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
template <typename T>
struct VarIntArrayTraits;
 
template <>
struct VarIntArrayTraits<int64_t>
{
    using ElementType = int64_t;
 
    static size_t bitSizeOf(ElementType element)
    {
        return zserio::bitSizeOfVarInt(element);
    }
 
    static size_t bitSizeOf(size_t, ElementType element)
    {
        return bitSizeOf(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readVarInt();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeVarInt(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
template <>
struct VarIntArrayTraits<uint64_t>
{
    using ElementType = uint64_t;
 
    static size_t bitSizeOf(ElementType element)
    {
        return zserio::bitSizeOfVarUInt(element);
    }
 
    static size_t bitSizeOf(size_t, ElementType element)
    {
        return bitSizeOf(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readVarUInt();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeVarUInt(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
struct VarSizeArrayTraits
{
    using ElementType = uint32_t;
 
    static size_t bitSizeOf(ElementType element)
    {
        return zserio::bitSizeOfVarSize(element);
    }
 
    static size_t bitSizeOf(size_t, ElementType element)
    {
        return bitSizeOf(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readVarSize();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeVarSize(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
struct Float16ArrayTraits
{
    using ElementType = float;
 
    static size_t bitSizeOf()
    {
        return 16;
    }
 
    static size_t bitSizeOf(size_t, ElementType)
    {
        return bitSizeOf();
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readFloat16();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeFloat16(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = true;
};
 
struct Float32ArrayTraits
{
    using ElementType = float;
 
    static size_t bitSizeOf()
    {
        return 32;
    }
 
    static size_t bitSizeOf(size_t, ElementType)
    {
        return bitSizeOf();
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readFloat32();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeFloat32(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = true;
};
 
struct Float64ArrayTraits
{
    using ElementType = double;
 
    static size_t bitSizeOf()
    {
        return 64;
    }
 
    static size_t bitSizeOf(size_t, ElementType)
    {
        return bitSizeOf();
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readFloat64();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeFloat64(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = true;
};
 
struct BoolArrayTraits
{
    using ElementType = bool;
 
    static size_t bitSizeOf()
    {
        return 1;
    }
 
    static size_t bitSizeOf(size_t, ElementType)
    {
        return bitSizeOf();
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return in.readBool();
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        out.writeBool(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = true;
};
 
template <template <typename> class ALLOC = std::allocator>
struct BasicBytesArrayTraits
{
    using ElementType = zserio::vector<uint8_t, ALLOC<uint8_t>>;
 
    using allocator_type = typename ElementType::allocator_type;
 
    static size_t bitSizeOf(size_t, const ElementType& element)
    {
        return zserio::bitSizeOfBytes(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, const ElementType& element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    template <typename RAW_ARRAY>
    static void read(RAW_ARRAY& rawArray, BitStreamReader& in, size_t = 0)
    {
        rawArray.emplace_back(in.readBytes(rawArray.get_allocator()));
    }
 
    static void write(BitStreamWriter& out, const ElementType& element)
    {
        out.writeBytes(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
using BytesArrayTraits = BasicBytesArrayTraits<>;
 
template <template <typename> class ALLOC = std::allocator>
struct BasicStringArrayTraits
{
    using ElementType = zserio::string<ALLOC<char>>;
 
    using allocator_type = typename ElementType::allocator_type;
 
    static size_t bitSizeOf(size_t, const ElementType& element)
    {
        return zserio::bitSizeOfString(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, const ElementType& element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    template <typename RAW_ARRAY>
    static void read(RAW_ARRAY& rawArray, BitStreamReader& in, size_t = 0)
    {
        rawArray.emplace_back(in.readString(rawArray.get_allocator()));
    }
 
    static void write(BitStreamWriter& out, const ElementType& element)
    {
        out.writeString(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
using StringArrayTraits = BasicStringArrayTraits<>;
 
template <template <typename> class ALLOC = std::allocator>
struct BasicBitBufferArrayTraits
{
    using ElementType = BasicBitBuffer<ALLOC<uint8_t>>;
 
    using allocator_type = typename ElementType::allocator_type;
 
    static size_t bitSizeOf(size_t, const ElementType& element)
    {
        return zserio::bitSizeOfBitBuffer(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, const ElementType& element)
    {
        return bitPosition + bitSizeOf(bitPosition, element);
    }
 
    template <typename RAW_ARRAY>
    static void read(RAW_ARRAY& rawArray, BitStreamReader& in, size_t = 0)
    {
        rawArray.emplace_back(in.readBitBuffer(rawArray.get_allocator()));
    }
 
    static void write(BitStreamWriter& out, const ElementType& element)
    {
        out.writeBitBuffer(element);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
using BitBufferArrayTraits = BasicBitBufferArrayTraits<>;
 
template <typename T>
struct EnumArrayTraits
{
    using ElementType = T;
 
    static size_t bitSizeOf(size_t, ElementType element)
    {
        return zserio::bitSizeOf(element);
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return zserio::initializeOffsets(bitPosition, element);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return zserio::read<ElementType>(in);
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        zserio::write(out, element);
    }
 
    // Be aware that T can be varuint, so bitSizeOf cannot return constant value.
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
template <typename T>
struct BitmaskArrayTraits
{
    using ElementType = T;
 
    static size_t bitSizeOf(size_t, ElementType element)
    {
        return element.bitSizeOf();
    }
 
    static size_t initializeOffsets(size_t bitPosition, ElementType element)
    {
        return element.initializeOffsets(bitPosition);
    }
 
    static ElementType read(BitStreamReader& in, size_t = 0)
    {
        return ElementType(in);
    }
 
    static void write(BitStreamWriter& out, ElementType element)
    {
        element.write(out);
    }
 
    // Be aware that T can be varuint, so bitSizeOf cannot return constant value.
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
template <typename T, typename ELEMENT_FACTORY>
class ObjectArrayTraits
{
public:
    using ElementType = T;
 
    using allocator_type = typename ElementType::allocator_type;
 
    using OwnerType = typename ELEMENT_FACTORY::OwnerType;
 
    static size_t bitSizeOf(const OwnerType&, size_t bitPosition, const ElementType& element)
    {
        return element.bitSizeOf(bitPosition);
    }
 
    static size_t initializeOffsets(OwnerType&, size_t bitPosition, ElementType& element)
    {
        return element.initializeOffsets(bitPosition);
    }
 
    template <typename RAW_ARRAY>
    static void read(OwnerType& owner, RAW_ARRAY& rawArray, BitStreamReader& in, size_t index)
    {
        ELEMENT_FACTORY::create(owner, rawArray, in, index);
    }
 
    static void write(const OwnerType&, BitStreamWriter& out, const ElementType& element)
    {
        element.write(out);
    }
 
    static constexpr bool IS_BITSIZEOF_CONSTANT = false;
};
 
namespace detail
{
 
template <typename ARRAY_TRAITS>
struct packed_array_traits_overloaded : std::false_type
{};
 
template <typename T, typename ELEMENT_FACTORY>
struct packed_array_traits_overloaded<ObjectArrayTraits<T, ELEMENT_FACTORY>> : std::true_type
{};
 
} // namespace detail
 
template <typename ARRAY_TRAITS, typename = void>
class PackedArrayTraits
{
public:
    using ArrayTraits = ARRAY_TRAITS;
 
    using ElementType = typename ARRAY_TRAITS::ElementType;
 
    static void initContext(DeltaContext& deltaContext, ElementType element)
    {
        deltaContext.template init<ArrayTraits>(element);
    }
 
    static size_t bitSizeOf(DeltaContext& deltaContext, size_t, ElementType element)
    {
        return deltaContext.template bitSizeOf<ArrayTraits>(element);
    }
 
    static size_t initializeOffsets(DeltaContext& deltaContext, size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(deltaContext, bitPosition, element);
    }
 
    static ElementType read(DeltaContext& deltaContext, BitStreamReader& in, size_t = 0)
    {
        return deltaContext.template read<ArrayTraits>(in);
    }
 
    static void write(DeltaContext& deltaContext, BitStreamWriter& out, ElementType element)
    {
        deltaContext.template write<ArrayTraits>(out, element);
    }
};
 
template <typename ARRAY_TRAITS>
class PackedArrayTraits<ARRAY_TRAITS, typename std::enable_if<has_owner_type<ARRAY_TRAITS>::value>::type>
{
public:
    using ArrayTraits = ARRAY_TRAITS;
 
    using ElementType = typename ARRAY_TRAITS::ElementType;
 
    using OwnerType = typename ARRAY_TRAITS::OwnerType;
 
    static void initContext(const OwnerType& owner, DeltaContext& deltaContext, ElementType element)
    {
        deltaContext.template init<ArrayTraits>(owner, element);
    }
 
    static size_t bitSizeOf(const OwnerType& owner, DeltaContext& deltaContext, size_t, ElementType element)
    {
        return deltaContext.template bitSizeOf<ArrayTraits>(owner, element);
    }
 
    static size_t initializeOffsets(
            const OwnerType& owner, DeltaContext& deltaContext, size_t bitPosition, ElementType element)
    {
        return bitPosition + bitSizeOf(owner, deltaContext, bitPosition, element);
    }
 
    static ElementType read(const OwnerType& owner, DeltaContext& deltaContext, BitStreamReader& in, size_t = 0)
    {
        return deltaContext.template read<ArrayTraits>(owner, in);
    }
 
    static void write(
            const OwnerType& owner, DeltaContext& deltaContext, BitStreamWriter& out, ElementType element)
    {
        deltaContext.template write<ArrayTraits>(owner, out, element);
    }
};
 
template <typename T>
class PackedArrayTraits<EnumArrayTraits<T>>
{
public:
    using ArrayTraits = EnumArrayTraits<T>;
 
    using ElementType = T;
 
    static void initContext(DeltaContext& deltaContext, ElementType element)
    {
        zserio::initPackingContext(deltaContext, element);
    }
 
    static size_t bitSizeOf(DeltaContext& deltaContext, size_t, ElementType element)
    {
        return zserio::bitSizeOf(deltaContext, element);
    }
 
    static size_t initializeOffsets(DeltaContext& deltaContext, size_t bitPosition, ElementType element)
    {
        return zserio::initializeOffsets(deltaContext, bitPosition, element);
    }
 
    static ElementType read(DeltaContext& deltaContext, BitStreamReader& in, size_t = 0)
    {
        return zserio::read<ElementType>(deltaContext, in);
    }
 
    static void write(DeltaContext& deltaContext, BitStreamWriter& out, ElementType element)
    {
        zserio::write(deltaContext, out, element);
    }
};
 
template <typename T>
class PackedArrayTraits<BitmaskArrayTraits<T>>
{
public:
    using ArrayTraits = BitmaskArrayTraits<T>;
 
    using ElementType = T;
 
    static void initContext(DeltaContext& deltaContext, const ElementType& element)
    {
        element.initPackingContext(deltaContext);
    }
 
    static size_t bitSizeOf(DeltaContext& deltaContext, size_t bitPosition, const ElementType& element)
    {
        return element.bitSizeOf(deltaContext, bitPosition);
    }
 
    static size_t initializeOffsets(DeltaContext& deltaContext, size_t bitPosition, const ElementType& element)
    {
        return element.initializeOffsets(deltaContext, bitPosition);
    }
 
    static ElementType read(DeltaContext& deltaContext, BitStreamReader& in, size_t = 0)
    {
        return ElementType(deltaContext, in);
    }
 
    static void write(DeltaContext& deltaContext, BitStreamWriter& out, const ElementType& element)
    {
        element.write(deltaContext, out);
    }
};
 
// note: enable_if is needed to be more specific then specialization for types which needs owner type
template <typename T, typename ELEMENT_FACTORY>
class PackedArrayTraits<ObjectArrayTraits<T, ELEMENT_FACTORY>,
        typename std::enable_if<has_owner_type<ObjectArrayTraits<T, ELEMENT_FACTORY>>::value>::type>
{
public:
    using ArrayTraits = ObjectArrayTraits<T, ELEMENT_FACTORY>;
 
    using ElementType = T;
 
    using allocator_type = typename T::allocator_type;
 
    using OwnerType = typename ArrayTraits::OwnerType;
 
    template <typename PACKING_CONTEXT>
    static void initContext(
            const typename ArrayTraits::OwnerType&, PACKING_CONTEXT& packingContext, const ElementType& element)
    {
        element.initPackingContext(packingContext);
    }
 
    template <typename PACKING_CONTEXT>
    static size_t bitSizeOf(const typename ArrayTraits::OwnerType&, PACKING_CONTEXT& packingContext,
            size_t bitPosition, const ElementType& element)
    {
        return element.bitSizeOf(packingContext, bitPosition);
    }
 
    template <typename PACKING_CONTEXT>
    static size_t initializeOffsets(const typename ArrayTraits::OwnerType&, PACKING_CONTEXT& packingContext,
            size_t bitPosition, ElementType& element)
    {
        return element.initializeOffsets(packingContext, bitPosition);
    }
 
    template <typename RAW_ARRAY, typename PACKING_CONTEXT>
    static void read(typename ArrayTraits::OwnerType& owner, RAW_ARRAY& rawArray,
            PACKING_CONTEXT& packingContext, BitStreamReader& in, size_t index)
    {
        ELEMENT_FACTORY::create(owner, rawArray, packingContext, in, index);
    }
 
    template <typename PACKING_CONTEXT>
    static void write(const typename ArrayTraits::OwnerType&, PACKING_CONTEXT& packingContext,
            BitStreamWriter& out, const ElementType& element)
    {
        element.write(packingContext, out);
    }
};
 
} // namespace zserio
 
#endif // ZSERIO_ARRAY_TRAITS_H_INC