1 #ifndef ZSERIO_REFLECTABLE_H_INC
2 #define ZSERIO_REFLECTABLE_H_INC
26 template <
typename ALLOC>
60 size_t bitSizeOf(
size_t bitPosition)
const override;
80 size_t size()
const override;
96 int8_t
getInt8()
const override;
111 int64_t
toInt()
const override;
112 uint64_t
toUInt()
const override;
124 template <
typename ALLOC,
typename T,
typename =
void>
162 template <
typename ALLOC,
typename T>
164 typename std::enable_if<std::is_arithmetic<T>::value || std::is_same<T, StringView>::value ||
204 template <
typename ALLOC,
typename T>
208 static_assert(std::is_integral<T>::value,
"T must be a signed integral type!");
214 Base(typeInfo, value)
233 template <
typename ALLOC,
typename T>
237 static_assert(std::is_signed<T>::value,
"T must be a signed integral type!");
255 template <
typename ALLOC,
typename T>
259 static_assert(std::is_unsigned<T>::value,
"T must be an unsigned integral type!");
275 template <
typename ALLOC>
312 template <
typename ALLOC>
332 template <
typename ALLOC>
352 template <
typename ALLOC>
372 template <
typename ALLOC>
392 template <
typename ALLOC>
412 template <
typename ALLOC>
432 template <
typename ALLOC>
452 template <
typename ALLOC>
470 template <
typename ALLOC>
500 template <
typename ALLOC>
530 template <
typename ALLOC>
560 template <
typename ALLOC>
590 template <
typename ALLOC>
620 template <
typename ALLOC>
650 template <
typename ALLOC>
680 template <
typename ALLOC>
707 template <
typename ALLOC,
typename T>
710 template <
typename ALLOC>
723 Base(typeInfo(bitSize), value)
728 <<
" - invalid bit size '" << bitSize <<
"' for 'int8_t' value!";
734 return Base::getTypeInfo().getBitSize();
739 writer.
writeSignedBits(Base::getValue(), Base::getTypeInfo().getBitSize());
743 template <
typename ALLOC>
756 Base(typeInfo(bitSize), value)
758 if (bitSize <= 8 || bitSize > 16)
761 <<
" - invalid bit size '" << bitSize <<
"' for 'int16_t' value!";
767 return Base::getTypeInfo().getBitSize();
772 writer.
writeSignedBits(Base::getValue(), Base::getTypeInfo().getBitSize());
776 template <
typename ALLOC>
789 Base(typeInfo(bitSize), value)
791 if (bitSize <= 16 || bitSize > 32)
794 <<
" - invalid bit size '" << bitSize <<
"' for 'int32_t' value!";
800 return Base::getTypeInfo().getBitSize();
805 writer.
writeSignedBits(Base::getValue(), Base::getTypeInfo().getBitSize());
809 template <
typename ALLOC>
822 Base(typeInfo(bitSize), value)
827 <<
" - invalid bit size '" << bitSize <<
"' for 'int64_t' value!";
833 return Base::getTypeInfo().getBitSize();
842 template <
typename ALLOC,
typename T>
845 template <
typename ALLOC>
858 Base(typeInfo(bitSize), value)
863 <<
" - invalid bit size '" << bitSize <<
"' for 'uint8_t' value!";
869 return Base::getTypeInfo().getBitSize();
874 writer.
writeBits(Base::getValue(), Base::getTypeInfo().getBitSize());
878 template <
typename ALLOC>
891 Base(typeInfo(bitSize), value)
893 if (bitSize <= 8 || bitSize > 16)
896 <<
" - invalid bit size '" << bitSize <<
"' for 'uint16_t' value!";
902 return Base::getTypeInfo().getBitSize();
907 writer.
writeBits(Base::getValue(), Base::getTypeInfo().getBitSize());
911 template <
typename ALLOC>
924 Base(typeInfo(bitSize), value)
926 if (bitSize <= 16 || bitSize > 32)
929 <<
" - invalid bit size '" << bitSize <<
"' for 'uint32_t' value!";
935 return Base::getTypeInfo().getBitSize();
940 writer.
writeBits(Base::getValue(), Base::getTypeInfo().getBitSize());
944 template <
typename ALLOC>
957 Base(typeInfo(bitSize), value)
962 <<
" - invalid bit size '" << bitSize <<
"' for 'uint64_t' value!";
968 return Base::getTypeInfo().getBitSize();
973 writer.
writeBits64(Base::getValue(), Base::getTypeInfo().getBitSize());
977 template <
typename ALLOC,
typename T>
980 template <
typename ALLOC>
993 Base(typeInfo(maxBitSize), value),
994 m_dynamicBitSize(dynamicBitSize)
999 <<
" - invalid max bit size '" << maxBitSize <<
"' for 'int8_t' value!";
1002 if (dynamicBitSize > maxBitSize)
1005 << dynamicBitSize <<
"' is greater than max bit size '" << maxBitSize <<
"'!";
1011 return m_dynamicBitSize;
1020 uint8_t m_dynamicBitSize;
1023 template <
typename ALLOC>
1036 Base(typeInfo(maxBitSize), value),
1037 m_dynamicBitSize(dynamicBitSize)
1039 if (maxBitSize <= 8 || maxBitSize > 16)
1042 <<
" - invalid max bit size '" << maxBitSize <<
"' for 'int16_t' value!";
1045 if (dynamicBitSize > maxBitSize)
1048 << dynamicBitSize <<
"' is greater than max bit size '" << maxBitSize <<
"'!";
1054 return m_dynamicBitSize;
1063 uint8_t m_dynamicBitSize;
1066 template <
typename ALLOC>
1079 Base(typeInfo(maxBitSize), value),
1080 m_dynamicBitSize(dynamicBitSize)
1082 if (maxBitSize <= 16 || maxBitSize > 32)
1085 <<
" - invalid max bit size '" << maxBitSize <<
"' for 'int32_t' value!";
1088 if (dynamicBitSize > maxBitSize)
1091 << dynamicBitSize <<
"' is greater than max bit size '" << maxBitSize <<
"'!";
1097 return m_dynamicBitSize;
1106 uint8_t m_dynamicBitSize;
1109 template <
typename ALLOC>
1122 Base(typeInfo(maxBitSize), value),
1123 m_dynamicBitSize(dynamicBitSize)
1125 if (maxBitSize <= 32)
1128 <<
" - invalid max bit size '" << maxBitSize <<
"' for 'int64_t' value!";
1131 if (dynamicBitSize > maxBitSize)
1134 << dynamicBitSize <<
"' is greater than max bit size '" << maxBitSize <<
"'!";
1140 return m_dynamicBitSize;
1149 uint8_t m_dynamicBitSize;
1152 template <
typename ALLOC,
typename T>
1155 template <
typename ALLOC>
1168 Base(typeInfo(maxBitSize), value),
1169 m_dynamicBitSize(dynamicBitSize)
1174 <<
" - invalid max bit size '" << maxBitSize <<
"' for 'uint8_t' value!";
1177 if (dynamicBitSize > maxBitSize)
1180 << dynamicBitSize <<
"' is greater than max bit size '" << maxBitSize <<
"'!";
1186 return m_dynamicBitSize;
1191 writer.
writeBits(Base::getValue(), m_dynamicBitSize);
1195 uint8_t m_dynamicBitSize;
1198 template <
typename ALLOC>
1211 Base(typeInfo(maxBitSize), value),
1212 m_dynamicBitSize(dynamicBitSize)
1214 if (maxBitSize <= 8 || maxBitSize > 16)
1217 <<
" - invalid max bit size '" << maxBitSize <<
"' for 'uint16_t' value!";
1220 if (dynamicBitSize > maxBitSize)
1223 << dynamicBitSize <<
"' is greater than max bit size '" << maxBitSize <<
"'!";
1229 return m_dynamicBitSize;
1234 writer.
writeBits(Base::getValue(), m_dynamicBitSize);
1238 uint8_t m_dynamicBitSize;
1241 template <
typename ALLOC>
1254 Base(typeInfo(maxBitSize), value),
1255 m_dynamicBitSize(dynamicBitSize)
1257 if (maxBitSize <= 16 || maxBitSize > 32)
1260 <<
" - invalid max bit size '" << maxBitSize <<
"' for 'uint32_t' value!";
1263 if (dynamicBitSize > maxBitSize)
1266 << dynamicBitSize <<
"' is greater than max bit size '" << maxBitSize <<
"'!";
1272 return m_dynamicBitSize;
1277 writer.
writeBits(Base::getValue(), m_dynamicBitSize);
1281 uint8_t m_dynamicBitSize;
1284 template <
typename ALLOC>
1297 Base(typeInfo(maxBitSize), value),
1298 m_dynamicBitSize(dynamicBitSize)
1300 if (maxBitSize <= 32)
1303 <<
" - invalid max bit size '" << maxBitSize <<
"' for 'uint64_t' value!";
1306 if (dynamicBitSize > maxBitSize)
1309 << dynamicBitSize <<
"' is greater than max bit size '" << maxBitSize <<
"'!";
1315 return m_dynamicBitSize;
1320 writer.
writeBits64(Base::getValue(), m_dynamicBitSize);
1324 uint8_t m_dynamicBitSize;
1330 template <
typename ALLOC>
1360 template <
typename ALLOC>
1390 template <
typename ALLOC>
1420 template <
typename ALLOC>
1450 template <
typename ALLOC>
1480 template <
typename ALLOC>
1510 template <
typename ALLOC>
1540 template <
typename ALLOC>
1570 template <
typename ALLOC>
1600 template <
typename ALLOC,
typename T>
1604 static_assert(std::is_floating_point<T>::value,
"T must be a floating point type!");
1612 return static_cast<double>(
getValue());
1619 template <
typename ALLOC>
1654 template <
typename ALLOC>
1689 template <
typename ALLOC>
1724 template <
typename ALLOC>
1759 template <
typename ALLOC>
1799 template <
typename ALLOC>
1834 template <
typename ALLOC>
1835 IBasicReflectableConstPtr<ALLOC> getFieldFromObject(
const IBasicReflectable<ALLOC>&
object,
StringView name)
1837 const auto& typeInfo =
object.getTypeInfo();
1840 const auto& fields = typeInfo.getFields();
1841 auto fieldsIt = std::find_if(fields.begin(), fields.end(),
1842 [name](
const BasicFieldInfo<ALLOC>& fieldInfo) { return fieldInfo.schemaName == name; });
1843 if (fieldsIt != fields.end())
1845 return object.getField(name);
1852 template <
typename ALLOC>
1853 IBasicReflectablePtr<ALLOC> getFieldFromObject(IBasicReflectable<ALLOC>&
object,
StringView name)
1855 const auto& typeInfo =
object.getTypeInfo();
1858 const auto& fields = typeInfo.getFields();
1859 auto fieldsIt = std::find_if(fields.begin(), fields.end(),
1860 [name](
const BasicFieldInfo<ALLOC>& fieldInfo) { return fieldInfo.schemaName == name; });
1861 if (fieldsIt != fields.end())
1863 return object.getField(name);
1870 template <
typename ALLOC>
1871 IBasicReflectableConstPtr<ALLOC> getParameterFromObject(
const IBasicReflectable<ALLOC>&
object,
StringView name)
1873 const auto& typeInfo =
object.getTypeInfo();
1876 const auto& parameters = typeInfo.getParameters();
1877 auto parametersIt = std::find_if(
1878 parameters.begin(), parameters.end(), [name](
const BasicParameterInfo<ALLOC>& parameterInfo) {
1879 return parameterInfo.schemaName == name;
1881 if (parametersIt != parameters.end())
1883 return object.getParameter(name);
1890 template <
typename ALLOC>
1891 IBasicReflectablePtr<ALLOC> getParameterFromObject(IBasicReflectable<ALLOC>&
object,
StringView name)
1893 const auto& typeInfo =
object.getTypeInfo();
1896 const auto& parameters = typeInfo.getParameters();
1897 auto parametersIt = std::find_if(
1898 parameters.begin(), parameters.end(), [name](
const BasicParameterInfo<ALLOC>& parameterInfo) {
1899 return parameterInfo.schemaName == name;
1901 if (parametersIt != parameters.end())
1903 return object.getParameter(name);
1910 template <
typename ALLOC>
1911 IBasicReflectableConstPtr<ALLOC> callFunctionInObject(
const IBasicReflectable<ALLOC>&
object,
StringView name)
1913 const auto& typeInfo =
object.getTypeInfo();
1916 const auto& functions = typeInfo.getFunctions();
1917 auto functionsIt = std::find_if(
1918 functions.begin(), functions.end(), [name](
const BasicFunctionInfo<ALLOC>& functionInfo) {
1919 return functionInfo.schemaName == name;
1921 if (functionsIt != functions.end())
1923 return object.callFunction(name);
1930 template <
typename ALLOC>
1931 IBasicReflectablePtr<ALLOC> callFunctionInObject(IBasicReflectable<ALLOC>&
object,
StringView name)
1933 const auto& typeInfo =
object.getTypeInfo();
1936 const auto& functions = typeInfo.getFunctions();
1937 auto functionsIt = std::find_if(
1938 functions.begin(), functions.end(), [name](
const BasicFunctionInfo<ALLOC>& functionInfo) {
1939 return functionInfo.schemaName == name;
1941 if (functionsIt != functions.end())
1943 return object.callFunction(name);
1950 template <
typename ALLOC>
1951 IBasicReflectableConstPtr<ALLOC> getFromObject(
1952 const IBasicReflectable<ALLOC>&
object,
StringView path,
size_t pos)
1956 const size_t dotPos = path.find(
'.', pos);
1960 auto field = getFieldFromObject(
object, name);
1963 return isLast ? std::move(field) : getFromObject(*field, path, dotPos + 1);
1966 auto parameter = getParameterFromObject(
object, name);
1969 return isLast ? std::move(parameter) : getFromObject(*parameter, path, dotPos + 1);
1972 auto functionResult = callFunctionInObject(
object, name);
1975 return isLast ? std::move(functionResult) : getFromObject(*functionResult, path, dotPos + 1);
1978 catch (
const CppRuntimeException&)
1984 template <
typename ALLOC>
1985 IBasicReflectablePtr<ALLOC> getFromObject(IBasicReflectable<ALLOC>&
object,
StringView path,
size_t pos)
1989 const size_t dotPos = path.find(
'.', pos);
1993 auto field = getFieldFromObject(
object, name);
1996 return isLast ? std::move(field) : getFromObject(*field, path, dotPos + 1);
1999 auto parameter = getParameterFromObject(
object, name);
2002 return isLast ? std::move(parameter) : getFromObject(*parameter, path, dotPos + 1);
2005 auto functionResult = callFunctionInObject(
object, name);
2008 return isLast ? std::move(functionResult) : getFromObject(*functionResult, path, dotPos + 1);
2011 catch (
const CppRuntimeException&)
2022 template <
typename ALLOC>
2037 template <
typename ALLOC>
2064 template <
typename ALLOC>
2082 size_t bitSizeOf(
size_t bitPosition)
const override;
2099 bool getBool()
const override;
2100 int8_t
getInt8()
const override;
2114 int64_t
toInt()
const override;
2115 uint64_t
toUInt()
const override;
2125 template <
typename ALLOC>
2135 void resize(
size_t index)
override;
2148 template <
typename ALLOC,
typename RAW_ARRAY,
typename ELEMENT_REFLECTABLE>
2154 using ElementReflectable = ELEMENT_REFLECTABLE;
2159 using Base::operator[];
2163 Base(ElementReflectable::typeInfo(), allocator),
2164 m_rawArray(rawArray)
2169 return m_rawArray.size();
2174 if (index >=
size())
2178 <<
"' of size " <<
size() <<
"!";
2181 return std::allocate_shared<ElementReflectable>(
Base::get_allocator(), m_rawArray[index]);
2190 const RAW_ARRAY& m_rawArray;
2193 template <
typename ALLOC,
typename RAW_ARRAY,
typename ELEMENT_REFLECTABLE>
2199 using ElementReflectable = ELEMENT_REFLECTABLE;
2205 Base(ElementReflectable::typeInfo(), allocator),
2206 m_rawArray(rawArray)
2211 return m_rawArray.size();
2216 m_rawArray.resize(
size);
2221 if (index >=
size())
2225 <<
"' of size " <<
size() <<
"!";
2228 return std::allocate_shared<ElementReflectable>(
Base::get_allocator(), m_rawArray[index]);
2233 if (index >=
size())
2237 <<
"' of size " <<
size() <<
"!";
2240 return std::allocate_shared<ElementReflectable>(
Base::get_allocator(), m_rawArray[index]);
2245 if (index >=
size())
2249 <<
"' of size " <<
size() <<
"!";
2252 m_rawArray[index] = value.template get<typename RAW_ARRAY::value_type>();
2257 m_rawArray.push_back(value.template get<typename RAW_ARRAY::value_type>());
2271 RAW_ARRAY& m_rawArray;
2279 template <
typename ALLOC,
typename RAW_ARRAY,
typename ELEMENT_REFLECTABLE>
2285 using ElementReflectable = ELEMENT_REFLECTABLE;
2290 using Base::operator[];
2294 Base(ElementReflectable::typeInfo(bitSize), allocator),
2295 m_rawArray(rawArray)
2300 return m_rawArray.size();
2305 if (index >=
size())
2309 <<
"' of size " <<
size() <<
"!";
2312 return std::allocate_shared<ElementReflectable>(
2322 const RAW_ARRAY& m_rawArray;
2325 template <
typename ALLOC,
typename RAW_ARRAY,
typename ELEMENT_REFLECTABLE>
2331 using ElementReflectable = ELEMENT_REFLECTABLE;
2337 Base(ElementReflectable::typeInfo(bitSize), allocator),
2338 m_rawArray(rawArray)
2343 return m_rawArray.size();
2348 m_rawArray.resize(
size);
2353 if (index >=
size())
2357 <<
"' of size " <<
size() <<
"!";
2360 return std::allocate_shared<ElementReflectable>(
2366 if (index >=
size())
2370 <<
"' of size " <<
size() <<
"!";
2373 return std::allocate_shared<ElementReflectable>(
2379 if (index >=
size())
2383 <<
"' of size " <<
size() <<
"!";
2386 m_rawArray[index] = value.template get<typename RAW_ARRAY::value_type>();
2391 m_rawArray.push_back(value.template get<typename RAW_ARRAY::value_type>());
2405 RAW_ARRAY& m_rawArray;
2413 template <
typename ALLOC,
typename RAW_ARRAY,
typename ELEMENT_REFLECTABLE>
2419 using ElementReflectable = ELEMENT_REFLECTABLE;
2424 using Base::operator[];
2428 const ALLOC& allocator,
const RAW_ARRAY& rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize) :
2429 Base(ElementReflectable::typeInfo(maxBitSize), allocator),
2430 m_rawArray(rawArray),
2431 m_maxBitSize(maxBitSize),
2432 m_dynamicBitSize(dynamicBitSize)
2437 return m_rawArray.size();
2442 if (index >=
size())
2446 <<
"' of size " <<
size() <<
"!";
2449 return std::allocate_shared<ElementReflectable>(
2459 const RAW_ARRAY& m_rawArray;
2460 const uint8_t m_maxBitSize;
2461 const uint8_t m_dynamicBitSize;
2464 template <
typename ALLOC,
typename RAW_ARRAY,
typename ELEMENT_REFLECTABLE>
2470 using ElementReflectable = ELEMENT_REFLECTABLE;
2476 const ALLOC& allocator, RAW_ARRAY& rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize) :
2477 Base(ElementReflectable::typeInfo(maxBitSize), allocator),
2478 m_rawArray(rawArray),
2479 m_maxBitSize(maxBitSize),
2480 m_dynamicBitSize(dynamicBitSize)
2485 return m_rawArray.size();
2490 m_rawArray.resize(
size);
2495 if (index >=
size())
2499 <<
"' of size " <<
size() <<
"!";
2502 return std::allocate_shared<ElementReflectable>(
2508 if (index >=
size())
2512 <<
"' of size " <<
size() <<
"!";
2515 return std::allocate_shared<ElementReflectable>(
2521 if (index >=
size())
2525 <<
"' of size " <<
size() <<
"!";
2528 m_rawArray[index] = value.template get<typename RAW_ARRAY::value_type>();
2533 m_rawArray.push_back(value.template get<typename RAW_ARRAY::value_type>());
2547 RAW_ARRAY& m_rawArray;
2548 const uint8_t m_maxBitSize;
2549 const uint8_t m_dynamicBitSize;
2557 template <
typename ALLOC,
typename RAW_ARRAY>
2559 template <
typename ALLOC,
typename RAW_ARRAY>
2562 template <
typename ALLOC,
typename RAW_ARRAY>
2564 template <
typename ALLOC,
typename RAW_ARRAY>
2567 template <
typename ALLOC,
typename RAW_ARRAY>
2569 template <
typename ALLOC,
typename RAW_ARRAY>
2572 template <
typename ALLOC,
typename RAW_ARRAY>
2574 template <
typename ALLOC,
typename RAW_ARRAY>
2577 template <
typename ALLOC,
typename RAW_ARRAY>
2579 template <
typename ALLOC,
typename RAW_ARRAY>
2582 template <
typename ALLOC,
typename RAW_ARRAY>
2584 template <
typename ALLOC,
typename RAW_ARRAY>
2587 template <
typename ALLOC,
typename RAW_ARRAY>
2589 template <
typename ALLOC,
typename RAW_ARRAY>
2592 template <
typename ALLOC,
typename RAW_ARRAY>
2594 template <
typename ALLOC,
typename RAW_ARRAY>
2597 template <
typename ALLOC,
typename RAW_ARRAY>
2599 template <
typename ALLOC,
typename RAW_ARRAY>
2602 template <
typename ALLOC,
typename RAW_ARRAY>
2605 template <
typename ALLOC,
typename RAW_ARRAY>
2609 template <
typename ALLOC,
typename RAW_ARRAY>
2612 template <
typename ALLOC,
typename RAW_ARRAY>
2616 template <
typename ALLOC,
typename RAW_ARRAY>
2619 template <
typename ALLOC,
typename RAW_ARRAY>
2623 template <
typename ALLOC,
typename RAW_ARRAY>
2626 template <
typename ALLOC,
typename RAW_ARRAY>
2630 template <
typename ALLOC,
typename RAW_ARRAY>
2633 template <
typename ALLOC,
typename RAW_ARRAY>
2636 template <
typename ALLOC,
typename RAW_ARRAY>
2639 template <
typename ALLOC,
typename RAW_ARRAY>
2642 template <
typename ALLOC,
typename RAW_ARRAY>
2645 template <
typename ALLOC,
typename RAW_ARRAY>
2648 template <
typename ALLOC,
typename RAW_ARRAY>
2650 template <
typename ALLOC,
typename RAW_ARRAY>
2653 template <
typename ALLOC,
typename RAW_ARRAY>
2656 template <
typename ALLOC,
typename RAW_ARRAY>
2659 template <
typename ALLOC,
typename RAW_ARRAY>
2662 template <
typename ALLOC,
typename RAW_ARRAY>
2665 template <
typename ALLOC,
typename RAW_ARRAY>
2668 template <
typename ALLOC,
typename RAW_ARRAY>
2671 template <
typename ALLOC,
typename RAW_ARRAY>
2673 template <
typename ALLOC,
typename RAW_ARRAY>
2676 template <
typename ALLOC,
typename RAW_ARRAY>
2678 template <
typename ALLOC,
typename RAW_ARRAY>
2681 template <
typename ALLOC,
typename RAW_ARRAY>
2683 template <
typename ALLOC,
typename RAW_ARRAY>
2686 template <
typename ALLOC,
typename RAW_ARRAY>
2688 template <
typename ALLOC,
typename RAW_ARRAY>
2691 template <
typename ALLOC,
typename RAW_ARRAY>
2693 template <
typename ALLOC,
typename RAW_ARRAY>
2696 template <
typename ALLOC,
typename RAW_ARRAY>
2698 template <
typename ALLOC,
typename RAW_ARRAY>
2701 template <
typename ALLOC,
typename RAW_ARRAY>
2703 template <
typename ALLOC,
typename RAW_ARRAY>
2706 template <
typename ALLOC,
typename RAW_ARRAY>
2709 template <
typename ALLOC,
typename RAW_ARRAY>
2717 template <
typename ALLOC,
typename RAW_ARRAY>
2723 using ElementType =
typename RAW_ARRAY::value_type;
2728 using Base::operator[];
2732 Base(ElementType::typeInfo(), allocator),
2733 m_rawArray(rawArray)
2738 return m_rawArray.size();
2743 if (index >=
size())
2747 <<
"' of size " <<
size() <<
"!";
2759 const RAW_ARRAY& m_rawArray;
2762 template <
typename ALLOC,
typename RAW_ARRAY>
2768 using ElementType =
typename RAW_ARRAY::value_type;
2774 Base(ElementType::typeInfo(), allocator),
2775 m_rawArray(rawArray)
2780 return m_rawArray.size();
2785 m_rawArray.resize(
size);
2790 if (index >=
size())
2794 <<
"' of size " <<
size() <<
"!";
2802 if (index >=
size())
2806 <<
"' of size " <<
size() <<
"!";
2814 if (index >=
size())
2818 <<
"' of size " <<
size() <<
"!";
2821 m_rawArray[index] = value.template get<typename RAW_ARRAY::value_type>();
2826 m_rawArray.push_back(value.template get<typename RAW_ARRAY::value_type>());
2840 RAW_ARRAY& m_rawArray;
2846 template <
typename ALLOC,
typename RAW_ARRAY>
2852 using ElementType =
typename RAW_ARRAY::value_type;
2857 using Base::operator[];
2861 Base(ElementType::typeInfo(), allocator),
2862 m_rawArray(rawArray)
2867 return m_rawArray.size();
2872 if (index >=
size())
2876 <<
"' of size " <<
size() <<
"!";
2888 const RAW_ARRAY& m_rawArray;
2891 template <
typename ALLOC,
typename RAW_ARRAY>
2897 using ElementType =
typename RAW_ARRAY::value_type;
2898 using UnderlyingElementType =
typename ElementType::underlying_type;
2904 Base(ElementType::typeInfo(), allocator),
2905 m_rawArray(rawArray)
2910 return m_rawArray.size();
2915 m_rawArray.resize(
size);
2920 if (index >=
size())
2924 <<
"' of size " <<
size() <<
"!";
2932 if (index >=
size())
2936 <<
"' of size " <<
size() <<
"!";
2944 if (index >=
size())
2948 <<
"' of size " <<
size() <<
"!";
2951 if (value.template isType<ElementType>())
2953 m_rawArray[index] = value.template get<ElementType>();
2957 m_rawArray[index] = ElementType(value.template get<UnderlyingElementType>());
2963 if (value.template isType<ElementType>())
2965 m_rawArray.push_back(value.template get<ElementType>());
2969 m_rawArray.push_back(ElementType(value.template get<UnderlyingElementType>()));
2984 RAW_ARRAY& m_rawArray;
2990 template <
typename ALLOC,
typename RAW_ARRAY>
2996 using ElementType =
typename RAW_ARRAY::value_type;
3001 using Base::operator[];
3006 m_rawArray(rawArray)
3011 return m_rawArray.size();
3016 if (index >=
size())
3020 <<
"' of size " <<
size() <<
"!";
3032 const RAW_ARRAY& m_rawArray;
3035 template <
typename ALLOC,
typename RAW_ARRAY>
3041 using ElementType =
typename RAW_ARRAY::value_type;
3042 using UnderlyingElementType =
typename std::underlying_type<ElementType>::type;
3049 m_rawArray(rawArray)
3054 return m_rawArray.size();
3059 m_rawArray.resize(
size);
3064 if (index >=
size())
3068 <<
"' of size " <<
size() <<
"!";
3076 if (index >=
size())
3080 <<
"' of size " <<
size() <<
"!";
3088 if (index >=
size())
3092 <<
"' of size " <<
size() <<
"!";
3095 if (value.template isType<ElementType>())
3097 m_rawArray[index] = value.template get<ElementType>();
3101 m_rawArray[index] = valueToEnum<ElementType>(value.template get<UnderlyingElementType>());
3107 if (value.template isType<ElementType>())
3109 m_rawArray.push_back(value.template get<ElementType>());
3113 m_rawArray.push_back(valueToEnum<ElementType>(value.template get<UnderlyingElementType>()));
3128 RAW_ARRAY& m_rawArray;
3137 template <
typename T,
typename ALLOC =
typename T::allocator_type>
3146 m_object(allocator),
3147 m_reflectable(m_object.reflectable(allocator))
3152 return m_reflectable->getTypeInfo();
3157 return m_reflectable->isArray();
3162 m_reflectable->initializeChildren();
3167 m_reflectable->initialize(typeArguments);
3172 return m_reflectable->initializeOffsets(bitPosition);
3182 return m_reflectable->bitSizeOf(bitPosition);
3192 m_reflectable->write(writer);
3197 return m_reflectable->getField(name);
3202 return m_reflectable->getField(name);
3207 return m_reflectable->createField(name);
3212 m_reflectable->setField(name, value);
3217 return m_reflectable->getParameter(name);
3222 return m_reflectable->getParameter(name);
3227 return m_reflectable->callFunction(name);
3232 return m_reflectable->callFunction(name);
3237 return m_reflectable->getChoice();
3242 return m_reflectable->find(path);
3247 return m_reflectable->find(path);
3252 return m_reflectable->operator[](path);
3257 return m_reflectable->operator[](path);
3262 return m_reflectable->size();
3267 m_reflectable->resize(
size);
3272 return m_reflectable->at(index);
3277 return m_reflectable->at(index);
3282 return m_reflectable->operator[](index);
3287 return m_reflectable->operator[](index);
3292 m_reflectable->setAt(value, index);
3297 m_reflectable->append(value);
3302 return m_reflectable->getAnyValue(allocator);
3307 return m_reflectable->getAnyValue(allocator);
3323 return m_reflectable->getBool();
3327 return m_reflectable->getInt8();
3331 return m_reflectable->getInt16();
3335 return m_reflectable->getInt32();
3339 return m_reflectable->getInt64();
3343 return m_reflectable->getUInt8();
3347 return m_reflectable->getUInt16();
3351 return m_reflectable->getUInt32();
3355 return m_reflectable->getUInt64();
3359 return m_reflectable->getFloat();
3363 return m_reflectable->getDouble();
3367 return m_reflectable->getBytes();
3371 return m_reflectable->getStringView();
3375 return m_reflectable->getBitBuffer();
3381 return m_reflectable->toInt();
3385 return m_reflectable->toUInt();
3389 return m_reflectable->toDouble();
3393 return m_reflectable->toString(allocator);
3410 template <
typename ALLOC>
3416 return std::allocate_shared<BoolReflectable<ALLOC>>(allocator, value);
3421 return std::allocate_shared<Int8Reflectable<ALLOC>>(allocator, value);
3426 return std::allocate_shared<Int16Reflectable<ALLOC>>(allocator, value);
3431 return std::allocate_shared<Int32Reflectable<ALLOC>>(allocator, value);
3436 return std::allocate_shared<Int64Reflectable<ALLOC>>(allocator, value);
3441 return std::allocate_shared<UInt8Reflectable<ALLOC>>(allocator, value);
3446 return std::allocate_shared<UInt16Reflectable<ALLOC>>(allocator, value);
3451 return std::allocate_shared<UInt32Reflectable<ALLOC>>(allocator, value);
3456 return std::allocate_shared<UInt64Reflectable<ALLOC>>(allocator, value);
3459 template <typename T, typename std::enable_if<std::is_signed<T>::value,
int>::type = 0>
3461 T value, uint8_t bitSize,
const ALLOC& allocator = ALLOC())
3463 return std::allocate_shared<FixedSignedBitFieldReflectable<ALLOC, T>>(allocator, value, bitSize);
3466 template <typename T, typename std::enable_if<std::is_unsigned<T>::value,
int>::type = 0>
3468 T value, uint8_t bitSize,
const ALLOC& allocator = ALLOC())
3470 return std::allocate_shared<FixedUnsignedBitFieldReflectable<ALLOC, T>>(allocator, value, bitSize);
3473 template <typename T, typename std::enable_if<std::is_signed<T>::value,
int>::type = 0>
3475 T value, uint8_t maxBitSize, uint8_t dynamicBitSize,
const ALLOC& allocator = ALLOC())
3477 return std::allocate_shared<DynamicSignedBitFieldReflectable<ALLOC, T>>(
3478 allocator, value, maxBitSize, dynamicBitSize);
3483 int64_t value, uint8_t maxBitSize,
const ALLOC& allocator = ALLOC())
3485 if (maxBitSize != 64)
3488 <<
"maxBitSize != 64 for referenced dynamic bit field!";
3494 template <typename T, typename std::enable_if<std::is_unsigned<T>::value,
int>::type = 0>
3496 T value, uint8_t maxBitSize, uint8_t dynamicBitSize,
const ALLOC& allocator = ALLOC())
3498 return std::allocate_shared<DynamicUnsignedBitFieldReflectable<ALLOC, T>>(
3499 allocator, value, maxBitSize, dynamicBitSize);
3504 uint64_t value, uint8_t maxBitSize,
const ALLOC& allocator = ALLOC())
3506 if (maxBitSize != 64)
3509 <<
"maxBitSize != 64 for referenced dynamic bit field!";
3517 return std::allocate_shared<VarInt16Reflectable<ALLOC>>(allocator, value);
3522 return std::allocate_shared<VarInt32Reflectable<ALLOC>>(allocator, value);
3527 return std::allocate_shared<VarInt64Reflectable<ALLOC>>(allocator, value);
3532 return std::allocate_shared<VarIntReflectable<ALLOC>>(allocator, value);
3537 return std::allocate_shared<VarUInt16Reflectable<ALLOC>>(allocator, value);
3542 return std::allocate_shared<VarUInt32Reflectable<ALLOC>>(allocator, value);
3547 return std::allocate_shared<VarUInt64Reflectable<ALLOC>>(allocator, value);
3552 return std::allocate_shared<VarUIntReflectable<ALLOC>>(allocator, value);
3557 return std::allocate_shared<VarSizeReflectable<ALLOC>>(allocator, value);
3562 return std::allocate_shared<Float16Reflectable<ALLOC>>(allocator, value);
3567 return std::allocate_shared<Float32Reflectable<ALLOC>>(allocator, value);
3572 return std::allocate_shared<Float64Reflectable<ALLOC>>(allocator, value);
3577 return std::allocate_shared<BytesReflectable<ALLOC>>(allocator, value);
3582 return std::allocate_shared<StringReflectable<ALLOC>>(allocator, value);
3588 return std::allocate_shared<BitBufferReflectable<ALLOC>>(allocator, value);
3591 template <
typename RAW_ARRAY>
3593 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3595 return std::allocate_shared<BoolReflectableConstArray<ALLOC, RAW_ARRAY>>(
3596 allocator, allocator, rawArray);
3599 template <
typename RAW_ARRAY>
3602 return std::allocate_shared<BoolReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3605 template <
typename RAW_ARRAY>
3607 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3609 return std::allocate_shared<Int8ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3610 allocator, allocator, rawArray);
3613 template <
typename RAW_ARRAY>
3616 return std::allocate_shared<Int8ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3619 template <
typename RAW_ARRAY>
3621 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3623 return std::allocate_shared<Int16ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3624 allocator, allocator, rawArray);
3627 template <
typename RAW_ARRAY>
3630 return std::allocate_shared<Int16ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3633 template <
typename RAW_ARRAY>
3635 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3637 return std::allocate_shared<Int32ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3638 allocator, allocator, rawArray);
3641 template <
typename RAW_ARRAY>
3644 return std::allocate_shared<Int32ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3647 template <
typename RAW_ARRAY>
3649 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3651 return std::allocate_shared<Int64ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3652 allocator, allocator, rawArray);
3655 template <
typename RAW_ARRAY>
3658 return std::allocate_shared<Int64ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3661 template <
typename RAW_ARRAY>
3663 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3665 return std::allocate_shared<UInt8ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3666 allocator, allocator, rawArray);
3669 template <
typename RAW_ARRAY>
3672 return std::allocate_shared<UInt8ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3675 template <
typename RAW_ARRAY>
3677 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3679 return std::allocate_shared<UInt16ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3680 allocator, allocator, rawArray);
3683 template <
typename RAW_ARRAY>
3686 return std::allocate_shared<UInt16ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3689 template <
typename RAW_ARRAY>
3691 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3693 return std::allocate_shared<UInt32ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3694 allocator, allocator, rawArray);
3697 template <
typename RAW_ARRAY>
3700 return std::allocate_shared<UInt32ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3703 template <
typename RAW_ARRAY>
3705 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3707 return std::allocate_shared<UInt64ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3708 allocator, allocator, rawArray);
3711 template <
typename RAW_ARRAY>
3714 return std::allocate_shared<UInt64ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3717 template <
typename RAW_ARRAY>
3719 const RAW_ARRAY& rawArray, uint8_t bitSize,
const ALLOC& allocator = ALLOC())
3721 return std::allocate_shared<FixedSignedBitFieldReflectableConstArray<ALLOC, RAW_ARRAY>>(
3722 allocator, allocator, rawArray, bitSize);
3725 template <
typename RAW_ARRAY>
3727 RAW_ARRAY& rawArray, uint8_t bitSize,
const ALLOC& allocator = ALLOC())
3729 return std::allocate_shared<FixedSignedBitFieldReflectableArray<ALLOC, RAW_ARRAY>>(
3730 allocator, allocator, rawArray, bitSize);
3733 template <
typename RAW_ARRAY>
3735 const RAW_ARRAY& rawArray, uint8_t bitSize,
const ALLOC& allocator = ALLOC())
3737 return std::allocate_shared<FixedUnsignedBitFieldReflectableConstArray<ALLOC, RAW_ARRAY>>(
3738 allocator, allocator, rawArray, bitSize);
3741 template <
typename RAW_ARRAY>
3743 RAW_ARRAY& rawArray, uint8_t bitSize,
const ALLOC& allocator = ALLOC())
3745 return std::allocate_shared<FixedUnsignedBitFieldReflectableArray<ALLOC, RAW_ARRAY>>(
3746 allocator, allocator, rawArray, bitSize);
3749 template <
typename RAW_ARRAY>
3751 uint8_t maxBitSize, uint8_t dynamicBitSize,
const ALLOC& allocator = ALLOC())
3753 return std::allocate_shared<DynamicSignedBitFieldReflectableConstArray<ALLOC, RAW_ARRAY>>(
3754 allocator, allocator, rawArray, maxBitSize, dynamicBitSize);
3757 template <
typename RAW_ARRAY>
3759 RAW_ARRAY& rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize,
const ALLOC& allocator = ALLOC())
3761 return std::allocate_shared<DynamicSignedBitFieldReflectableArray<ALLOC, RAW_ARRAY>>(
3762 allocator, allocator, rawArray, maxBitSize, dynamicBitSize);
3765 template <
typename RAW_ARRAY>
3767 uint8_t maxBitSize, uint8_t dynamicBitSize,
const ALLOC& allocator = ALLOC())
3769 return std::allocate_shared<DynamicUnsignedBitFieldReflectableConstArray<ALLOC, RAW_ARRAY>>(
3770 allocator, allocator, rawArray, maxBitSize, dynamicBitSize);
3773 template <
typename RAW_ARRAY>
3775 RAW_ARRAY& rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize,
const ALLOC& allocator = ALLOC())
3777 return std::allocate_shared<DynamicUnsignedBitFieldReflectableArray<ALLOC, RAW_ARRAY>>(
3778 allocator, allocator, rawArray, maxBitSize, dynamicBitSize);
3781 template <
typename RAW_ARRAY>
3783 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3785 return std::allocate_shared<VarInt16ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3786 allocator, allocator, rawArray);
3789 template <
typename RAW_ARRAY>
3792 return std::allocate_shared<VarInt16ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3795 template <
typename RAW_ARRAY>
3797 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3799 return std::allocate_shared<VarInt32ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3800 allocator, allocator, rawArray);
3803 template <
typename RAW_ARRAY>
3806 return std::allocate_shared<VarInt32ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3809 template <
typename RAW_ARRAY>
3811 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3813 return std::allocate_shared<VarInt64ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3814 allocator, allocator, rawArray);
3817 template <
typename RAW_ARRAY>
3820 return std::allocate_shared<VarInt64ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3823 template <
typename RAW_ARRAY>
3825 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3827 return std::allocate_shared<VarIntReflectableConstArray<ALLOC, RAW_ARRAY>>(
3828 allocator, allocator, rawArray);
3831 template <
typename RAW_ARRAY>
3834 return std::allocate_shared<VarIntReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3837 template <
typename RAW_ARRAY>
3839 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3841 return std::allocate_shared<VarUInt16ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3842 allocator, allocator, rawArray);
3845 template <
typename RAW_ARRAY>
3848 return std::allocate_shared<VarUInt16ReflectableArray<ALLOC, RAW_ARRAY>>(
3849 allocator, allocator, rawArray);
3852 template <
typename RAW_ARRAY>
3854 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3856 return std::allocate_shared<VarUInt32ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3857 allocator, allocator, rawArray);
3860 template <
typename RAW_ARRAY>
3863 return std::allocate_shared<VarUInt32ReflectableArray<ALLOC, RAW_ARRAY>>(
3864 allocator, allocator, rawArray);
3867 template <
typename RAW_ARRAY>
3869 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3871 return std::allocate_shared<VarUInt64ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3872 allocator, allocator, rawArray);
3875 template <
typename RAW_ARRAY>
3878 return std::allocate_shared<VarUInt64ReflectableArray<ALLOC, RAW_ARRAY>>(
3879 allocator, allocator, rawArray);
3882 template <
typename RAW_ARRAY>
3884 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3886 return std::allocate_shared<VarUIntReflectableConstArray<ALLOC, RAW_ARRAY>>(
3887 allocator, allocator, rawArray);
3890 template <
typename RAW_ARRAY>
3893 return std::allocate_shared<VarUIntReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3896 template <
typename RAW_ARRAY>
3898 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3900 return std::allocate_shared<VarSizeReflectableConstArray<ALLOC, RAW_ARRAY>>(
3901 allocator, allocator, rawArray);
3904 template <
typename RAW_ARRAY>
3907 return std::allocate_shared<VarSizeReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3910 template <
typename RAW_ARRAY>
3912 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3914 return std::allocate_shared<Float16ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3915 allocator, allocator, rawArray);
3918 template <
typename RAW_ARRAY>
3921 return std::allocate_shared<Float16ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3924 template <
typename RAW_ARRAY>
3926 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3928 return std::allocate_shared<Float32ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3929 allocator, allocator, rawArray);
3932 template <
typename RAW_ARRAY>
3935 return std::allocate_shared<Float32ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3938 template <
typename RAW_ARRAY>
3940 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3942 return std::allocate_shared<Float64ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3943 allocator, allocator, rawArray);
3946 template <
typename RAW_ARRAY>
3949 return std::allocate_shared<Float64ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3952 template <
typename RAW_ARRAY>
3954 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3956 return std::allocate_shared<BytesReflectableConstArray<ALLOC, RAW_ARRAY>>(
3957 allocator, allocator, rawArray);
3960 template <
typename RAW_ARRAY>
3963 return std::allocate_shared<BytesReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3966 template <
typename RAW_ARRAY>
3968 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3970 return std::allocate_shared<StringReflectableConstArray<ALLOC, RAW_ARRAY>>(
3971 allocator, allocator, rawArray);
3974 template <
typename RAW_ARRAY>
3977 return std::allocate_shared<StringReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3980 template <
typename RAW_ARRAY>
3982 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3984 return std::allocate_shared<BitBufferReflectableConstArray<ALLOC, RAW_ARRAY>>(
3985 allocator, allocator, rawArray);
3988 template <
typename RAW_ARRAY>
3991 return std::allocate_shared<BitBufferReflectableArray<ALLOC, RAW_ARRAY>>(
3992 allocator, allocator, rawArray);
3995 template <
typename RAW_ARRAY>
3997 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3999 return std::allocate_shared<CompoundReflectableConstArray<ALLOC, RAW_ARRAY>>(
4000 allocator, allocator, rawArray);
4003 template <
typename RAW_ARRAY>
4006 return std::allocate_shared<CompoundReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
4009 template <
typename RAW_ARRAY>
4011 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
4013 return std::allocate_shared<BitmaskReflectableConstArray<ALLOC, RAW_ARRAY>>(
4014 allocator, allocator, rawArray);
4017 template <
typename RAW_ARRAY>
4020 return std::allocate_shared<BitmaskReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
4023 template <
typename RAW_ARRAY>
4025 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
4027 return std::allocate_shared<EnumReflectableConstArray<ALLOC, RAW_ARRAY>>(
4028 allocator, allocator, rawArray);
4031 template <
typename RAW_ARRAY>
4034 return std::allocate_shared<EnumReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
4041 template <
typename ALLOC>
4043 m_typeInfo(typeInfo)
4046 template <
typename ALLOC>
4049 template <
typename ALLOC>
4055 template <
typename ALLOC>
4061 template <
typename ALLOC>
4064 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not a compound type!";
4067 template <
typename ALLOC>
4070 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no type arguments!";
4073 template <
typename ALLOC>
4076 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not a compound type!";
4079 template <
typename ALLOC>
4085 template <
typename ALLOC>
4088 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not implemented!";
4091 template <
typename ALLOC>
4097 template <
typename ALLOC>
4100 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not implemented!";
4103 template <
typename ALLOC>
4106 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no fields to get!";
4109 template <
typename ALLOC>
4112 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no fields to get!";
4115 template <
typename ALLOC>
4118 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no fields to create!";
4121 template <
typename ALLOC>
4124 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no fields to set!";
4127 template <
typename ALLOC>
4130 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no parameters to get!";
4133 template <
typename ALLOC>
4136 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no parameters to get!";
4139 template <
typename ALLOC>
4142 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no functions to call!";
4145 template <
typename ALLOC>
4148 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no functions to call!";
4151 template <
typename ALLOC>
4154 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is neither choice nor union!";
4157 template <
typename ALLOC>
4160 return detail::getFromObject(*
this, path, 0);
4163 template <
typename ALLOC>
4166 return detail::getFromObject(*
this, path, 0);
4169 template <
typename ALLOC>
4175 template <
typename ALLOC>
4181 template <
typename ALLOC>
4184 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4187 template <
typename ALLOC>
4190 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4193 template <
typename ALLOC>
4196 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4199 template <
typename ALLOC>
4202 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4205 template <
typename ALLOC>
4208 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4211 template <
typename ALLOC>
4214 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4217 template <
typename ALLOC>
4220 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4223 template <
typename ALLOC>
4226 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4229 template <
typename ALLOC>
4232 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not implemented!";
4235 template <
typename ALLOC>
4238 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not implemented!";
4241 template <
typename ALLOC>
4244 return getAnyValue(ALLOC());
4247 template <
typename ALLOC>
4250 return getAnyValue(ALLOC());
4253 template <
typename ALLOC>
4256 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not boolean type!";
4259 template <
typename ALLOC>
4265 template <
typename ALLOC>
4268 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not int16 type!";
4271 template <
typename ALLOC>
4274 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not int32 type!";
4277 template <
typename ALLOC>
4280 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not int64 type!";
4283 template <
typename ALLOC>
4286 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not uint8 type!";
4289 template <
typename ALLOC>
4292 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not uint16 type!";
4295 template <
typename ALLOC>
4298 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not uint32 type!";
4301 template <
typename ALLOC>
4304 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not uint64 type!";
4307 template <
typename ALLOC>
4310 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not float type!";
4313 template <
typename ALLOC>
4316 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not double type!";
4319 template <
typename ALLOC>
4322 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not bytes type!";
4325 template <
typename ALLOC>
4328 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not string type!";
4331 template <
typename ALLOC>
4334 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not an extern type!";
4337 template <
typename ALLOC>
4341 << getTypeInfo().getSchemaName() <<
"' to signed integer is not available!";
4344 template <
typename ALLOC>
4348 << getTypeInfo().getSchemaName() <<
"' to unsigned integer is not available!";
4351 template <
typename ALLOC>
4355 << getTypeInfo().getSchemaName() <<
"' to double is not available!";
4358 template <
typename ALLOC>
4362 << getTypeInfo().getSchemaName() <<
"' to string is not available!";
4365 template <
typename ALLOC>
4371 template <
typename ALLOC>
4374 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4377 template <
typename ALLOC>
4380 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4383 template <
typename ALLOC>
4386 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4389 template <
typename ALLOC>
4392 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4395 template <
typename ALLOC>
4398 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4401 template <
typename ALLOC>
4404 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4407 template <
typename ALLOC>
4410 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4413 template <
typename ALLOC>
4416 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4419 template <
typename ALLOC>
4422 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4425 template <
typename ALLOC>
4428 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4431 template <
typename ALLOC>
4434 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4437 template <
typename ALLOC>
4440 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4443 template <
typename ALLOC>
4446 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4449 template <
typename ALLOC>
4452 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4455 template <
typename ALLOC>
4458 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4461 template <
typename ALLOC>
4464 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4467 template <
typename ALLOC>
4470 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4473 template <
typename ALLOC>
4476 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4479 template <
typename ALLOC>
4482 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4485 template <
typename ALLOC>
4488 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4491 template <
typename ALLOC>
4494 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4497 template <
typename ALLOC>
4500 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4503 template <
typename ALLOC>
4506 return this->at(index);
4509 template <
typename ALLOC>
4512 return this->at(index);
4515 template <
typename ALLOC>
4518 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4521 template <
typename ALLOC>
4524 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4527 template <
typename ALLOC>
4530 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4533 template <
typename ALLOC>
4536 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4539 template <
typename ALLOC>
4542 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4545 template <
typename ALLOC>
4548 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4551 template <
typename ALLOC>
4554 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4557 template <
typename ALLOC>
4560 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4563 template <
typename ALLOC>
4566 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4569 template <
typename ALLOC>
4572 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4575 template <
typename ALLOC>
4578 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4581 template <
typename ALLOC>
4584 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4587 template <
typename ALLOC>
4590 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4593 template <
typename ALLOC>
4596 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4599 template <
typename ALLOC>
4602 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4605 template <
typename ALLOC>
4608 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4611 template <
typename ALLOC>
4614 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4617 template <
typename ALLOC>
4620 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4623 template <
typename ALLOC>
4626 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is a constant array!";
4629 template <
typename ALLOC>
4632 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is a constant array!";
4635 template <
typename ALLOC>
4638 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is a constant array!";
4641 template <
typename ALLOC>
4644 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is a constant array!";
4647 template <
typename ALLOC>
4650 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is a constant array!";
4653 template <
typename ALLOC>
4656 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is a constant array!";
allocator_type get_allocator() const
static IBasicReflectablePtr< ALLOC > getFloat32(float value, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getFloat32Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getFixedUnsignedBitFieldArray(RAW_ARRAY &rawArray, uint8_t bitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getFloat64Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getStringArray(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getVarUInt16Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarUIntArray(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarInt16Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getVarUInt32Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getVarInt16Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarInt32Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getBool(bool value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getInt64Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getUInt32Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getInt8Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getInt8(int8_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getDynamicSignedBitFieldArray(const RAW_ARRAY &rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getVarIntArray(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getBitmaskArray(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getBytesArray(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getFixedUnsignedBitFieldArray(const RAW_ARRAY &rawArray, uint8_t bitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getString(StringView value, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getFloat64Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getUInt16Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getVarInt32Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getInt8Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getFloat16Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getInt64(int64_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarInt32(int32_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarInt16(int16_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getInt64Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getFixedSignedBitFieldArray(const RAW_ARRAY &rawArray, uint8_t bitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getDynamicSignedBitField(int64_t value, uint8_t maxBitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getBytesArray(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarUInt64Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarUInt32Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getBitBuffer(const BasicBitBuffer< ALLOC > &value, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getVarUIntArray(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getUInt16(uint16_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getCompoundArray(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarUInt16Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getVarUInt64Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getBitBufferArray(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarUInt(uint64_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getUInt8(uint8_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getUInt32(uint32_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getInt32(int32_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getBytes(Span< const uint8_t > value, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getCompoundArray(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getBitmaskArray(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getFixedSignedBitFieldArray(RAW_ARRAY &rawArray, uint8_t bitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getDynamicUnsignedBitField(uint64_t value, uint8_t maxBitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarInt64(int64_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getUInt16Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarUInt16(uint16_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getBoolArray(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getUInt32Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getUInt8Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getBitBufferArray(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getStringArray(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getDynamicUnsignedBitField(T value, uint8_t maxBitSize, uint8_t dynamicBitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getEnumArray(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getVarSizeArray(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getInt16Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarSize(uint32_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getDynamicSignedBitField(T value, uint8_t maxBitSize, uint8_t dynamicBitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarSizeArray(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getUInt64(uint64_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getFloat16(float value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarIntArray(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarUInt32(uint32_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getInt32Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getBoolArray(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getInt16(int16_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getDynamicSignedBitFieldArray(RAW_ARRAY &rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarUInt64(uint64_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getDynamicUnsignedBitFieldArray(RAW_ARRAY &rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getUInt64Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getVarInt64Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getUInt64Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getEnumArray(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getFixedSignedBitField(T value, uint8_t bitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getFloat32Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getDynamicUnsignedBitFieldArray(const RAW_ARRAY &rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarInt(int64_t value, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getInt32Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getFloat64(double value, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getVarInt64Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getUInt8Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getFixedUnsignedBitField(T value, uint8_t bitSize, const ALLOC &allocator=ALLOC())
static IBasicReflectableConstPtr< ALLOC > getInt16Array(const RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static IBasicReflectablePtr< ALLOC > getFloat16Array(RAW_ARRAY &rawArray, const ALLOC &allocator=ALLOC())
static constexpr const size_type npos
BasicStringView substr(size_type pos=0, size_type count=npos) const
static const IBasicTypeInfo< ALLOC > & typeInfo()
BitBufferReflectable(const BasicBitBuffer< ALLOC > &value)
size_t bitSizeOf(size_t) const override
void write(BitStreamWriter &writer) const override
const BasicBitBuffer< ALLOC > & getBitBuffer() const override
void writeFloat64(double data)
void writeVarInt64(int64_t data)
void writeVarInt16(int16_t data)
void writeString(StringView data)
void writeSignedBits(int32_t data, uint8_t numBits=32)
void writeFloat32(float data)
void writeVarUInt64(uint64_t data)
void writeVarUInt16(uint16_t data)
void writeVarInt32(int32_t data)
void writeSignedBits64(int64_t data, uint8_t numBits=64)
void writeVarSize(uint32_t data)
void writeVarUInt32(uint32_t data)
void writeVarUInt(uint64_t data)
void writeVarInt(int64_t data)
void writeFloat16(float data)
void writeBits64(uint64_t data, uint8_t numBits=64)
void writeBytes(Span< const uint8_t > data)
void writeBool(bool data)
void writeBitBuffer(const BasicBitBuffer< ALLOC > &bitBuffer)
void writeBits(uint32_t data, uint8_t numBits=32)
void resize(size_t size) override
void setAt(const AnyHolder< ALLOC > &value, size_t index) override
IBasicReflectablePtr< ALLOC > at(size_t index) override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) override
BitmaskReflectableArray(const ALLOC &allocator, RAW_ARRAY &rawArray)
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
void append(const AnyHolder< ALLOC > &value) override
size_t size() const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
size_t size() const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
BitmaskReflectableConstArray(const ALLOC &allocator, const RAW_ARRAY &rawArray)
size_t bitSizeOf(size_t) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
BoolReflectable(bool value)
bool getBool() const override
void write(BitStreamWriter &writer) const override
void resize(size_t size) override
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) override
void setAt(const AnyHolder< ALLOC > &value, size_t index) override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
void append(const AnyHolder< ALLOC > &value) override
IBasicReflectablePtr< ALLOC > at(size_t index) override
BuiltinReflectableArray(const ALLOC &allocator, RAW_ARRAY &rawArray)
size_t size() const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
BuiltinReflectableBase(const IBasicTypeInfo< ALLOC > &typeInfo, T value)
const T & getValue() const
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
BuiltinReflectableBase(const IBasicTypeInfo< ALLOC > &typeInfo, const T &value)
size_t size() const override
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
BuiltinReflectableConstArray(const ALLOC &allocator, const RAW_ARRAY &rawArray)
static const IBasicTypeInfo< ALLOC > & getDynamicUnsignedBitField(uint8_t maxBitSize)
static const IBasicTypeInfo< ALLOC > & getFloat32()
static const IBasicTypeInfo< ALLOC > & getVarUInt64()
static const IBasicTypeInfo< ALLOC > & getUInt32()
static const IBasicTypeInfo< ALLOC > & getBool()
static const IBasicTypeInfo< ALLOC > & getVarInt64()
static const IBasicTypeInfo< ALLOC > & getVarUInt()
static const IBasicTypeInfo< ALLOC > & getVarInt32()
static const IBasicTypeInfo< ALLOC > & getFixedUnsignedBitField(uint8_t bitSize)
static const IBasicTypeInfo< ALLOC > & getInt32()
static const IBasicTypeInfo< ALLOC > & getInt16()
static const IBasicTypeInfo< ALLOC > & getVarInt()
static const IBasicTypeInfo< ALLOC > & getString()
static const IBasicTypeInfo< ALLOC > & getInt8()
static const IBasicTypeInfo< ALLOC > & getVarInt16()
static const IBasicTypeInfo< ALLOC > & getUInt8()
static const IBasicTypeInfo< ALLOC > & getBitBuffer()
static const IBasicTypeInfo< ALLOC > & getUInt64()
static const IBasicTypeInfo< ALLOC > & getInt64()
static const IBasicTypeInfo< ALLOC > & getUInt16()
static const IBasicTypeInfo< ALLOC > & getVarSize()
static const IBasicTypeInfo< ALLOC > & getFloat16()
static const IBasicTypeInfo< ALLOC > & getVarUInt32()
static const IBasicTypeInfo< ALLOC > & getBytes()
static const IBasicTypeInfo< ALLOC > & getVarUInt16()
static const IBasicTypeInfo< ALLOC > & getDynamicSignedBitField(uint8_t maxBitSize)
static const IBasicTypeInfo< ALLOC > & getFixedSignedBitField(uint8_t bitSize)
static const IBasicTypeInfo< ALLOC > & getFloat64()
size_t bitSizeOf(size_t) const override
void write(BitStreamWriter &writer) const override
BytesReflectable(Span< const uint8_t > value)
Span< const uint8_t > getBytes() const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
void setAt(const AnyHolder< ALLOC > &value, size_t index) override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
size_t size() const override
IBasicReflectablePtr< ALLOC > at(size_t index) override
void resize(size_t size) override
void append(const AnyHolder< ALLOC > &value) override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) override
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
CompoundReflectableArray(const ALLOC &allocator, RAW_ARRAY &rawArray)
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
CompoundReflectableConstArray(const ALLOC &allocator, const RAW_ARRAY &rawArray)
size_t size() const override
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) override
size_t size() const override
void append(const AnyHolder< ALLOC > &value) override
IBasicReflectablePtr< ALLOC > at(size_t index) override
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
void resize(size_t size) override
void setAt(const AnyHolder< ALLOC > &value, size_t index) override
DynamicBitFieldReflectableArray(const ALLOC &allocator, RAW_ARRAY &rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize)
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
DynamicBitFieldReflectableConstArray(const ALLOC &allocator, const RAW_ARRAY &rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize)
size_t size() const override
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t maxBitSize)
size_t bitSizeOf(size_t) const override
void write(BitStreamWriter &writer) const override
DynamicSignedBitFieldReflectable(int16_t value, uint8_t maxBitSize, uint8_t dynamicBitSize)
void write(BitStreamWriter &writer) const override
DynamicSignedBitFieldReflectable(int32_t value, uint8_t maxBitSize, uint8_t dynamicBitSize)
size_t bitSizeOf(size_t) const override
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t maxBitSize)
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t maxBitSize)
DynamicSignedBitFieldReflectable(int64_t value, uint8_t maxBitSize, uint8_t dynamicBitSize)
size_t bitSizeOf(size_t) const override
void write(BitStreamWriter &writer) const override
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t maxBitSize)
size_t bitSizeOf(size_t) const override
DynamicSignedBitFieldReflectable(int8_t value, uint8_t maxBitSize, uint8_t dynamicBitSize)
size_t bitSizeOf(size_t) const override
void write(BitStreamWriter &writer) const override
DynamicUnsignedBitFieldReflectable(uint16_t value, uint8_t maxBitSize, uint8_t dynamicBitSize)
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t maxBitSize)
DynamicUnsignedBitFieldReflectable(uint32_t value, uint8_t maxBitSize, uint8_t dynamicBitSize)
void write(BitStreamWriter &writer) const override
size_t bitSizeOf(size_t) const override
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t maxBitSize)
size_t bitSizeOf(size_t) const override
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t maxBitSize)
DynamicUnsignedBitFieldReflectable(uint64_t value, uint8_t maxBitSize, uint8_t dynamicBitSize)
void write(BitStreamWriter &writer) const override
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t maxBitSize)
DynamicUnsignedBitFieldReflectable(uint8_t value, uint8_t maxBitSize, uint8_t dynamicBitSize)
size_t bitSizeOf(size_t) const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) override
EnumReflectableArray(const ALLOC &allocator, RAW_ARRAY &rawArray)
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
IBasicReflectablePtr< ALLOC > at(size_t index) override
void resize(size_t size) override
void setAt(const AnyHolder< ALLOC > &value, size_t index) override
void append(const AnyHolder< ALLOC > &value) override
size_t size() const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
size_t size() const override
EnumReflectableConstArray(const ALLOC &allocator, const RAW_ARRAY &rawArray)
IBasicReflectablePtr< ALLOC > at(size_t index) override
void append(const AnyHolder< ALLOC > &value) override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) override
size_t size() const override
FixedBitFieldReflectableArray(const ALLOC &allocator, RAW_ARRAY &rawArray, uint8_t bitSize)
void resize(size_t size) override
void setAt(const AnyHolder< ALLOC > &value, size_t index) override
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
FixedBitFieldReflectableConstArray(const ALLOC &allocator, const RAW_ARRAY &rawArray, uint8_t bitSize)
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
size_t size() const override
void write(BitStreamWriter &writer) const override
FixedSignedBitFieldReflectable(int16_t value, uint8_t bitSize)
size_t bitSizeOf(size_t) const override
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t bitSize)
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t bitSize)
void write(BitStreamWriter &writer) const override
size_t bitSizeOf(size_t) const override
FixedSignedBitFieldReflectable(int32_t value, uint8_t bitSize)
void write(BitStreamWriter &writer) const override
FixedSignedBitFieldReflectable(int64_t value, uint8_t bitSize)
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t bitSize)
size_t bitSizeOf(size_t) const override
size_t bitSizeOf(size_t) const override
FixedSignedBitFieldReflectable(int8_t value, uint8_t bitSize)
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t bitSize)
void write(BitStreamWriter &writer) const override
FixedUnsignedBitFieldReflectable(uint16_t value, uint8_t bitSize)
void write(BitStreamWriter &writer) const override
size_t bitSizeOf(size_t) const override
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t bitSize)
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t bitSize)
size_t bitSizeOf(size_t) const override
void write(BitStreamWriter &writer) const override
FixedUnsignedBitFieldReflectable(uint32_t value, uint8_t bitSize)
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t bitSize)
void write(BitStreamWriter &writer) const override
FixedUnsignedBitFieldReflectable(uint64_t value, uint8_t bitSize)
size_t bitSizeOf(size_t) const override
size_t bitSizeOf(size_t) const override
FixedUnsignedBitFieldReflectable(uint8_t value, uint8_t bitSize)
static const IBasicTypeInfo< ALLOC > & typeInfo(uint8_t bitSize)
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
Float16Reflectable(float value)
void write(BitStreamWriter &writer) const override
size_t bitSizeOf(size_t) const override
float getFloat() const override
Float32Reflectable(float value)
static const IBasicTypeInfo< ALLOC > & typeInfo()
size_t bitSizeOf(size_t) const override
float getFloat() const override
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
size_t bitSizeOf(size_t) const override
Float64Reflectable(double value)
void write(BitStreamWriter &writer) const override
double getDouble() const override
double toDouble() const override
virtual StringView getSchemaName() const =0
int16_t getInt16() const override
size_t bitSizeOf(size_t) const override
Int16Reflectable(int16_t value)
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
int32_t getInt32() const override
size_t bitSizeOf(size_t) const override
Int32Reflectable(int32_t value)
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
int64_t getInt64() const override
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
Int64Reflectable(int64_t value)
size_t bitSizeOf(size_t) const override
int8_t getInt8() const override
size_t bitSizeOf(size_t) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
void write(BitStreamWriter &writer) const override
Int8Reflectable(int8_t value)
double toDouble() const override
string< ALLOC > toString(const ALLOC &allocator) const override
BuiltinReflectableBase< ALLOC, T > Base
IntegralReflectableBase(const IBasicTypeInfo< ALLOC > &typeInfo, T value)
ReflectableAllocatorHolderBase(const IBasicTypeInfo< ALLOC > &typeInfo, const ALLOC &allocator)
void initializeChildren() override
int32_t getInt32() const override
uint8_t getUInt8() const override
IBasicReflectableConstPtr< ALLOC > callFunction(StringView name) const override
Span< const uint8_t > getBytes() const override
float getFloat() const override
uint64_t toUInt() const override
double toDouble() const override
int16_t getInt16() const override
int64_t toInt() const override
StringView getChoice() const override
uint64_t getUInt64() const override
int8_t getInt8() const override
uint32_t getUInt32() const override
void initialize(const vector< AnyHolder< ALLOC >, ALLOC > &typeArguments) override
void write(BitStreamWriter &writer) const override
bool isArray() const override
IBasicReflectableConstPtr< ALLOC > operator[](size_t index) const override
IBasicReflectableConstPtr< ALLOC > getParameter(StringView name) const override
IBasicReflectableConstPtr< ALLOC > getField(StringView name) const override
int64_t getInt64() const override
double getDouble() const override
IBasicReflectablePtr< ALLOC > createField(StringView name) override
const BasicBitBuffer< ALLOC > & getBitBuffer() const override
bool getBool() const override
uint16_t getUInt16() const override
void setField(StringView name, const AnyHolder< ALLOC > &value) override
StringView getStringView() const override
StringView getStringView() const override
const IBasicTypeInfo< ALLOC > & getTypeInfo() const override
void initializeChildren() override
const BasicBitBuffer< ALLOC > & getBitBuffer() const override
int64_t toInt() const override
IBasicReflectableConstPtr< ALLOC > operator[](StringView path) const override
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
ReflectableBase & operator=(const ReflectableBase &&)=delete
IBasicReflectableConstPtr< ALLOC > callFunction(StringView name) const override
int32_t getInt32() const override
void resize(size_t size) override
int16_t getInt16() const override
void setField(StringView name, const AnyHolder< ALLOC > &value) override
IBasicReflectableConstPtr< ALLOC > getParameter(StringView name) const override
ReflectableBase(const ReflectableBase &)=delete
IBasicReflectableConstPtr< ALLOC > find(StringView path) const override
Span< const uint8_t > getBytes() const override
ReflectableBase(const IBasicTypeInfo< ALLOC > &typeInfo)
size_t size() const override
float getFloat() const override
double getDouble() const override
uint64_t getUInt64() const override
uint8_t getUInt8() const override
uint16_t getUInt16() const override
bool isArray() const override
size_t bitSizeOf() const override
ReflectableBase & operator=(const ReflectableBase &)=delete
AnyHolder< ALLOC > getAnyValue() const override
void append(const AnyHolder< ALLOC > &value) override
~ReflectableBase() override=0
uint64_t toUInt() const override
IBasicReflectablePtr< ALLOC > createField(StringView name) override
ReflectableBase(const ReflectableBase &&)=delete
string< ALLOC > toString() const override
size_t initializeOffsets() override
uint32_t getUInt32() const override
bool getBool() const override
int8_t getInt8() const override
IBasicReflectableConstPtr< ALLOC > getField(StringView name) const override
void write(BitStreamWriter &writer) const override
void setAt(const AnyHolder< ALLOC > &value, size_t index) override
StringView getChoice() const override
int64_t getInt64() const override
double toDouble() const override
void initialize(const vector< AnyHolder< ALLOC >, ALLOC > &typeArguments) override
IBasicReflectablePtr< ALLOC > getParameter(StringView name) override
void setField(StringView name, const AnyHolder< ALLOC > &value) override
IBasicReflectablePtr< ALLOC > getField(StringView name) override
void initialize(const vector< AnyHolder< ALLOC >, ALLOC > &typeArguments) override
IBasicReflectablePtr< ALLOC > callFunction(StringView name) override
void initializeChildren() override
IBasicReflectablePtr< ALLOC > operator[](size_t index) override
void setAt(const AnyHolder< ALLOC > &value, size_t index) override
IBasicReflectablePtr< ALLOC > at(size_t index) override
void append(const AnyHolder< ALLOC > &value) override
void resize(size_t index) override
IBasicReflectablePtr< ALLOC > operator[](size_t index) override
IBasicReflectableConstPtr< ALLOC > find(StringView path) const override
void resize(size_t size) override
int32_t getInt32() const override
int64_t getInt64() const override
int16_t getInt16() const override
AnyHolder< ALLOC > getAnyValue() override
void initializeChildren() override
Span< const uint8_t > getBytes() const override
IBasicReflectablePtr< ALLOC > createField(StringView name) override
IBasicReflectableConstPtr< ALLOC > getParameter(StringView name) const override
const BasicBitBuffer< ALLOC > & getBitBuffer() const override
IBasicReflectablePtr< ALLOC > callFunction(StringView name) override
bool getBool() const override
int64_t toInt() const override
IBasicReflectableConstPtr< ALLOC > operator[](StringView path) const override
int8_t getInt8() const override
IBasicReflectablePtr< ALLOC > find(StringView path) override
IBasicReflectableConstPtr< ALLOC > callFunction(StringView name) const override
uint16_t getUInt16() const override
size_t bitSizeOf(size_t bitPosition) const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) override
float getFloat() const override
size_t initializeOffsets() override
void setField(StringView name, const AnyHolder< ALLOC > &value) override
bool isArray() const override
IBasicReflectableConstPtr< ALLOC > operator[](size_t index) const override
IBasicReflectablePtr< ALLOC > at(size_t index) override
string< RebindAlloc< ALLOC, char > > toString(const ALLOC &allocator) const override
void append(const AnyHolder< ALLOC > &value) override
void setAt(const AnyHolder< ALLOC > &value, size_t index) override
size_t size() const override
double toDouble() const override
IBasicReflectableConstPtr< ALLOC > getField(StringView name) const override
void write(BitStreamWriter &writer) const override
IBasicReflectableConstPtr< ALLOC > at(size_t index) const override
IBasicReflectablePtr< ALLOC > getField(StringView name) override
IBasicReflectablePtr< ALLOC > operator[](StringView path) override
string< RebindAlloc< ALLOC, char > > toString() const override
uint64_t getUInt64() const override
uint64_t toUInt() const override
StringView getChoice() const override
uint32_t getUInt32() const override
double getDouble() const override
IBasicReflectablePtr< ALLOC > getParameter(StringView name) override
size_t bitSizeOf() const override
ReflectableOwner(const ALLOC &allocator)
void initialize(const vector< AnyHolder< ALLOC >, ALLOC > &typeArguments) override
const IBasicTypeInfo< ALLOC > & getTypeInfo() const override
AnyHolder< ALLOC > getAnyValue(const ALLOC &allocator) const override
size_t initializeOffsets(size_t bitPosition) override
uint8_t getUInt8() const override
AnyHolder< ALLOC > getAnyValue() const override
StringView getStringView() const override
IntegralReflectableBase< ALLOC, int8_t > Base
int64_t toInt() const override
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
StringView getStringView() const override
size_t bitSizeOf(size_t) const override
StringReflectable(StringView value)
string< ALLOC > toString(const ALLOC &allocator) const override
uint16_t getUInt16() const override
size_t bitSizeOf(size_t) const override
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
UInt16Reflectable(uint16_t value)
uint32_t getUInt32() const override
void write(BitStreamWriter &writer) const override
size_t bitSizeOf(size_t) const override
UInt32Reflectable(uint32_t value)
static const IBasicTypeInfo< ALLOC > & typeInfo()
uint64_t getUInt64() const override
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
size_t bitSizeOf(size_t) const override
UInt64Reflectable(uint64_t value)
uint8_t getUInt8() const override
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
UInt8Reflectable(uint8_t value)
size_t bitSizeOf(size_t) const override
uint64_t toUInt() const override
IntegralReflectableBase< ALLOC, uint8_t > Base
size_t bitSizeOf(size_t) const override
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
VarInt16Reflectable(int16_t value)
void write(BitStreamWriter &writer) const override
VarInt32Reflectable(int32_t value)
size_t bitSizeOf(size_t) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
size_t bitSizeOf(size_t) const override
VarInt64Reflectable(int64_t value)
static const IBasicTypeInfo< ALLOC > & typeInfo()
VarIntReflectable(int64_t value)
size_t bitSizeOf(size_t) const override
void write(BitStreamWriter &writer) const override
size_t bitSizeOf(size_t) const override
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
VarSizeReflectable(uint32_t value)
void write(BitStreamWriter &writer) const override
VarUInt16Reflectable(uint16_t value)
static const IBasicTypeInfo< ALLOC > & typeInfo()
size_t bitSizeOf(size_t) const override
size_t bitSizeOf(size_t) const override
VarUInt32Reflectable(uint32_t value)
void write(BitStreamWriter &writer) const override
static const IBasicTypeInfo< ALLOC > & typeInfo()
static const IBasicTypeInfo< ALLOC > & typeInfo()
size_t bitSizeOf(size_t) const override
void write(BitStreamWriter &writer) const override
VarUInt64Reflectable(uint64_t value)
static const IBasicTypeInfo< ALLOC > & typeInfo()
void write(BitStreamWriter &writer) const override
size_t bitSizeOf(size_t) const override
VarUIntReflectable(uint64_t value)
size_t bitSizeOfString(StringView stringValue)
size_t bitSizeOfVarInt32(int32_t value)
const IBasicTypeInfo< ALLOC > & enumTypeInfo()
size_t bitSizeOfVarUInt32(uint32_t value)
BasicStringView< char, std::char_traits< char > > StringView
size_t bitSizeOfVarInt64(int64_t value)
std::basic_string< char, std::char_traits< char >, RebindAlloc< ALLOC, char > > string
std::vector< T, RebindAlloc< ALLOC, T > > vector
IBasicReflectablePtr< ALLOC > enumReflectable(T value, const ALLOC &allocator=ALLOC())
size_t initializeOffsets(size_t bitPosition, T value)
size_t bitSizeOfVarUInt64(uint64_t value)
size_t bitSizeOfVarInt16(int16_t value)
size_t bitSizeOfBitBuffer(const BasicBitBuffer< ALLOC > &bitBuffer)
string< ALLOC > toString(T value, const ALLOC &allocator=ALLOC())
size_t bitSizeOfVarUInt(uint64_t value)
size_t bitSizeOfVarInt(int64_t value)
size_t bitSizeOfBytes(Span< const uint8_t > bytesValue)
typename IBasicReflectable< ALLOC >::Ptr IBasicReflectablePtr
size_t bitSizeOf(T value)
size_t bitSizeOfVarUInt16(uint16_t value)
typename IBasicReflectable< ALLOC >::ConstPtr IBasicReflectableConstPtr
static bool isCompound(SchemaType schemaType)