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())
1844 return object.getField(name);
1850 template <
typename ALLOC>
1851 IBasicReflectablePtr<ALLOC> getFieldFromObject(IBasicReflectable<ALLOC>&
object,
StringView name)
1853 const auto& typeInfo =
object.getTypeInfo();
1856 const auto& fields = typeInfo.getFields();
1857 auto fieldsIt = std::find_if(fields.begin(), fields.end(),
1858 [name](
const BasicFieldInfo<ALLOC>& fieldInfo) { return fieldInfo.schemaName == name; });
1859 if (fieldsIt != fields.end())
1860 return object.getField(name);
1866 template <
typename ALLOC>
1867 IBasicReflectableConstPtr<ALLOC> getParameterFromObject(
const IBasicReflectable<ALLOC>&
object,
StringView name)
1869 const auto& typeInfo =
object.getTypeInfo();
1872 const auto& parameters = typeInfo.getParameters();
1873 auto parametersIt = std::find_if(
1874 parameters.begin(), parameters.end(), [name](
const BasicParameterInfo<ALLOC>& parameterInfo) {
1875 return parameterInfo.schemaName == name;
1877 if (parametersIt != parameters.end())
1878 return object.getParameter(name);
1884 template <
typename ALLOC>
1885 IBasicReflectablePtr<ALLOC> getParameterFromObject(IBasicReflectable<ALLOC>&
object,
StringView name)
1887 const auto& typeInfo =
object.getTypeInfo();
1890 const auto& parameters = typeInfo.getParameters();
1891 auto parametersIt = std::find_if(
1892 parameters.begin(), parameters.end(), [name](
const BasicParameterInfo<ALLOC>& parameterInfo) {
1893 return parameterInfo.schemaName == name;
1895 if (parametersIt != parameters.end())
1896 return object.getParameter(name);
1902 template <
typename ALLOC>
1903 IBasicReflectableConstPtr<ALLOC> callFunctionInObject(
const IBasicReflectable<ALLOC>&
object,
StringView name)
1905 const auto& typeInfo =
object.getTypeInfo();
1908 const auto& functions = typeInfo.getFunctions();
1909 auto functionsIt = std::find_if(
1910 functions.begin(), functions.end(), [name](
const BasicFunctionInfo<ALLOC>& functionInfo) {
1911 return functionInfo.schemaName == name;
1913 if (functionsIt != functions.end())
1914 return object.callFunction(name);
1920 template <
typename ALLOC>
1921 IBasicReflectablePtr<ALLOC> callFunctionInObject(IBasicReflectable<ALLOC>&
object,
StringView name)
1923 const auto& typeInfo =
object.getTypeInfo();
1926 const auto& functions = typeInfo.getFunctions();
1927 auto functionsIt = std::find_if(
1928 functions.begin(), functions.end(), [name](
const BasicFunctionInfo<ALLOC>& functionInfo) {
1929 return functionInfo.schemaName == name;
1931 if (functionsIt != functions.end())
1932 return object.callFunction(name);
1938 template <
typename ALLOC>
1939 IBasicReflectableConstPtr<ALLOC> getFromObject(
1940 const IBasicReflectable<ALLOC>&
object,
StringView path,
size_t pos)
1944 const size_t dotPos = path.find(
'.', pos);
1948 auto field = getFieldFromObject(
object, name);
1950 return isLast ? field : getFromObject(*field, path, dotPos + 1);
1952 auto parameter = getParameterFromObject(
object, name);
1954 return isLast ? parameter : getFromObject(*parameter, path, dotPos + 1);
1956 auto functionResult = callFunctionInObject(
object, name);
1958 return isLast ? functionResult : getFromObject(*functionResult, path, dotPos + 1);
1960 catch (
const CppRuntimeException&)
1966 template <
typename ALLOC>
1967 IBasicReflectablePtr<ALLOC> getFromObject(IBasicReflectable<ALLOC>&
object,
StringView path,
size_t pos)
1971 const size_t dotPos = path.find(
'.', pos);
1975 auto field = getFieldFromObject(
object, name);
1977 return isLast ? field : getFromObject(*field, path, dotPos + 1);
1979 auto parameter = getParameterFromObject(
object, name);
1981 return isLast ? parameter : getFromObject(*parameter, path, dotPos + 1);
1983 auto functionResult = callFunctionInObject(
object, name);
1985 return isLast ? functionResult : getFromObject(*functionResult, path, dotPos + 1);
1987 catch (
const CppRuntimeException&)
1998 template <
typename ALLOC>
2013 template <
typename ALLOC>
2040 template <
typename ALLOC>
2058 size_t bitSizeOf(
size_t bitPosition)
const override;
2075 bool getBool()
const override;
2076 int8_t
getInt8()
const override;
2090 int64_t
toInt()
const override;
2091 uint64_t
toUInt()
const override;
2101 template <
typename ALLOC>
2111 void resize(
size_t index)
override;
2124 template <
typename ALLOC,
typename RAW_ARRAY,
typename ELEMENT_REFLECTABLE>
2130 using ElementReflectable = ELEMENT_REFLECTABLE;
2135 using Base::operator[];
2139 Base(ElementReflectable::typeInfo(), allocator),
2140 m_rawArray(rawArray)
2145 return m_rawArray.size();
2150 if (index >=
size())
2154 <<
"' of size " <<
size() <<
"!";
2157 return std::allocate_shared<ElementReflectable>(
Base::get_allocator(), m_rawArray[index]);
2166 const RAW_ARRAY& m_rawArray;
2169 template <
typename ALLOC,
typename RAW_ARRAY,
typename ELEMENT_REFLECTABLE>
2175 using ElementReflectable = ELEMENT_REFLECTABLE;
2181 Base(ElementReflectable::typeInfo(), allocator),
2182 m_rawArray(rawArray)
2187 return m_rawArray.size();
2192 m_rawArray.resize(
size);
2197 if (index >=
size())
2201 <<
"' of size " <<
size() <<
"!";
2204 return std::allocate_shared<ElementReflectable>(
Base::get_allocator(), m_rawArray[index]);
2209 if (index >=
size())
2213 <<
"' of size " <<
size() <<
"!";
2216 return std::allocate_shared<ElementReflectable>(
Base::get_allocator(), m_rawArray[index]);
2221 if (index >=
size())
2225 <<
"' of size " <<
size() <<
"!";
2228 m_rawArray[index] = value.template get<typename RAW_ARRAY::value_type>();
2233 m_rawArray.push_back(value.template get<typename RAW_ARRAY::value_type>());
2247 RAW_ARRAY& m_rawArray;
2255 template <
typename ALLOC,
typename RAW_ARRAY,
typename ELEMENT_REFLECTABLE>
2261 using ElementReflectable = ELEMENT_REFLECTABLE;
2266 using Base::operator[];
2270 Base(ElementReflectable::typeInfo(bitSize), allocator),
2271 m_rawArray(rawArray)
2276 return m_rawArray.size();
2281 if (index >=
size())
2285 <<
"' of size " <<
size() <<
"!";
2288 return std::allocate_shared<ElementReflectable>(
2298 const RAW_ARRAY& m_rawArray;
2301 template <
typename ALLOC,
typename RAW_ARRAY,
typename ELEMENT_REFLECTABLE>
2307 using ElementReflectable = ELEMENT_REFLECTABLE;
2313 Base(ElementReflectable::typeInfo(bitSize), allocator),
2314 m_rawArray(rawArray)
2319 return m_rawArray.size();
2324 m_rawArray.resize(
size);
2329 if (index >=
size())
2333 <<
"' of size " <<
size() <<
"!";
2336 return std::allocate_shared<ElementReflectable>(
2342 if (index >=
size())
2346 <<
"' of size " <<
size() <<
"!";
2349 return std::allocate_shared<ElementReflectable>(
2355 if (index >=
size())
2359 <<
"' of size " <<
size() <<
"!";
2362 m_rawArray[index] = value.template get<typename RAW_ARRAY::value_type>();
2367 m_rawArray.push_back(value.template get<typename RAW_ARRAY::value_type>());
2381 RAW_ARRAY& m_rawArray;
2389 template <
typename ALLOC,
typename RAW_ARRAY,
typename ELEMENT_REFLECTABLE>
2395 using ElementReflectable = ELEMENT_REFLECTABLE;
2400 using Base::operator[];
2404 const ALLOC& allocator,
const RAW_ARRAY& rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize) :
2405 Base(ElementReflectable::typeInfo(maxBitSize), allocator),
2406 m_rawArray(rawArray),
2407 m_maxBitSize(maxBitSize),
2408 m_dynamicBitSize(dynamicBitSize)
2413 return m_rawArray.size();
2418 if (index >=
size())
2422 <<
"' of size " <<
size() <<
"!";
2425 return std::allocate_shared<ElementReflectable>(
2435 const RAW_ARRAY& m_rawArray;
2436 const uint8_t m_maxBitSize;
2437 const uint8_t m_dynamicBitSize;
2440 template <
typename ALLOC,
typename RAW_ARRAY,
typename ELEMENT_REFLECTABLE>
2446 using ElementReflectable = ELEMENT_REFLECTABLE;
2452 const ALLOC& allocator, RAW_ARRAY& rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize) :
2453 Base(ElementReflectable::typeInfo(maxBitSize), allocator),
2454 m_rawArray(rawArray),
2455 m_maxBitSize(maxBitSize),
2456 m_dynamicBitSize(dynamicBitSize)
2461 return m_rawArray.size();
2466 m_rawArray.resize(
size);
2471 if (index >=
size())
2475 <<
"' of size " <<
size() <<
"!";
2478 return std::allocate_shared<ElementReflectable>(
2484 if (index >=
size())
2488 <<
"' of size " <<
size() <<
"!";
2491 return std::allocate_shared<ElementReflectable>(
2497 if (index >=
size())
2501 <<
"' of size " <<
size() <<
"!";
2504 m_rawArray[index] = value.template get<typename RAW_ARRAY::value_type>();
2509 m_rawArray.push_back(value.template get<typename RAW_ARRAY::value_type>());
2523 RAW_ARRAY& m_rawArray;
2524 const uint8_t m_maxBitSize;
2525 const uint8_t m_dynamicBitSize;
2533 template <
typename ALLOC,
typename RAW_ARRAY>
2535 template <
typename ALLOC,
typename RAW_ARRAY>
2538 template <
typename ALLOC,
typename RAW_ARRAY>
2540 template <
typename ALLOC,
typename RAW_ARRAY>
2543 template <
typename ALLOC,
typename RAW_ARRAY>
2545 template <
typename ALLOC,
typename RAW_ARRAY>
2548 template <
typename ALLOC,
typename RAW_ARRAY>
2550 template <
typename ALLOC,
typename RAW_ARRAY>
2553 template <
typename ALLOC,
typename RAW_ARRAY>
2555 template <
typename ALLOC,
typename RAW_ARRAY>
2558 template <
typename ALLOC,
typename RAW_ARRAY>
2560 template <
typename ALLOC,
typename RAW_ARRAY>
2563 template <
typename ALLOC,
typename RAW_ARRAY>
2565 template <
typename ALLOC,
typename RAW_ARRAY>
2568 template <
typename ALLOC,
typename RAW_ARRAY>
2570 template <
typename ALLOC,
typename RAW_ARRAY>
2573 template <
typename ALLOC,
typename RAW_ARRAY>
2575 template <
typename ALLOC,
typename RAW_ARRAY>
2578 template <
typename ALLOC,
typename RAW_ARRAY>
2581 template <
typename ALLOC,
typename RAW_ARRAY>
2585 template <
typename ALLOC,
typename RAW_ARRAY>
2588 template <
typename ALLOC,
typename RAW_ARRAY>
2592 template <
typename ALLOC,
typename RAW_ARRAY>
2595 template <
typename ALLOC,
typename RAW_ARRAY>
2599 template <
typename ALLOC,
typename RAW_ARRAY>
2602 template <
typename ALLOC,
typename RAW_ARRAY>
2606 template <
typename ALLOC,
typename RAW_ARRAY>
2609 template <
typename ALLOC,
typename RAW_ARRAY>
2612 template <
typename ALLOC,
typename RAW_ARRAY>
2615 template <
typename ALLOC,
typename RAW_ARRAY>
2618 template <
typename ALLOC,
typename RAW_ARRAY>
2621 template <
typename ALLOC,
typename RAW_ARRAY>
2624 template <
typename ALLOC,
typename RAW_ARRAY>
2626 template <
typename ALLOC,
typename RAW_ARRAY>
2629 template <
typename ALLOC,
typename RAW_ARRAY>
2632 template <
typename ALLOC,
typename RAW_ARRAY>
2635 template <
typename ALLOC,
typename RAW_ARRAY>
2638 template <
typename ALLOC,
typename RAW_ARRAY>
2641 template <
typename ALLOC,
typename RAW_ARRAY>
2644 template <
typename ALLOC,
typename RAW_ARRAY>
2647 template <
typename ALLOC,
typename RAW_ARRAY>
2649 template <
typename ALLOC,
typename RAW_ARRAY>
2652 template <
typename ALLOC,
typename RAW_ARRAY>
2654 template <
typename ALLOC,
typename RAW_ARRAY>
2657 template <
typename ALLOC,
typename RAW_ARRAY>
2659 template <
typename ALLOC,
typename RAW_ARRAY>
2662 template <
typename ALLOC,
typename RAW_ARRAY>
2664 template <
typename ALLOC,
typename RAW_ARRAY>
2667 template <
typename ALLOC,
typename RAW_ARRAY>
2669 template <
typename ALLOC,
typename RAW_ARRAY>
2672 template <
typename ALLOC,
typename RAW_ARRAY>
2674 template <
typename ALLOC,
typename RAW_ARRAY>
2677 template <
typename ALLOC,
typename RAW_ARRAY>
2679 template <
typename ALLOC,
typename RAW_ARRAY>
2682 template <
typename ALLOC,
typename RAW_ARRAY>
2685 template <
typename ALLOC,
typename RAW_ARRAY>
2693 template <
typename ALLOC,
typename RAW_ARRAY>
2699 using ElementType =
typename RAW_ARRAY::value_type;
2704 using Base::operator[];
2708 Base(ElementType::typeInfo(), allocator),
2709 m_rawArray(rawArray)
2714 return m_rawArray.size();
2719 if (index >=
size())
2723 <<
"' of size " <<
size() <<
"!";
2735 const RAW_ARRAY& m_rawArray;
2738 template <
typename ALLOC,
typename RAW_ARRAY>
2744 using ElementType =
typename RAW_ARRAY::value_type;
2750 Base(ElementType::typeInfo(), allocator),
2751 m_rawArray(rawArray)
2756 return m_rawArray.size();
2761 m_rawArray.resize(
size);
2766 if (index >=
size())
2770 <<
"' of size " <<
size() <<
"!";
2778 if (index >=
size())
2782 <<
"' of size " <<
size() <<
"!";
2790 if (index >=
size())
2794 <<
"' of size " <<
size() <<
"!";
2797 m_rawArray[index] = value.template get<typename RAW_ARRAY::value_type>();
2802 m_rawArray.push_back(value.template get<typename RAW_ARRAY::value_type>());
2816 RAW_ARRAY& m_rawArray;
2822 template <
typename ALLOC,
typename RAW_ARRAY>
2828 using ElementType =
typename RAW_ARRAY::value_type;
2833 using Base::operator[];
2837 Base(ElementType::typeInfo(), allocator),
2838 m_rawArray(rawArray)
2843 return m_rawArray.size();
2848 if (index >=
size())
2852 <<
"' of size " <<
size() <<
"!";
2864 const RAW_ARRAY& m_rawArray;
2867 template <
typename ALLOC,
typename RAW_ARRAY>
2873 using ElementType =
typename RAW_ARRAY::value_type;
2874 using UnderlyingElementType =
typename ElementType::underlying_type;
2880 Base(ElementType::typeInfo(), allocator),
2881 m_rawArray(rawArray)
2886 return m_rawArray.size();
2891 m_rawArray.resize(
size);
2896 if (index >=
size())
2900 <<
"' of size " <<
size() <<
"!";
2908 if (index >=
size())
2912 <<
"' of size " <<
size() <<
"!";
2920 if (index >=
size())
2924 <<
"' of size " <<
size() <<
"!";
2927 if (value.template isType<ElementType>())
2928 m_rawArray[index] = value.template get<ElementType>();
2930 m_rawArray[index] = ElementType(value.template get<UnderlyingElementType>());
2935 if (value.template isType<ElementType>())
2936 m_rawArray.push_back(value.template get<ElementType>());
2938 m_rawArray.push_back(ElementType(value.template get<UnderlyingElementType>()));
2952 RAW_ARRAY& m_rawArray;
2958 template <
typename ALLOC,
typename RAW_ARRAY>
2964 using ElementType =
typename RAW_ARRAY::value_type;
2969 using Base::operator[];
2974 m_rawArray(rawArray)
2979 return m_rawArray.size();
2984 if (index >=
size())
2988 <<
"' of size " <<
size() <<
"!";
3000 const RAW_ARRAY& m_rawArray;
3003 template <
typename ALLOC,
typename RAW_ARRAY>
3009 using ElementType =
typename RAW_ARRAY::value_type;
3010 using UnderlyingElementType =
typename std::underlying_type<ElementType>::type;
3017 m_rawArray(rawArray)
3022 return m_rawArray.size();
3027 m_rawArray.resize(
size);
3032 if (index >=
size())
3036 <<
"' of size " <<
size() <<
"!";
3044 if (index >=
size())
3048 <<
"' of size " <<
size() <<
"!";
3056 if (index >=
size())
3060 <<
"' of size " <<
size() <<
"!";
3063 if (value.template isType<ElementType>())
3064 m_rawArray[index] = value.template get<ElementType>();
3066 m_rawArray[index] = valueToEnum<ElementType>(value.template get<UnderlyingElementType>());
3071 if (value.template isType<ElementType>())
3072 m_rawArray.push_back(value.template get<ElementType>());
3074 m_rawArray.push_back(valueToEnum<ElementType>(value.template get<UnderlyingElementType>()));
3088 RAW_ARRAY& m_rawArray;
3097 template <
typename T,
typename ALLOC =
typename T::allocator_type>
3106 m_object(allocator),
3107 m_reflectable(m_object.reflectable(allocator))
3112 return m_reflectable->getTypeInfo();
3117 return m_reflectable->isArray();
3122 m_reflectable->initializeChildren();
3127 m_reflectable->initialize(typeArguments);
3132 return m_reflectable->initializeOffsets(bitPosition);
3142 return m_reflectable->bitSizeOf(bitPosition);
3152 m_reflectable->write(writer);
3157 return m_reflectable->getField(name);
3162 return m_reflectable->getField(name);
3167 return m_reflectable->createField(name);
3172 m_reflectable->setField(name, value);
3177 return m_reflectable->getParameter(name);
3182 return m_reflectable->getParameter(name);
3187 return m_reflectable->callFunction(name);
3192 return m_reflectable->callFunction(name);
3197 return m_reflectable->getChoice();
3202 return m_reflectable->find(path);
3207 return m_reflectable->find(path);
3212 return m_reflectable->operator[](path);
3217 return m_reflectable->operator[](path);
3222 return m_reflectable->size();
3227 m_reflectable->resize(
size);
3232 return m_reflectable->at(index);
3237 return m_reflectable->at(index);
3242 return m_reflectable->operator[](index);
3247 return m_reflectable->operator[](index);
3252 m_reflectable->setAt(value, index);
3257 m_reflectable->append(value);
3262 return m_reflectable->getAnyValue(allocator);
3267 return m_reflectable->getAnyValue(allocator);
3283 return m_reflectable->getBool();
3287 return m_reflectable->getInt8();
3291 return m_reflectable->getInt16();
3295 return m_reflectable->getInt32();
3299 return m_reflectable->getInt64();
3303 return m_reflectable->getUInt8();
3307 return m_reflectable->getUInt16();
3311 return m_reflectable->getUInt32();
3315 return m_reflectable->getUInt64();
3319 return m_reflectable->getFloat();
3323 return m_reflectable->getDouble();
3327 return m_reflectable->getBytes();
3331 return m_reflectable->getStringView();
3335 return m_reflectable->getBitBuffer();
3341 return m_reflectable->toInt();
3345 return m_reflectable->toUInt();
3349 return m_reflectable->toDouble();
3353 return m_reflectable->toString(allocator);
3370 template <
typename ALLOC>
3376 return std::allocate_shared<BoolReflectable<ALLOC>>(allocator, value);
3381 return std::allocate_shared<Int8Reflectable<ALLOC>>(allocator, value);
3386 return std::allocate_shared<Int16Reflectable<ALLOC>>(allocator, value);
3391 return std::allocate_shared<Int32Reflectable<ALLOC>>(allocator, value);
3396 return std::allocate_shared<Int64Reflectable<ALLOC>>(allocator, value);
3401 return std::allocate_shared<UInt8Reflectable<ALLOC>>(allocator, value);
3406 return std::allocate_shared<UInt16Reflectable<ALLOC>>(allocator, value);
3411 return std::allocate_shared<UInt32Reflectable<ALLOC>>(allocator, value);
3416 return std::allocate_shared<UInt64Reflectable<ALLOC>>(allocator, value);
3419 template <typename T, typename std::enable_if<std::is_signed<T>::value,
int>::type = 0>
3421 T value, uint8_t bitSize,
const ALLOC& allocator = ALLOC())
3423 return std::allocate_shared<FixedSignedBitFieldReflectable<ALLOC, T>>(allocator, value, bitSize);
3426 template <typename T, typename std::enable_if<std::is_unsigned<T>::value,
int>::type = 0>
3428 T value, uint8_t bitSize,
const ALLOC& allocator = ALLOC())
3430 return std::allocate_shared<FixedUnsignedBitFieldReflectable<ALLOC, T>>(allocator, value, bitSize);
3433 template <typename T, typename std::enable_if<std::is_signed<T>::value,
int>::type = 0>
3435 T value, uint8_t maxBitSize, uint8_t dynamicBitSize,
const ALLOC& allocator = ALLOC())
3437 return std::allocate_shared<DynamicSignedBitFieldReflectable<ALLOC, T>>(
3438 allocator, value, maxBitSize, dynamicBitSize);
3443 int64_t value, uint8_t maxBitSize,
const ALLOC& allocator = ALLOC())
3445 if (maxBitSize != 64)
3448 <<
"maxBitSize != 64 for referenced dynamic bit field!";
3454 template <typename T, typename std::enable_if<std::is_unsigned<T>::value,
int>::type = 0>
3456 T value, uint8_t maxBitSize, uint8_t dynamicBitSize,
const ALLOC& allocator = ALLOC())
3458 return std::allocate_shared<DynamicUnsignedBitFieldReflectable<ALLOC, T>>(
3459 allocator, value, maxBitSize, dynamicBitSize);
3464 uint64_t value, uint8_t maxBitSize,
const ALLOC& allocator = ALLOC())
3466 if (maxBitSize != 64)
3469 <<
"maxBitSize != 64 for referenced dynamic bit field!";
3477 return std::allocate_shared<VarInt16Reflectable<ALLOC>>(allocator, value);
3482 return std::allocate_shared<VarInt32Reflectable<ALLOC>>(allocator, value);
3487 return std::allocate_shared<VarInt64Reflectable<ALLOC>>(allocator, value);
3492 return std::allocate_shared<VarIntReflectable<ALLOC>>(allocator, value);
3497 return std::allocate_shared<VarUInt16Reflectable<ALLOC>>(allocator, value);
3502 return std::allocate_shared<VarUInt32Reflectable<ALLOC>>(allocator, value);
3507 return std::allocate_shared<VarUInt64Reflectable<ALLOC>>(allocator, value);
3512 return std::allocate_shared<VarUIntReflectable<ALLOC>>(allocator, value);
3517 return std::allocate_shared<VarSizeReflectable<ALLOC>>(allocator, value);
3522 return std::allocate_shared<Float16Reflectable<ALLOC>>(allocator, value);
3527 return std::allocate_shared<Float32Reflectable<ALLOC>>(allocator, value);
3532 return std::allocate_shared<Float64Reflectable<ALLOC>>(allocator, value);
3537 return std::allocate_shared<BytesReflectable<ALLOC>>(allocator, value);
3542 return std::allocate_shared<StringReflectable<ALLOC>>(allocator, value);
3548 return std::allocate_shared<BitBufferReflectable<ALLOC>>(allocator, value);
3551 template <
typename RAW_ARRAY>
3553 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3555 return std::allocate_shared<BoolReflectableConstArray<ALLOC, RAW_ARRAY>>(
3556 allocator, allocator, rawArray);
3559 template <
typename RAW_ARRAY>
3562 return std::allocate_shared<BoolReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3565 template <
typename RAW_ARRAY>
3567 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3569 return std::allocate_shared<Int8ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3570 allocator, allocator, rawArray);
3573 template <
typename RAW_ARRAY>
3576 return std::allocate_shared<Int8ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3579 template <
typename RAW_ARRAY>
3581 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3583 return std::allocate_shared<Int16ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3584 allocator, allocator, rawArray);
3587 template <
typename RAW_ARRAY>
3590 return std::allocate_shared<Int16ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3593 template <
typename RAW_ARRAY>
3595 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3597 return std::allocate_shared<Int32ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3598 allocator, allocator, rawArray);
3601 template <
typename RAW_ARRAY>
3604 return std::allocate_shared<Int32ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3607 template <
typename RAW_ARRAY>
3609 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3611 return std::allocate_shared<Int64ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3612 allocator, allocator, rawArray);
3615 template <
typename RAW_ARRAY>
3618 return std::allocate_shared<Int64ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3621 template <
typename RAW_ARRAY>
3623 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3625 return std::allocate_shared<UInt8ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3626 allocator, allocator, rawArray);
3629 template <
typename RAW_ARRAY>
3632 return std::allocate_shared<UInt8ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3635 template <
typename RAW_ARRAY>
3637 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3639 return std::allocate_shared<UInt16ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3640 allocator, allocator, rawArray);
3643 template <
typename RAW_ARRAY>
3646 return std::allocate_shared<UInt16ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3649 template <
typename RAW_ARRAY>
3651 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3653 return std::allocate_shared<UInt32ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3654 allocator, allocator, rawArray);
3657 template <
typename RAW_ARRAY>
3660 return std::allocate_shared<UInt32ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3663 template <
typename RAW_ARRAY>
3665 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3667 return std::allocate_shared<UInt64ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3668 allocator, allocator, rawArray);
3671 template <
typename RAW_ARRAY>
3674 return std::allocate_shared<UInt64ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3677 template <
typename RAW_ARRAY>
3679 const RAW_ARRAY& rawArray, uint8_t bitSize,
const ALLOC& allocator = ALLOC())
3681 return std::allocate_shared<FixedSignedBitFieldReflectableConstArray<ALLOC, RAW_ARRAY>>(
3682 allocator, allocator, rawArray, bitSize);
3685 template <
typename RAW_ARRAY>
3687 RAW_ARRAY& rawArray, uint8_t bitSize,
const ALLOC& allocator = ALLOC())
3689 return std::allocate_shared<FixedSignedBitFieldReflectableArray<ALLOC, RAW_ARRAY>>(
3690 allocator, allocator, rawArray, bitSize);
3693 template <
typename RAW_ARRAY>
3695 const RAW_ARRAY& rawArray, uint8_t bitSize,
const ALLOC& allocator = ALLOC())
3697 return std::allocate_shared<FixedUnsignedBitFieldReflectableConstArray<ALLOC, RAW_ARRAY>>(
3698 allocator, allocator, rawArray, bitSize);
3701 template <
typename RAW_ARRAY>
3703 RAW_ARRAY& rawArray, uint8_t bitSize,
const ALLOC& allocator = ALLOC())
3705 return std::allocate_shared<FixedUnsignedBitFieldReflectableArray<ALLOC, RAW_ARRAY>>(
3706 allocator, allocator, rawArray, bitSize);
3709 template <
typename RAW_ARRAY>
3711 uint8_t maxBitSize, uint8_t dynamicBitSize,
const ALLOC& allocator = ALLOC())
3713 return std::allocate_shared<DynamicSignedBitFieldReflectableConstArray<ALLOC, RAW_ARRAY>>(
3714 allocator, allocator, rawArray, maxBitSize, dynamicBitSize);
3717 template <
typename RAW_ARRAY>
3719 RAW_ARRAY& rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize,
const ALLOC& allocator = ALLOC())
3721 return std::allocate_shared<DynamicSignedBitFieldReflectableArray<ALLOC, RAW_ARRAY>>(
3722 allocator, allocator, rawArray, maxBitSize, dynamicBitSize);
3725 template <
typename RAW_ARRAY>
3727 uint8_t maxBitSize, uint8_t dynamicBitSize,
const ALLOC& allocator = ALLOC())
3729 return std::allocate_shared<DynamicUnsignedBitFieldReflectableConstArray<ALLOC, RAW_ARRAY>>(
3730 allocator, allocator, rawArray, maxBitSize, dynamicBitSize);
3733 template <
typename RAW_ARRAY>
3735 RAW_ARRAY& rawArray, uint8_t maxBitSize, uint8_t dynamicBitSize,
const ALLOC& allocator = ALLOC())
3737 return std::allocate_shared<DynamicUnsignedBitFieldReflectableArray<ALLOC, RAW_ARRAY>>(
3738 allocator, allocator, rawArray, maxBitSize, dynamicBitSize);
3741 template <
typename RAW_ARRAY>
3743 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3745 return std::allocate_shared<VarInt16ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3746 allocator, allocator, rawArray);
3749 template <
typename RAW_ARRAY>
3752 return std::allocate_shared<VarInt16ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3755 template <
typename RAW_ARRAY>
3757 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3759 return std::allocate_shared<VarInt32ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3760 allocator, allocator, rawArray);
3763 template <
typename RAW_ARRAY>
3766 return std::allocate_shared<VarInt32ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3769 template <
typename RAW_ARRAY>
3771 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3773 return std::allocate_shared<VarInt64ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3774 allocator, allocator, rawArray);
3777 template <
typename RAW_ARRAY>
3780 return std::allocate_shared<VarInt64ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3783 template <
typename RAW_ARRAY>
3785 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3787 return std::allocate_shared<VarIntReflectableConstArray<ALLOC, RAW_ARRAY>>(
3788 allocator, allocator, rawArray);
3791 template <
typename RAW_ARRAY>
3794 return std::allocate_shared<VarIntReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3797 template <
typename RAW_ARRAY>
3799 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3801 return std::allocate_shared<VarUInt16ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3802 allocator, allocator, rawArray);
3805 template <
typename RAW_ARRAY>
3808 return std::allocate_shared<VarUInt16ReflectableArray<ALLOC, RAW_ARRAY>>(
3809 allocator, allocator, rawArray);
3812 template <
typename RAW_ARRAY>
3814 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3816 return std::allocate_shared<VarUInt32ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3817 allocator, allocator, rawArray);
3820 template <
typename RAW_ARRAY>
3823 return std::allocate_shared<VarUInt32ReflectableArray<ALLOC, RAW_ARRAY>>(
3824 allocator, allocator, rawArray);
3827 template <
typename RAW_ARRAY>
3829 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3831 return std::allocate_shared<VarUInt64ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3832 allocator, allocator, rawArray);
3835 template <
typename RAW_ARRAY>
3838 return std::allocate_shared<VarUInt64ReflectableArray<ALLOC, RAW_ARRAY>>(
3839 allocator, allocator, rawArray);
3842 template <
typename RAW_ARRAY>
3844 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3846 return std::allocate_shared<VarUIntReflectableConstArray<ALLOC, RAW_ARRAY>>(
3847 allocator, allocator, rawArray);
3850 template <
typename RAW_ARRAY>
3853 return std::allocate_shared<VarUIntReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3856 template <
typename RAW_ARRAY>
3858 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3860 return std::allocate_shared<VarSizeReflectableConstArray<ALLOC, RAW_ARRAY>>(
3861 allocator, allocator, rawArray);
3864 template <
typename RAW_ARRAY>
3867 return std::allocate_shared<VarSizeReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3870 template <
typename RAW_ARRAY>
3872 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3874 return std::allocate_shared<Float16ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3875 allocator, allocator, rawArray);
3878 template <
typename RAW_ARRAY>
3881 return std::allocate_shared<Float16ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3884 template <
typename RAW_ARRAY>
3886 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3888 return std::allocate_shared<Float32ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3889 allocator, allocator, rawArray);
3892 template <
typename RAW_ARRAY>
3895 return std::allocate_shared<Float32ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3898 template <
typename RAW_ARRAY>
3900 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3902 return std::allocate_shared<Float64ReflectableConstArray<ALLOC, RAW_ARRAY>>(
3903 allocator, allocator, rawArray);
3906 template <
typename RAW_ARRAY>
3909 return std::allocate_shared<Float64ReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3912 template <
typename RAW_ARRAY>
3914 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3916 return std::allocate_shared<BytesReflectableConstArray<ALLOC, RAW_ARRAY>>(
3917 allocator, allocator, rawArray);
3920 template <
typename RAW_ARRAY>
3923 return std::allocate_shared<BytesReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3926 template <
typename RAW_ARRAY>
3928 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3930 return std::allocate_shared<StringReflectableConstArray<ALLOC, RAW_ARRAY>>(
3931 allocator, allocator, rawArray);
3934 template <
typename RAW_ARRAY>
3937 return std::allocate_shared<StringReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3940 template <
typename RAW_ARRAY>
3942 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3944 return std::allocate_shared<BitBufferReflectableConstArray<ALLOC, RAW_ARRAY>>(
3945 allocator, allocator, rawArray);
3948 template <
typename RAW_ARRAY>
3951 return std::allocate_shared<BitBufferReflectableArray<ALLOC, RAW_ARRAY>>(
3952 allocator, allocator, rawArray);
3955 template <
typename RAW_ARRAY>
3957 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3959 return std::allocate_shared<CompoundReflectableConstArray<ALLOC, RAW_ARRAY>>(
3960 allocator, allocator, rawArray);
3963 template <
typename RAW_ARRAY>
3966 return std::allocate_shared<CompoundReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3969 template <
typename RAW_ARRAY>
3971 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3973 return std::allocate_shared<BitmaskReflectableConstArray<ALLOC, RAW_ARRAY>>(
3974 allocator, allocator, rawArray);
3977 template <
typename RAW_ARRAY>
3980 return std::allocate_shared<BitmaskReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
3983 template <
typename RAW_ARRAY>
3985 const RAW_ARRAY& rawArray,
const ALLOC& allocator = ALLOC())
3987 return std::allocate_shared<EnumReflectableConstArray<ALLOC, RAW_ARRAY>>(
3988 allocator, allocator, rawArray);
3991 template <
typename RAW_ARRAY>
3994 return std::allocate_shared<EnumReflectableArray<ALLOC, RAW_ARRAY>>(allocator, allocator, rawArray);
4001 template <
typename ALLOC>
4003 m_typeInfo(typeInfo)
4006 template <
typename ALLOC>
4009 template <
typename ALLOC>
4015 template <
typename ALLOC>
4021 template <
typename ALLOC>
4024 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not a compound type!";
4027 template <
typename ALLOC>
4030 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no type arguments!";
4033 template <
typename ALLOC>
4036 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not a compound type!";
4039 template <
typename ALLOC>
4045 template <
typename ALLOC>
4048 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not implemented!";
4051 template <
typename ALLOC>
4057 template <
typename ALLOC>
4060 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not implemented!";
4063 template <
typename ALLOC>
4066 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no fields to get!";
4069 template <
typename ALLOC>
4072 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no fields to get!";
4075 template <
typename ALLOC>
4078 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no fields to create!";
4081 template <
typename ALLOC>
4084 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no fields to set!";
4087 template <
typename ALLOC>
4090 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no parameters to get!";
4093 template <
typename ALLOC>
4096 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no parameters to get!";
4099 template <
typename ALLOC>
4102 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no functions to call!";
4105 template <
typename ALLOC>
4108 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' has no functions to call!";
4111 template <
typename ALLOC>
4114 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is neither choice nor union!";
4117 template <
typename ALLOC>
4120 return detail::getFromObject(*
this, path, 0);
4123 template <
typename ALLOC>
4126 return detail::getFromObject(*
this, path, 0);
4129 template <
typename ALLOC>
4135 template <
typename ALLOC>
4141 template <
typename ALLOC>
4144 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4147 template <
typename ALLOC>
4150 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4153 template <
typename ALLOC>
4156 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4159 template <
typename ALLOC>
4162 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4165 template <
typename ALLOC>
4168 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4171 template <
typename ALLOC>
4174 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4177 template <
typename ALLOC>
4180 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4183 template <
typename ALLOC>
4186 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not an array!";
4189 template <
typename ALLOC>
4192 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not implemented!";
4195 template <
typename ALLOC>
4198 throw CppRuntimeException(
"Type '") << getTypeInfo().getSchemaName() <<
"' is not implemented!";
4201 template <
typename ALLOC>
4204 return getAnyValue(ALLOC());
4207 template <
typename ALLOC>
4210 return getAnyValue(ALLOC());
4213 template <
typename ALLOC>
4216 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not boolean type!";
4219 template <
typename ALLOC>
4225 template <
typename ALLOC>
4228 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not int16 type!";
4231 template <
typename ALLOC>
4234 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not int32 type!";
4237 template <
typename ALLOC>
4240 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not int64 type!";
4243 template <
typename ALLOC>
4246 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not uint8 type!";
4249 template <
typename ALLOC>
4252 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not uint16 type!";
4255 template <
typename ALLOC>
4258 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not uint32 type!";
4261 template <
typename ALLOC>
4264 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not uint64 type!";
4267 template <
typename ALLOC>
4270 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not float type!";
4273 template <
typename ALLOC>
4276 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not double type!";
4279 template <
typename ALLOC>
4282 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not bytes type!";
4285 template <
typename ALLOC>
4288 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not string type!";
4291 template <
typename ALLOC>
4294 throw CppRuntimeException(
"'") << getTypeInfo().getSchemaName() <<
"' is not an extern type!";
4297 template <
typename ALLOC>
4301 << getTypeInfo().getSchemaName() <<
"' to signed integer is not available!";
4304 template <
typename ALLOC>
4308 << getTypeInfo().getSchemaName() <<
"' to unsigned integer is not available!";
4311 template <
typename ALLOC>
4315 << getTypeInfo().getSchemaName() <<
"' to double is not available!";
4318 template <
typename ALLOC>
4322 << getTypeInfo().getSchemaName() <<
"' to string is not available!";
4325 template <
typename ALLOC>
4331 template <
typename ALLOC>
4334 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4337 template <
typename ALLOC>
4340 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4343 template <
typename ALLOC>
4346 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4349 template <
typename ALLOC>
4352 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4355 template <
typename ALLOC>
4358 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4361 template <
typename ALLOC>
4364 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4367 template <
typename ALLOC>
4370 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4373 template <
typename ALLOC>
4376 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is constant!";
4379 template <
typename ALLOC>
4382 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4385 template <
typename ALLOC>
4388 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4391 template <
typename ALLOC>
4394 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4397 template <
typename ALLOC>
4400 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4403 template <
typename ALLOC>
4406 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4409 template <
typename ALLOC>
4412 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4415 template <
typename ALLOC>
4418 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4421 template <
typename ALLOC>
4424 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4427 template <
typename ALLOC>
4430 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4433 template <
typename ALLOC>
4436 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4439 template <
typename ALLOC>
4442 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4445 template <
typename ALLOC>
4448 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4451 template <
typename ALLOC>
4454 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4457 template <
typename ALLOC>
4460 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4463 template <
typename ALLOC>
4466 return this->at(index);
4469 template <
typename ALLOC>
4472 return this->at(index);
4475 template <
typename ALLOC>
4478 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4481 template <
typename ALLOC>
4484 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4487 template <
typename ALLOC>
4490 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4493 template <
typename ALLOC>
4496 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4499 template <
typename ALLOC>
4502 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4505 template <
typename ALLOC>
4508 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4511 template <
typename ALLOC>
4514 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4517 template <
typename ALLOC>
4520 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4523 template <
typename ALLOC>
4526 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4529 template <
typename ALLOC>
4532 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4535 template <
typename ALLOC>
4538 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4541 template <
typename ALLOC>
4544 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4547 template <
typename ALLOC>
4550 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4553 template <
typename ALLOC>
4556 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4559 template <
typename ALLOC>
4562 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4565 template <
typename ALLOC>
4568 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4571 template <
typename ALLOC>
4574 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4577 template <
typename ALLOC>
4580 throw CppRuntimeException(
"Reflectable is an array '") << getTypeInfo().getSchemaName() <<
"[]'!";
4583 template <
typename ALLOC>
4586 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is a constant array!";
4589 template <
typename ALLOC>
4592 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is a constant array!";
4595 template <
typename ALLOC>
4598 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is a constant array!";
4601 template <
typename ALLOC>
4604 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is a constant array!";
4607 template <
typename ALLOC>
4610 throw CppRuntimeException(
"Reflectable '") << getTypeInfo().getSchemaName() <<
"' is a constant array!";
4613 template <
typename ALLOC>
4616 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)