1 #ifndef ZSERIO_ARRAY_H_INC
2 #define ZSERIO_ARRAY_H_INC
24 struct DummyArrayExpressions
28 struct DummyArrayOwner
32 template <
typename ARRAY_TRAITS,
typename ARRAY_EXPRESSIONS,
typename =
void>
33 struct array_owner_type
35 using type = DummyArrayOwner;
38 template <
typename ARRAY_TRAITS,
typename ARRAY_EXPRESSIONS>
39 struct array_owner_type<ARRAY_TRAITS, ARRAY_EXPRESSIONS,
40 typename std::enable_if<has_owner_type<ARRAY_TRAITS>::value>::type>
42 using type =
typename ARRAY_TRAITS::OwnerType;
45 template <
typename ARRAY_TRAITS,
typename ARRAY_EXPRESSIONS>
46 struct array_owner_type<ARRAY_TRAITS, ARRAY_EXPRESSIONS,
47 typename std::enable_if<!has_owner_type<ARRAY_TRAITS>::value &&
48 has_owner_type<ARRAY_EXPRESSIONS>::value>::type>
50 using type =
typename ARRAY_EXPRESSIONS::OwnerType;
54 template <
typename T,
typename =
void>
55 struct packing_context_type
57 using type = DeltaContext;
61 struct packing_context_type<T, typename std::enable_if<has_zserio_packing_context<T>::value>::type>
63 using type =
typename T::ZserioPackingContext;
67 template <
typename ARRAY_EXPRESSIONS,
typename OWNER_TYPE,
68 typename std::enable_if<has_initialize_offset<ARRAY_EXPRESSIONS>::value,
int>::type = 0>
69 void initializeOffset(OWNER_TYPE& owner,
size_t index,
size_t bitPosition)
71 ARRAY_EXPRESSIONS::initializeOffset(owner, index, bitPosition);
74 template <
typename ARRAY_EXPRESSIONS,
typename OWNER_TYPE,
75 typename std::enable_if<!has_initialize_offset<ARRAY_EXPRESSIONS>::value,
int>::type = 0>
76 void initializeOffset(OWNER_TYPE&,
size_t,
size_t)
80 template <
typename ARRAY_EXPRESSIONS,
typename OWNER_TYPE,
81 typename std::enable_if<has_check_offset<ARRAY_EXPRESSIONS>::value,
int>::type = 0>
82 void checkOffset(
const OWNER_TYPE& owner,
size_t index,
size_t bitPosition)
84 ARRAY_EXPRESSIONS::checkOffset(owner, index, bitPosition);
87 template <
typename ARRAY_EXPRESSIONS,
typename OWNER_TYPE,
88 typename std::enable_if<!has_check_offset<ARRAY_EXPRESSIONS>::value,
int>::type = 0>
89 void checkOffset(
const OWNER_TYPE&,
size_t,
size_t)
93 template <
typename PACKED_ARRAY_TRAITS,
typename OWNER_TYPE,
typename PACKING_CONTEXT,
94 typename std::enable_if<has_owner_type<PACKED_ARRAY_TRAITS>::value,
int>::type = 0>
95 void packedArrayTraitsInitContext(
96 const OWNER_TYPE& owner, PACKING_CONTEXT& context,
typename PACKED_ARRAY_TRAITS::ElementType element)
98 PACKED_ARRAY_TRAITS::initContext(owner, context, element);
101 template <
typename PACKED_ARRAY_TRAITS,
typename OWNER_TYPE,
typename PACKING_CONTEXT,
102 typename std::enable_if<!has_owner_type<PACKED_ARRAY_TRAITS>::value,
int>::type = 0>
103 void packedArrayTraitsInitContext(
104 const OWNER_TYPE&, PACKING_CONTEXT& context,
typename PACKED_ARRAY_TRAITS::ElementType element)
106 PACKED_ARRAY_TRAITS::initContext(context, element);
110 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
111 typename std::enable_if<ARRAY_TRAITS::IS_BITSIZEOF_CONSTANT && has_owner_type<ARRAY_TRAITS>::value,
113 size_t arrayTraitsConstBitSizeOf(
const OWNER_TYPE& owner)
118 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
119 typename std::enable_if<ARRAY_TRAITS::IS_BITSIZEOF_CONSTANT && !has_owner_type<ARRAY_TRAITS>::value,
121 size_t arrayTraitsConstBitSizeOf(
const OWNER_TYPE&)
127 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
128 typename std::enable_if<has_owner_type<ARRAY_TRAITS>::value,
int>::type = 0>
129 size_t arrayTraitsBitSizeOf(
130 const OWNER_TYPE& owner,
size_t bitPosition,
const typename ARRAY_TRAITS::ElementType& element)
135 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
136 typename std::enable_if<!has_owner_type<ARRAY_TRAITS>::value,
int>::type = 0>
137 size_t arrayTraitsBitSizeOf(
138 const OWNER_TYPE&,
size_t bitPosition,
const typename ARRAY_TRAITS::ElementType& element)
144 template <
typename PACKED_ARRAY_TRAITS,
typename OWNER_TYPE,
typename PACKING_CONTEXT,
145 typename std::enable_if<has_owner_type<PACKED_ARRAY_TRAITS>::value,
int>::type = 0>
146 size_t packedArrayTraitsBitSizeOf(
const OWNER_TYPE& owner, PACKING_CONTEXT& context,
size_t bitPosition,
147 const typename PACKED_ARRAY_TRAITS::ElementType& element)
152 template <
typename PACKED_ARRAY_TRAITS,
typename OWNER_TYPE,
typename PACKING_CONTEXT,
153 typename std::enable_if<!has_owner_type<PACKED_ARRAY_TRAITS>::value,
int>::type = 0>
154 size_t packedArrayTraitsBitSizeOf(
const OWNER_TYPE&, PACKING_CONTEXT& context,
size_t bitPosition,
155 const typename PACKED_ARRAY_TRAITS::ElementType& element)
161 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
162 typename std::enable_if<has_owner_type<ARRAY_TRAITS>::value,
int>::type = 0>
163 size_t arrayTraitsInitializeOffsets(
164 OWNER_TYPE& owner,
size_t bitPosition,
typename ARRAY_TRAITS::ElementType& element)
169 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
170 typename std::enable_if<!has_owner_type<ARRAY_TRAITS>::value &&
171 !std::is_scalar<typename ARRAY_TRAITS::ElementType>::value,
173 size_t arrayTraitsInitializeOffsets(
174 OWNER_TYPE&,
size_t bitPosition,
const typename ARRAY_TRAITS::ElementType& element)
179 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
180 typename std::enable_if<!has_owner_type<ARRAY_TRAITS>::value &&
181 std::is_scalar<typename ARRAY_TRAITS::ElementType>::value,
183 size_t arrayTraitsInitializeOffsets(OWNER_TYPE&,
size_t bitPosition,
typename ARRAY_TRAITS::ElementType element)
189 template <
typename PACKED_ARRAY_TRAITS,
typename OWNER_TYPE,
typename PACKING_CONTEXT,
190 typename std::enable_if<has_owner_type<PACKED_ARRAY_TRAITS>::value,
int>::type = 0>
191 size_t packedArrayTraitsInitializeOffsets(OWNER_TYPE& owner, PACKING_CONTEXT& context,
size_t bitPosition,
192 typename PACKED_ARRAY_TRAITS::ElementType& element)
197 template <
typename PACKED_ARRAY_TRAITS,
typename OWNER_TYPE,
typename PACKING_CONTEXT,
198 typename std::enable_if<!has_owner_type<PACKED_ARRAY_TRAITS>::value &&
199 !std::is_scalar<typename PACKED_ARRAY_TRAITS::ElementType>::value,
201 size_t packedArrayTraitsInitializeOffsets(OWNER_TYPE&, PACKING_CONTEXT& context,
size_t bitPosition,
202 const typename PACKED_ARRAY_TRAITS::ElementType& element)
207 template <
typename PACKED_ARRAY_TRAITS,
typename OWNER_TYPE,
typename PACKING_CONTEXT,
208 typename std::enable_if<!has_owner_type<PACKED_ARRAY_TRAITS>::value &&
209 std::is_scalar<typename PACKED_ARRAY_TRAITS::ElementType>::value,
211 size_t packedArrayTraitsInitializeOffsets(OWNER_TYPE&, PACKING_CONTEXT& context,
size_t bitPosition,
212 typename PACKED_ARRAY_TRAITS::ElementType element)
218 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
typename RAW_ARRAY,
219 typename std::enable_if<has_owner_type<ARRAY_TRAITS>::value && !has_allocator<ARRAY_TRAITS>::value,
221 void arrayTraitsRead(
const OWNER_TYPE& owner, RAW_ARRAY& rawArray, BitStreamReader& in,
size_t index)
226 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
typename RAW_ARRAY,
227 typename std::enable_if<has_owner_type<ARRAY_TRAITS>::value && has_allocator<ARRAY_TRAITS>::value,
229 void arrayTraitsRead(OWNER_TYPE& owner, RAW_ARRAY& rawArray, BitStreamReader& in,
size_t index)
234 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
typename RAW_ARRAY,
235 typename std::enable_if<!has_owner_type<ARRAY_TRAITS>::value && !has_allocator<ARRAY_TRAITS>::value,
237 void arrayTraitsRead(
const OWNER_TYPE&, RAW_ARRAY& rawArray, BitStreamReader& in,
size_t index)
242 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
typename RAW_ARRAY,
243 typename std::enable_if<!has_owner_type<ARRAY_TRAITS>::value && has_allocator<ARRAY_TRAITS>::value,
245 void arrayTraitsRead(
const OWNER_TYPE&, RAW_ARRAY& rawArray, BitStreamReader& in,
size_t index)
251 template <
typename PACKED_ARRAY_TRAITS,
typename OWNER_TYPE,
typename RAW_ARRAY,
typename PACKING_CONTEXT,
252 typename std::enable_if<has_owner_type<PACKED_ARRAY_TRAITS>::value &&
253 has_allocator<PACKED_ARRAY_TRAITS>::value,
255 void packedArrayTraitsRead(
256 OWNER_TYPE& owner, RAW_ARRAY& rawArray, PACKING_CONTEXT& context, BitStreamReader& in,
size_t index)
261 template <
typename PACKED_ARRAY_TRAITS,
typename OWNER_TYPE,
typename RAW_ARRAY,
typename PACKING_CONTEXT,
262 typename std::enable_if<has_owner_type<PACKED_ARRAY_TRAITS>::value &&
263 !has_allocator<PACKED_ARRAY_TRAITS>::value,
265 void packedArrayTraitsRead(
const OWNER_TYPE& owner, RAW_ARRAY& rawArray, PACKING_CONTEXT& context,
266 BitStreamReader& in,
size_t index)
274 template <
typename PACKED_ARRAY_TRAITS,
typename OWNER_TYPE,
typename RAW_ARRAY,
typename PACKING_CONTEXT,
275 typename std::enable_if<!has_owner_type<PACKED_ARRAY_TRAITS>::value &&
276 !has_allocator<PACKED_ARRAY_TRAITS>::value,
278 void packedArrayTraitsRead(
279 const OWNER_TYPE&, RAW_ARRAY& rawArray, PACKING_CONTEXT& context, BitStreamReader& in,
size_t index)
285 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
286 typename std::enable_if<has_owner_type<ARRAY_TRAITS>::value,
int>::type = 0>
287 void arrayTraitsWrite(
288 const OWNER_TYPE& owner, BitStreamWriter& out,
const typename ARRAY_TRAITS::ElementType& element)
293 template <
typename ARRAY_TRAITS,
typename OWNER_TYPE,
294 typename std::enable_if<!has_owner_type<ARRAY_TRAITS>::value,
int>::type = 0>
295 void arrayTraitsWrite(
296 const OWNER_TYPE&, BitStreamWriter& out,
const typename ARRAY_TRAITS::ElementType& element)
302 template <
typename PACKED_ARRAY_TRAITS,
typename OWNER_TYPE,
typename PACKING_CONTEXT,
303 typename std::enable_if<has_owner_type<PACKED_ARRAY_TRAITS>::value,
int>::type = 0>
304 void packedArrayTraitsWrite(
const OWNER_TYPE& owner, PACKING_CONTEXT& context, BitStreamWriter& out,
305 const typename PACKED_ARRAY_TRAITS::ElementType& element)
310 template <
typename PACKED_ARRAY_TRAITS,
typename OWNER_TYPE,
typename PACKING_CONTEXT,
311 typename std::enable_if<!has_owner_type<PACKED_ARRAY_TRAITS>::value,
int>::type = 0>
312 void packedArrayTraitsWrite(
const OWNER_TYPE&, PACKING_CONTEXT& context, BitStreamWriter& out,
313 const typename PACKED_ARRAY_TRAITS::ElementType& element)
339 template <
typename RAW_ARRAY,
typename ARRAY_TRAITS,
ArrayType ARRAY_TYPE,
340 typename ARRAY_EXPRESSIONS = detail::DummyArrayExpressions>
359 using OwnerType =
typename detail::array_owner_type<ArrayTraits, ArrayExpressions>::type;
370 m_rawArray(allocator)
388 m_rawArray(std::move(rawArray))
412 template <
typename T =
typename RAW_ARRAY::value_type,
413 typename std::enable_if<std::is_constructible<T, NoInitT, T>::value,
int>::type = 0>
416 other.m_rawArray.get_allocator()))
418 m_rawArray.reserve(other.m_rawArray.size());
419 for (
const auto& value : other.m_rawArray)
421 m_rawArray.emplace_back(
NoInit, value);
432 template <
typename T =
typename RAW_ARRAY::value_type,
433 typename std::enable_if<std::is_constructible<T, NoInitT, T>::value,
int>::type = 0>
436 const RawArray rawArray(other.m_rawArray.get_allocator());
437 m_rawArray = rawArray;
438 m_rawArray.reserve(other.m_rawArray.size());
439 for (
const auto& value : other.m_rawArray)
441 m_rawArray.emplace_back(
NoInit, value);
454 template <
typename T =
typename RAW_ARRAY::value_type,
455 typename std::enable_if<std::is_constructible<T, NoInitT, T>::value,
int>::type = 0>
457 Array(std::move(other))
468 template <
typename T =
typename RAW_ARRAY::value_type,
469 typename std::enable_if<std::is_constructible<T, NoInitT, T>::value,
int>::type = 0>
492 template <
typename T =
typename RAW_ARRAY::value_type,
493 typename std::enable_if<std::is_constructible<T, NoInitT, T>::value,
int>::type = 0>
507 return m_rawArray == other.m_rawArray;
519 return m_rawArray < other.m_rawArray;
558 typename std::enable_if<has_initialize_element<ARRAY_EXPRESSIONS_>::value,
int>::type = 0>
562 for (
auto&& element : m_rawArray)
564 ArrayExpressions::initializeElement(owner, element, index);
578 template <
typename OWNER_TYPE_ =
OwnerType,
579 typename std::enable_if<std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
582 return bitSizeOfImpl(detail::DummyArrayOwner(), bitPosition);
595 template <
typename OWNER_TYPE_ =
OwnerType,
596 typename std::enable_if<!std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
599 return bitSizeOfImpl(owner, bitPosition);
611 template <
typename OWNER_TYPE_ =
OwnerType,
612 typename std::enable_if<std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
615 detail::DummyArrayOwner owner;
616 return initializeOffsetsImpl(owner, bitPosition);
629 template <
typename OWNER_TYPE_ =
OwnerType,
630 typename std::enable_if<!std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
633 return initializeOffsetsImpl(owner, bitPosition);
644 template <
typename OWNER_TYPE_ =
OwnerType,
645 typename std::enable_if<std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
648 detail::DummyArrayOwner owner;
649 readImpl(owner, in, arrayLength);
661 template <
typename OWNER_TYPE_ =
OwnerType,
662 typename std::enable_if<!std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
665 readImpl(owner, in, arrayLength);
675 template <
typename OWNER_TYPE_ =
OwnerType,
676 typename std::enable_if<std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
679 writeImpl(detail::DummyArrayOwner(), out);
690 template <
typename OWNER_TYPE_ =
OwnerType,
691 typename std::enable_if<!std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
694 writeImpl(owner, out);
706 template <
typename OWNER_TYPE_ =
OwnerType,
707 typename std::enable_if<std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
710 return bitSizeOfPackedImpl(detail::DummyArrayOwner(), bitPosition);
723 template <
typename OWNER_TYPE_ =
OwnerType,
724 typename std::enable_if<!std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
727 return bitSizeOfPackedImpl(ownerType, bitPosition);
739 template <
typename OWNER_TYPE_ =
OwnerType,
740 typename std::enable_if<std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
743 detail::DummyArrayOwner owner;
744 return initializeOffsetsPackedImpl(owner, bitPosition);
757 template <
typename OWNER_TYPE_ =
OwnerType,
758 typename std::enable_if<!std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
761 return initializeOffsetsPackedImpl(owner, bitPosition);
772 template <
typename OWNER_TYPE_ =
OwnerType,
773 typename std::enable_if<std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
776 detail::DummyArrayOwner owner;
777 readPackedImpl(owner, in, arrayLength);
789 template <
typename OWNER_TYPE_ =
OwnerType,
790 typename std::enable_if<!std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
793 readPackedImpl(owner, in, arrayLength);
803 template <
typename OWNER_TYPE_ =
OwnerType,
804 typename std::enable_if<std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
807 writePackedImpl(detail::DummyArrayOwner(), out);
818 template <
typename OWNER_TYPE_ =
OwnerType,
819 typename std::enable_if<!std::is_same<OWNER_TYPE_, detail::DummyArrayOwner>::value,
int>::type = 0>
822 writePackedImpl(owner, out);
826 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
829 static void addBitSizeOfArrayLength(
size_t&,
size_t)
832 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
835 static void addBitSizeOfArrayLength(
size_t& bitPosition,
size_t arrayLength)
840 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
843 static void alignBitPosition(
size_t&)
846 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
849 static void alignBitPosition(
size_t& bitPosition)
851 bitPosition =
alignTo(8, bitPosition);
854 template <
typename IO,
typename OWNER_TYPE,
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
857 static void alignAndCheckOffset(IO&, OWNER_TYPE&,
size_t)
860 template <
typename IO,
typename OWNER_TYPE,
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
863 static void alignAndCheckOffset(IO& io, OWNER_TYPE& owner,
size_t index)
866 detail::checkOffset<ArrayExpressions>(owner, index, io.getBitPosition() / 8);
869 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
872 static void initializeOffset(
OwnerType&,
size_t,
size_t&)
875 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
878 static void initializeOffset(
OwnerType& owner,
size_t index,
size_t& bitPosition)
880 bitPosition =
alignTo(8, bitPosition);
881 detail::initializeOffset<ArrayExpressions>(owner, index, bitPosition / 8);
884 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
888 static size_t readArrayLength(
OwnerType&, BitStreamReader&,
size_t arrayLength)
893 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
896 static size_t readArrayLength(
OwnerType&, BitStreamReader& in,
size_t)
898 return in.readVarSize();
901 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
902 typename std::enable_if<ARRAY_TYPE_ == ArrayType::IMPLICIT, int>::type = 0>
903 static size_t readArrayLength(
OwnerType& owner, BitStreamReader& in,
size_t)
906 "Implicit array elements must have constant bit size!");
908 const size_t remainingBits = in.getBufferBitSize() - in.getBitPosition();
909 return remainingBits / detail::arrayTraitsConstBitSizeOf<ArrayTraits>(owner);
912 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
915 static void writeArrayLength(BitStreamWriter&,
size_t)
918 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
921 static void writeArrayLength(BitStreamWriter& out,
size_t arrayLength)
926 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
929 static size_t constBitSizeOfElements(
size_t,
size_t arrayLength,
size_t elementBitSize)
931 return arrayLength * elementBitSize;
934 template <
ArrayType ARRAY_TYPE_ = ARRAY_TYPE,
937 static size_t constBitSizeOfElements(
size_t bitPosition,
size_t arrayLength,
size_t elementBitSize)
939 size_t endBitPosition =
alignTo(8, bitPosition);
940 endBitPosition += elementBitSize + (arrayLength - 1) *
alignTo(8, elementBitSize);
942 return endBitPosition - bitPosition;
946 typename std::enable_if<ARRAY_TRAITS_::IS_BITSIZEOF_CONSTANT, int>::type = 0>
947 size_t bitSizeOfImpl(
const OwnerType& owner,
size_t bitPosition)
const
949 size_t endBitPosition = bitPosition;
951 const size_t arrayLength = m_rawArray.size();
952 addBitSizeOfArrayLength(endBitPosition, arrayLength);
956 const size_t elementBitSize = detail::arrayTraitsConstBitSizeOf<ArrayTraits>(owner);
957 endBitPosition += constBitSizeOfElements(endBitPosition, arrayLength, elementBitSize);
960 return endBitPosition - bitPosition;
964 typename std::enable_if<!ARRAY_TRAITS_::IS_BITSIZEOF_CONSTANT, int>::type = 0>
965 size_t bitSizeOfImpl(
const OwnerType& owner,
size_t bitPosition)
const
967 size_t endBitPosition = bitPosition;
969 const size_t arrayLength = m_rawArray.size();
970 addBitSizeOfArrayLength(endBitPosition, arrayLength);
972 for (
size_t index = 0; index < arrayLength; ++index)
974 alignBitPosition(endBitPosition);
976 detail::arrayTraitsBitSizeOf<ArrayTraits>(owner, endBitPosition, m_rawArray[index]);
979 return endBitPosition - bitPosition;
982 size_t initializeOffsetsImpl(
OwnerType& owner,
size_t bitPosition)
984 size_t endBitPosition = bitPosition;
986 const size_t arrayLength = m_rawArray.size();
987 addBitSizeOfArrayLength(endBitPosition, arrayLength);
989 for (
size_t index = 0; index < arrayLength; ++index)
991 initializeOffset(owner, index, endBitPosition);
993 detail::arrayTraitsInitializeOffsets<ArrayTraits>(owner, endBitPosition, m_rawArray[index]);
996 return endBitPosition;
999 void readImpl(
OwnerType& owner, BitStreamReader& in,
size_t arrayLength)
1001 size_t readLength = readArrayLength(owner, in, arrayLength);
1004 m_rawArray.reserve(readLength);
1005 for (
size_t index = 0; index < readLength; ++index)
1007 alignAndCheckOffset(in, owner, index);
1008 detail::arrayTraitsRead<ArrayTraits>(owner, m_rawArray, in, index);
1012 void writeImpl(
const OwnerType& owner, BitStreamWriter& out)
const
1014 const size_t arrayLength = m_rawArray.size();
1015 writeArrayLength(out, arrayLength);
1017 for (
size_t index = 0; index < arrayLength; ++index)
1019 alignAndCheckOffset(out, owner, index);
1020 detail::arrayTraitsWrite<ArrayTraits>(owner, out, m_rawArray[index]);
1024 using PackingContext =
typename detail::packing_context_type<typename RawArray::value_type>::type;
1026 size_t bitSizeOfPackedImpl(
const OwnerType& owner,
size_t bitPosition)
const
1030 size_t endBitPosition = bitPosition;
1032 const size_t arrayLength = m_rawArray.size();
1033 addBitSizeOfArrayLength(endBitPosition, arrayLength);
1035 if (arrayLength > 0)
1037 PackingContext context;
1039 for (
size_t index = 0; index < arrayLength; ++index)
1041 detail::packedArrayTraitsInitContext<PackedArrayTraits<ArrayTraits>>(
1042 owner, context, m_rawArray[index]);
1045 for (
size_t index = 0; index < arrayLength; ++index)
1047 alignBitPosition(endBitPosition);
1048 endBitPosition += detail::packedArrayTraitsBitSizeOf<PackedArrayTraits<ArrayTraits>>(
1049 owner, context, endBitPosition, m_rawArray[index]);
1053 return endBitPosition - bitPosition;
1056 size_t initializeOffsetsPackedImpl(
OwnerType& owner,
size_t bitPosition)
1060 size_t endBitPosition = bitPosition;
1062 const size_t arrayLength = m_rawArray.size();
1063 addBitSizeOfArrayLength(endBitPosition, arrayLength);
1065 if (arrayLength > 0)
1067 PackingContext context;
1069 for (
size_t index = 0; index < arrayLength; ++index)
1071 detail::packedArrayTraitsInitContext<PackedArrayTraits<ArrayTraits>>(
1072 owner, context, m_rawArray[index]);
1075 for (
size_t index = 0; index < arrayLength; ++index)
1077 initializeOffset(owner, index, endBitPosition);
1078 endBitPosition = detail::packedArrayTraitsInitializeOffsets<PackedArrayTraits<ArrayTraits>>(
1079 owner, context, endBitPosition, m_rawArray[index]);
1083 return endBitPosition;
1086 void readPackedImpl(
OwnerType& owner, BitStreamReader& in,
size_t arrayLength = 0)
1090 size_t readLength = readArrayLength(owner, in, arrayLength);
1096 m_rawArray.reserve(readLength);
1098 PackingContext context;
1100 for (
size_t index = 0; index < readLength; ++index)
1102 alignAndCheckOffset(in, owner, index);
1103 detail::packedArrayTraitsRead<PackedArrayTraits<ArrayTraits>>(
1104 owner, m_rawArray, context, in, index);
1109 void writePackedImpl(
const OwnerType& owner, BitStreamWriter& out)
const
1113 const size_t arrayLength = m_rawArray.size();
1114 writeArrayLength(out, arrayLength);
1116 if (arrayLength > 0)
1118 PackingContext context;
1120 for (
size_t index = 0; index < arrayLength; ++index)
1122 detail::packedArrayTraitsInitContext<PackedArrayTraits<ArrayTraits>>(
1123 owner, context, m_rawArray[index]);
1126 for (
size_t index = 0; index < arrayLength; ++index)
1128 alignAndCheckOffset(out, owner, index);
1129 detail::packedArrayTraitsWrite<PackedArrayTraits<ArrayTraits>>(
1130 owner, context, out, m_rawArray[index]);
1142 template <
typename ARRAY,
typename RAW_ARRAY>
1145 return ARRAY(std::forward<RAW_ARRAY>(rawArray));
1151 template <
typename ARRAY>
size_t bitSizeOf(const OwnerType &owner, size_t bitPosition) const
Array(NoInitT, const Array &other)
bool operator==(const Array &other) const
void readPacked(BitStreamReader &in, size_t arrayLength=0)
Array & operator=(Array &&other)=default
size_t initializeOffsetsPacked(OwnerType &owner, size_t bitPosition)
Array & assign(NoInitT, const Array &other)
void write(BitStreamWriter &out) const
void read(OwnerType &owner, BitStreamReader &in, size_t arrayLength=0)
Array & operator=(const Array &other)=default
size_t bitSizeOfPacked(size_t bitPosition) const
size_t initializeOffsets(OwnerType &owner, size_t bitPosition)
void readPacked(OwnerType &owner, BitStreamReader &in, size_t arrayLength=0)
void read(BitStreamReader &in, size_t arrayLength=0)
typename detail::array_owner_type< ArrayTraits, ArrayExpressions >::type OwnerType
size_t initializeOffsets(size_t bitPosition)
void writePacked(BitStreamWriter &out) const
uint32_t hashCode() const
Array(RawArray &&rawArray)
bool operator<(const Array &other) const
Array(PropagateAllocatorT, const Array &other, const allocator_type &allocator)
ARRAY_EXPRESSIONS ArrayExpressions
typename RawArray::allocator_type allocator_type
size_t bitSizeOf(size_t bitPosition) const
Array(Array &&other)=default
Array(PropagateAllocatorT, NoInitT, const Array &other, const allocator_type &allocator)
void initializeElements(OwnerType &owner)
const RawArray & getRawArray() const
Array & assign(NoInitT, Array &&other)
void write(const OwnerType &owner, BitStreamWriter &out) const
Array(NoInitT, Array &&other)
size_t initializeOffsetsPacked(size_t bitPosition)
Array(const RawArray &rawArray)
size_t bitSizeOfPacked(const OwnerType &ownerType, size_t bitPosition) const
Array(const allocator_type &allocator=allocator_type())
Array(const Array &other)=default
void writePacked(const OwnerType &owner, BitStreamWriter &out) const
T read(BitStreamReader &in)
void write(BitStreamWriter &out, T value)
ARRAY createOptionalArray(RAW_ARRAY &&rawArray)
T allocatorPropagatingCopy(const T &source, const ALLOC &allocator)
size_t alignTo(size_t alignmentValue, size_t bitPosition)
constexpr NullOptType NullOpt
size_t initializeOffsets(size_t bitPosition, T value)
size_t bitSizeOfVarSize(uint32_t value)
std::enable_if< std::is_integral< T >::value &&(sizeof(T)<=4), uint32_t >::type calcHashCode(uint32_t seedValue, T value)
uint32_t convertSizeToUInt32(size_t value)
size_t bitSizeOf(T value)