61 # pragma warning(push)
62 # pragma warning(disable : 4251) // "X needs to have dll-interface to be used by clients of class Y."
71 static constexpr
size_t version{ 1 };
84 FrameInfo(
const FrameInfo &other);
87 FrameInfo &operator=(
const FrameInfo &other);
90 FrameInfo(FrameInfo &&other) noexcept;
93 FrameInfo &operator=(FrameInfo &&other) noexcept;
96 FrameInfo() =
default;
99 static constexpr
bool isContainer{
true };
102 static constexpr
const char *path{
"" };
105 static constexpr
const char *name{
"FrameInfo" };
108 static constexpr
const char *description{ R
"description(Various information for a frame)description" };
111 void set(
const std::string &fullPath,
const std::string &value);
114 std::string getString(
const std::string &fullPath)
const;
121 SoftwareVersion() =
default;
124 static constexpr
bool isContainer{
true };
127 static constexpr
const char *path{
"SoftwareVersion" };
130 static constexpr
const char *name{
"SoftwareVersion" };
133 static constexpr
const char *description{
134 R
"description(The version information for installed software at the time of image capture)description"
138 void set(
const std::string &fullPath,
const std::string &value);
141 std::string getString(
const std::string &fullPath)
const;
148 ZividAPI() =
default;
151 static constexpr
bool isContainer{
true };
154 static constexpr
const char *path{
"SoftwareVersion/ZividAPI" };
157 static constexpr
const char *name{
"ZividAPI" };
160 static constexpr
const char *description{
161 R
"description(Version information for the Zivid API library)description"
165 void set(
const std::string &fullPath,
const std::string &value);
168 std::string getString(
const std::string &fullPath)
const;
175 using ValueType = std::string;
178 static constexpr
bool isContainer{
false };
181 static constexpr
const char *path{
"SoftwareVersion/ZividAPI/Comments" };
184 static constexpr
const char *name{
"Comments" };
187 static constexpr
const char *description{ R
"description(Comments)description" };
190 Comments() = default;
193 explicit Comments(ValueType value) noexcept(std::is_nothrow_move_constructible<ValueType>::value)
194 : m_value{ std::move(value) }
198 const ValueType &value()
const
204 void setFromString(
const std::string &value)
216 bool operator==(
const Comments &other)
const
218 return m_value == other.m_value;
222 bool operator!=(
const Comments &other)
const
224 return m_value != other.m_value;
228 bool operator<(
const Comments &other)
const
230 return m_value < other.m_value;
234 bool operator>(
const Comments &other)
const
236 return m_value > other.m_value;
240 friend std::ostream &
operator<<(std::ostream &stream,
const Comments &value)
242 return stream << value.toString();
246 friend std::istream &operator>>(std::istream &stream, Comments &value)
249 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
265 static constexpr
bool isContainer{
false };
268 static constexpr
const char *path{
"SoftwareVersion/ZividAPI/FileDescription" };
271 static constexpr
const char *name{
"FileDescription" };
274 static constexpr
const char *description{ R
"description(File description)description" };
281 std::is_nothrow_move_constructible<ValueType>::value)
282 : m_value{ std::move(value) }
286 const ValueType &value()
const
292 void setFromString(
const std::string &value)
306 return m_value == other.m_value;
312 return m_value != other.m_value;
318 return m_value < other.m_value;
324 return m_value > other.m_value;
334 friend std::istream &operator>>(std::istream &stream, FileDescription &value)
337 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
353 static constexpr
bool isContainer{
false };
356 static constexpr
const char *path{
"SoftwareVersion/ZividAPI/FileVersion" };
359 static constexpr
const char *name{
"FileVersion" };
362 static constexpr
const char *description{ R
"description(File version)description" };
368 explicit FileVersion(
ValueType value) noexcept(std::is_nothrow_move_constructible<ValueType>::value)
369 : m_value{ std::move(value) }
379 void setFromString(
const std::string &value)
393 return m_value == other.m_value;
399 return m_value != other.m_value;
405 return m_value < other.m_value;
411 return m_value > other.m_value;
421 friend std::istream &operator>>(std::istream &stream,
FileVersion &value)
424 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
440 static constexpr
bool isContainer{
false };
443 static constexpr
const char *path{
"SoftwareVersion/ZividAPI/ProductVersion" };
446 static constexpr
const char *name{
"ProductVersion" };
449 static constexpr
const char *description{ R
"description(Product version)description" };
456 std::is_nothrow_move_constructible<ValueType>::value)
457 : m_value{ std::move(value) }
461 const ValueType &value()
const
467 void setFromString(
const std::string &value)
481 return m_value == other.m_value;
487 return m_value != other.m_value;
493 return m_value < other.m_value;
499 return m_value > other.m_value;
509 friend std::istream &operator>>(std::istream &stream, ProductVersion &value)
512 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
521 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI::Comments>::value,
529 typename std::enable_if<
530 std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI::FileDescription>::value,
534 return m_fileDescription;
539 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI::FileVersion>::value,
543 return m_fileVersion;
547 typename std::enable_if<
548 std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI::ProductVersion>::value,
552 return m_productVersion;
555 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
561 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
564 return m_fileDescription;
567 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
570 return m_fileVersion;
573 template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
576 return m_productVersion;
606 ZividAPI &set(
const FileDescription &value)
608 m_fileDescription = value;
612 const FileDescription &fileDescription()
const
614 return m_fileDescription;
618 FileVersion m_fileVersion{};
624 m_fileVersion = value;
628 const FileVersion &fileVersion()
const
630 return m_fileVersion;
634 ProductVersion m_productVersion{};
640 m_productVersion = value;
644 const ProductVersion &productVersion()
const
646 return m_productVersion;
651 void forEach(
const F &f)
const
654 f(m_fileDescription);
661 void forEach(
const F &f)
664 f(m_fileDescription);
671 void traverseValues(
const F &f)
const
674 f(m_fileDescription);
681 void traverseValues(
const F &f)
684 f(m_fileDescription);
699 void setFromString(
const std::string &value);
702 friend std::istream &operator>>(std::istream &stream,
ZividAPI &value)
705 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
710 bool operator==(
const ZividAPI &other)
const;
713 bool operator!=(
const ZividAPI &other)
const;
724 static constexpr
bool isContainer{
true };
727 static constexpr
const char *path{
"SoftwareVersion/ZividCameraFile" };
730 static constexpr
const char *name{
"ZividCameraFile" };
733 static constexpr
const char *description{
734 R
"description(Version information for the ZividCameraFile driver)description"
738 void set(
const std::string &fullPath,
const std::string &value);
741 std::string getString(
const std::string &fullPath)
const;
748 using ValueType = std::string;
751 static constexpr
bool isContainer{
false };
754 static constexpr
const char *path{
"SoftwareVersion/ZividCameraFile/Comments" };
757 static constexpr
const char *name{
"Comments" };
760 static constexpr
const char *description{ R
"description(Comments)description" };
763 Comments() = default;
766 explicit Comments(ValueType value) noexcept(std::is_nothrow_move_constructible<ValueType>::value)
767 : m_value{ std::move(value) }
771 const ValueType &value()
const
777 void setFromString(
const std::string &value)
789 bool operator==(
const Comments &other)
const
791 return m_value == other.m_value;
795 bool operator!=(
const Comments &other)
const
797 return m_value != other.m_value;
801 bool operator<(
const Comments &other)
const
803 return m_value < other.m_value;
807 bool operator>(
const Comments &other)
const
809 return m_value > other.m_value;
813 friend std::ostream &
operator<<(std::ostream &stream,
const Comments &value)
815 return stream << value.toString();
819 friend std::istream &operator>>(std::istream &stream, Comments &value)
822 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
838 static constexpr
bool isContainer{
false };
841 static constexpr
const char *path{
"SoftwareVersion/ZividCameraFile/FileDescription" };
844 static constexpr
const char *name{
"FileDescription" };
847 static constexpr
const char *description{ R
"description(File description)description" };
854 std::is_nothrow_move_constructible<ValueType>::value)
855 : m_value{ std::move(value) }
859 const ValueType &value()
const
865 void setFromString(
const std::string &value)
879 return m_value == other.m_value;
885 return m_value != other.m_value;
891 return m_value < other.m_value;
897 return m_value > other.m_value;
907 friend std::istream &operator>>(std::istream &stream, FileDescription &value)
910 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
926 static constexpr
bool isContainer{
false };
929 static constexpr
const char *path{
"SoftwareVersion/ZividCameraFile/FileVersion" };
932 static constexpr
const char *name{
"FileVersion" };
935 static constexpr
const char *description{ R
"description(File version)description" };
941 explicit FileVersion(
ValueType value) noexcept(std::is_nothrow_move_constructible<ValueType>::value)
942 : m_value{ std::move(value) }
952 void setFromString(
const std::string &value)
966 return m_value == other.m_value;
972 return m_value != other.m_value;
978 return m_value < other.m_value;
984 return m_value > other.m_value;
994 friend std::istream &operator>>(std::istream &stream,
FileVersion &value)
997 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
1013 static constexpr
bool isContainer{
false };
1016 static constexpr
const char *path{
"SoftwareVersion/ZividCameraFile/ProductVersion" };
1019 static constexpr
const char *name{
"ProductVersion" };
1022 static constexpr
const char *description{ R
"description(Product version)description" };
1029 std::is_nothrow_move_constructible<ValueType>::value)
1030 : m_value{ std::move(value) }
1034 const ValueType &value()
const
1040 void setFromString(
const std::string &value)
1054 return m_value == other.m_value;
1060 return m_value != other.m_value;
1066 return m_value < other.m_value;
1072 return m_value > other.m_value;
1082 friend std::istream &operator>>(std::istream &stream, ProductVersion &value)
1084 value.setFromString(
1085 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
1093 template<
typename T,
1094 typename std::enable_if<
1095 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile::Comments>::value,
1102 template<
typename T,
1103 typename std::enable_if<
1104 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile::FileDescription>::value,
1108 return m_fileDescription;
1111 template<
typename T,
1112 typename std::enable_if<
1113 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile::FileVersion>::value,
1117 return m_fileVersion;
1120 template<
typename T,
1121 typename std::enable_if<
1122 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile::ProductVersion>::value,
1126 return m_productVersion;
1129 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
1135 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
1138 return m_fileDescription;
1141 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
1144 return m_fileVersion;
1147 template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
1150 return m_productVersion;
1182 m_fileDescription = value;
1186 const FileDescription &fileDescription()
const
1188 return m_fileDescription;
1192 FileVersion m_fileVersion{};
1198 m_fileVersion = value;
1202 const FileVersion &fileVersion()
const
1204 return m_fileVersion;
1208 ProductVersion m_productVersion{};
1214 m_productVersion = value;
1218 const ProductVersion &productVersion()
const
1220 return m_productVersion;
1224 template<
typename F>
1225 void forEach(
const F &f)
const
1228 f(m_fileDescription);
1230 f(m_productVersion);
1234 template<
typename F>
1235 void forEach(
const F &f)
1238 f(m_fileDescription);
1240 f(m_productVersion);
1244 template<
typename F>
1245 void traverseValues(
const F &f)
const
1248 f(m_fileDescription);
1250 f(m_productVersion);
1254 template<
typename F>
1255 void traverseValues(
const F &f)
1258 f(m_fileDescription);
1260 f(m_productVersion);
1273 void setFromString(
const std::string &value);
1276 friend std::istream &operator>>(std::istream &stream,
ZividCameraFile &value)
1279 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
1298 static constexpr
bool isContainer{
true };
1301 static constexpr
const char *path{
"SoftwareVersion/ZividCameraToshibaTeli" };
1304 static constexpr
const char *name{
"ZividCameraToshibaTeli" };
1307 static constexpr
const char *description{
1308 R
"description(Version information for the ZividCameraToshibaTeli driver)description"
1312 void set(
const std::string &fullPath,
const std::string &value);
1315 std::string getString(
const std::string &fullPath)
const;
1322 using ValueType = std::string;
1325 static constexpr
bool isContainer{
false };
1328 static constexpr
const char *path{
"SoftwareVersion/ZividCameraToshibaTeli/Comments" };
1331 static constexpr
const char *name{
"Comments" };
1334 static constexpr
const char *description{ R
"description(Comments)description" };
1337 Comments() = default;
1340 explicit Comments(ValueType value) noexcept(std::is_nothrow_move_constructible<ValueType>::value)
1341 : m_value{ std::move(value) }
1345 const ValueType &value()
const
1351 void setFromString(
const std::string &value)
1363 bool operator==(
const Comments &other)
const
1365 return m_value == other.m_value;
1369 bool operator!=(
const Comments &other)
const
1371 return m_value != other.m_value;
1375 bool operator<(
const Comments &other)
const
1377 return m_value < other.m_value;
1381 bool operator>(
const Comments &other)
const
1383 return m_value > other.m_value;
1387 friend std::ostream &
operator<<(std::ostream &stream,
const Comments &value)
1389 return stream << value.toString();
1393 friend std::istream &operator>>(std::istream &stream, Comments &value)
1395 value.setFromString(
1396 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
1412 static constexpr
bool isContainer{
false };
1415 static constexpr
const char *path{
"SoftwareVersion/ZividCameraToshibaTeli/FileDescription" };
1418 static constexpr
const char *name{
"FileDescription" };
1421 static constexpr
const char *description{ R
"description(File description)description" };
1428 std::is_nothrow_move_constructible<ValueType>::value)
1429 : m_value{ std::move(value) }
1433 const ValueType &value()
const
1439 void setFromString(
const std::string &value)
1453 return m_value == other.m_value;
1459 return m_value != other.m_value;
1465 return m_value < other.m_value;
1471 return m_value > other.m_value;
1481 friend std::istream &operator>>(std::istream &stream, FileDescription &value)
1483 value.setFromString(
1484 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
1500 static constexpr
bool isContainer{
false };
1503 static constexpr
const char *path{
"SoftwareVersion/ZividCameraToshibaTeli/FileVersion" };
1506 static constexpr
const char *name{
"FileVersion" };
1509 static constexpr
const char *description{ R
"description(File version)description" };
1515 explicit FileVersion(
ValueType value) noexcept(std::is_nothrow_move_constructible<ValueType>::value)
1516 : m_value{ std::move(value) }
1526 void setFromString(
const std::string &value)
1540 return m_value == other.m_value;
1546 return m_value != other.m_value;
1552 return m_value < other.m_value;
1558 return m_value > other.m_value;
1568 friend std::istream &operator>>(std::istream &stream,
FileVersion &value)
1571 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
1587 static constexpr
bool isContainer{
false };
1590 static constexpr
const char *path{
"SoftwareVersion/ZividCameraToshibaTeli/ProductVersion" };
1593 static constexpr
const char *name{
"ProductVersion" };
1596 static constexpr
const char *description{ R
"description(Product version)description" };
1603 std::is_nothrow_move_constructible<ValueType>::value)
1604 : m_value{ std::move(value) }
1608 const ValueType &value()
const
1614 void setFromString(
const std::string &value)
1628 return m_value == other.m_value;
1634 return m_value != other.m_value;
1640 return m_value < other.m_value;
1646 return m_value > other.m_value;
1656 friend std::istream &operator>>(std::istream &stream, ProductVersion &value)
1658 value.setFromString(
1659 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
1667 template<
typename T,
1668 typename std::enable_if<
1669 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli::Comments>::value,
1678 typename std::enable_if<
1679 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli::FileDescription>::value,
1683 return m_fileDescription;
1686 template<
typename T,
1687 typename std::enable_if<
1688 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli::FileVersion>::value,
1692 return m_fileVersion;
1695 template<
typename T,
1696 typename std::enable_if<
1697 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli::ProductVersion>::value,
1701 return m_productVersion;
1704 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
1710 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
1713 return m_fileDescription;
1716 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
1719 return m_fileVersion;
1722 template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
1725 return m_productVersion;
1745 const Comments &comments()
const
1757 m_fileDescription = value;
1761 const FileDescription &fileDescription()
const
1763 return m_fileDescription;
1767 FileVersion m_fileVersion{};
1773 m_fileVersion = value;
1777 const FileVersion &fileVersion()
const
1779 return m_fileVersion;
1783 ProductVersion m_productVersion{};
1789 m_productVersion = value;
1793 const ProductVersion &productVersion()
const
1795 return m_productVersion;
1799 template<
typename F>
1800 void forEach(
const F &f)
const
1803 f(m_fileDescription);
1805 f(m_productVersion);
1809 template<
typename F>
1810 void forEach(
const F &f)
1813 f(m_fileDescription);
1815 f(m_productVersion);
1819 template<
typename F>
1820 void traverseValues(
const F &f)
const
1823 f(m_fileDescription);
1825 f(m_productVersion);
1829 template<
typename F>
1830 void traverseValues(
const F &f)
1833 f(m_fileDescription);
1835 f(m_productVersion);
1848 void setFromString(
const std::string &value);
1854 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
1873 static constexpr
bool isContainer{
true };
1876 static constexpr
const char *path{
"SoftwareVersion/ZividStudio" };
1879 static constexpr
const char *name{
"ZividStudio" };
1882 static constexpr
const char *description{
1883 R
"description(Version information for the ZividStudio applicaton)description"
1887 void set(
const std::string &fullPath,
const std::string &value);
1890 std::string getString(
const std::string &fullPath)
const;
1897 using ValueType = std::string;
1900 static constexpr
bool isContainer{
false };
1903 static constexpr
const char *path{
"SoftwareVersion/ZividStudio/Comments" };
1906 static constexpr
const char *name{
"Comments" };
1909 static constexpr
const char *description{ R
"description(Comments)description" };
1912 Comments() = default;
1915 explicit Comments(ValueType value) noexcept(std::is_nothrow_move_constructible<ValueType>::value)
1916 : m_value{ std::move(value) }
1920 const ValueType &value()
const
1926 void setFromString(
const std::string &value)
1938 bool operator==(
const Comments &other)
const
1940 return m_value == other.m_value;
1944 bool operator!=(
const Comments &other)
const
1946 return m_value != other.m_value;
1950 bool operator<(
const Comments &other)
const
1952 return m_value < other.m_value;
1956 bool operator>(
const Comments &other)
const
1958 return m_value > other.m_value;
1962 friend std::ostream &
operator<<(std::ostream &stream,
const Comments &value)
1964 return stream << value.toString();
1968 friend std::istream &operator>>(std::istream &stream, Comments &value)
1970 value.setFromString(
1971 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
1987 static constexpr
bool isContainer{
false };
1990 static constexpr
const char *path{
"SoftwareVersion/ZividStudio/FileDescription" };
1993 static constexpr
const char *name{
"FileDescription" };
1996 static constexpr
const char *description{ R
"description(File description)description" };
2003 std::is_nothrow_move_constructible<ValueType>::value)
2004 : m_value{ std::move(value) }
2008 const ValueType &value()
const
2014 void setFromString(
const std::string &value)
2028 return m_value == other.m_value;
2034 return m_value != other.m_value;
2040 return m_value < other.m_value;
2046 return m_value > other.m_value;
2056 friend std::istream &operator>>(std::istream &stream, FileDescription &value)
2058 value.setFromString(
2059 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
2075 static constexpr
bool isContainer{
false };
2078 static constexpr
const char *path{
"SoftwareVersion/ZividStudio/FileVersion" };
2081 static constexpr
const char *name{
"FileVersion" };
2084 static constexpr
const char *description{ R
"description(File version)description" };
2090 explicit FileVersion(
ValueType value) noexcept(std::is_nothrow_move_constructible<ValueType>::value)
2091 : m_value{ std::move(value) }
2101 void setFromString(
const std::string &value)
2115 return m_value == other.m_value;
2121 return m_value != other.m_value;
2127 return m_value < other.m_value;
2133 return m_value > other.m_value;
2143 friend std::istream &operator>>(std::istream &stream,
FileVersion &value)
2146 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
2162 static constexpr
bool isContainer{
false };
2165 static constexpr
const char *path{
"SoftwareVersion/ZividStudio/ProductVersion" };
2168 static constexpr
const char *name{
"ProductVersion" };
2171 static constexpr
const char *description{ R
"description(Product version)description" };
2178 std::is_nothrow_move_constructible<ValueType>::value)
2179 : m_value{ std::move(value) }
2183 const ValueType &value()
const
2189 void setFromString(
const std::string &value)
2203 return m_value == other.m_value;
2209 return m_value != other.m_value;
2215 return m_value < other.m_value;
2221 return m_value > other.m_value;
2231 friend std::istream &operator>>(std::istream &stream, ProductVersion &value)
2233 value.setFromString(
2234 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
2244 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio::Comments>::value,
2251 template<
typename T,
2252 typename std::enable_if<
2253 std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio::FileDescription>::value,
2257 return m_fileDescription;
2260 template<
typename T,
2261 typename std::enable_if<
2262 std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio::FileVersion>::value,
2266 return m_fileVersion;
2269 template<
typename T,
2270 typename std::enable_if<
2271 std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio::ProductVersion>::value,
2275 return m_productVersion;
2278 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
2284 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
2287 return m_fileDescription;
2290 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
2293 return m_fileVersion;
2296 template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
2299 return m_productVersion;
2331 m_fileDescription = value;
2335 const FileDescription &fileDescription()
const
2337 return m_fileDescription;
2341 FileVersion m_fileVersion{};
2347 m_fileVersion = value;
2351 const FileVersion &fileVersion()
const
2353 return m_fileVersion;
2357 ProductVersion m_productVersion{};
2363 m_productVersion = value;
2367 const ProductVersion &productVersion()
const
2369 return m_productVersion;
2373 template<
typename F>
2374 void forEach(
const F &f)
const
2377 f(m_fileDescription);
2379 f(m_productVersion);
2383 template<
typename F>
2384 void forEach(
const F &f)
2387 f(m_fileDescription);
2389 f(m_productVersion);
2393 template<
typename F>
2394 void traverseValues(
const F &f)
const
2397 f(m_fileDescription);
2399 f(m_productVersion);
2403 template<
typename F>
2404 void traverseValues(
const F &f)
2407 f(m_fileDescription);
2409 f(m_productVersion);
2422 void setFromString(
const std::string &value);
2425 friend std::istream &operator>>(std::istream &stream,
ZividStudio &value)
2428 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
2441 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI>::value,
int>::type = 0>
2447 template<
typename T,
2448 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI::Comments>::value,
2457 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI::FileDescription>::value,
2464 template<
typename T,
2465 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI::FileVersion>::value,
2474 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI::ProductVersion>::value,
2481 template<
typename T,
2482 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile>::value,
2486 return m_zividCameraFile;
2491 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile::Comments>::value,
2498 template<
typename T,
2499 typename std::enable_if<
2500 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile::FileDescription>::value,
2507 template<
typename T,
2508 typename std::enable_if<
2509 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile::FileVersion>::value,
2516 template<
typename T,
2517 typename std::enable_if<
2518 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile::ProductVersion>::value,
2525 template<
typename T,
2526 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli>::value,
2530 return m_zividCameraToshibaTeli;
2533 template<
typename T,
2534 typename std::enable_if<
2535 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli::Comments>::value,
2542 template<
typename T,
2543 typename std::enable_if<
2544 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli::FileDescription>::value,
2548 return m_zividCameraToshibaTeli
2552 template<
typename T,
2553 typename std::enable_if<
2554 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli::FileVersion>::value,
2561 template<
typename T,
2562 typename std::enable_if<
2563 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli::ProductVersion>::value,
2567 return m_zividCameraToshibaTeli
2573 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio>::value,
int>::type = 0>
2576 return m_zividStudio;
2579 template<
typename T,
2580 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio::Comments>::value,
2587 template<
typename T,
2588 typename std::enable_if<
2589 std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio::FileDescription>::value,
2598 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio::FileVersion>::value,
2607 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio::ProductVersion>::value,
2614 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
2620 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
2623 return m_zividCameraFile;
2626 template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
2629 return m_zividCameraToshibaTeli;
2632 template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
2635 return m_zividStudio;
2640 const ZividCameraFile &zividCameraFile,
2641 const ZividCameraToshibaTeli &zividCameraToshibaTeli,
2642 const ZividStudio &zividStudio);
2655 const ZividAPI &zividAPI()
const
2663 m_zividAPI.
set(value);
2677 m_zividAPI.
set(value);
2684 m_zividAPI.
set(value);
2695 m_zividCameraFile = value;
2699 const ZividCameraFile &zividCameraFile()
const
2701 return m_zividCameraFile;
2707 m_zividCameraFile.
set(value);
2714 m_zividCameraFile.
set(value);
2721 m_zividCameraFile.
set(value);
2726 SoftwareVersion &set(
const ZividCameraFile::ProductVersion &value)
2728 m_zividCameraFile.set(value);
2733 ZividCameraToshibaTeli m_zividCameraToshibaTeli{};
2739 m_zividCameraToshibaTeli = value;
2743 const ZividCameraToshibaTeli &zividCameraToshibaTeli()
const
2745 return m_zividCameraToshibaTeli;
2751 m_zividCameraToshibaTeli.
set(value);
2758 m_zividCameraToshibaTeli.
set(value);
2765 m_zividCameraToshibaTeli.
set(value);
2770 SoftwareVersion &set(
const ZividCameraToshibaTeli::ProductVersion &value)
2772 m_zividCameraToshibaTeli.
set(value);
2777 ZividStudio m_zividStudio{};
2783 m_zividStudio = value;
2787 const ZividStudio &zividStudio()
const
2789 return m_zividStudio;
2795 m_zividStudio.
set(value);
2802 m_zividStudio.
set(value);
2809 m_zividStudio.
set(value);
2821 template<
typename F>
2822 void forEach(
const F &f)
const
2825 f(m_zividCameraFile);
2826 f(m_zividCameraToshibaTeli);
2831 template<
typename F>
2832 void forEach(
const F &f)
2835 f(m_zividCameraFile);
2836 f(m_zividCameraToshibaTeli);
2841 template<
typename F>
2842 void traverseValues(
const F &f)
const
2844 m_zividAPI.traverseValues(f);
2845 m_zividCameraFile.traverseValues(f);
2846 m_zividCameraToshibaTeli.traverseValues(f);
2847 m_zividStudio.traverseValues(f);
2851 template<
typename F>
2852 void traverseValues(
const F &f)
2854 m_zividAPI.traverseValues(f);
2855 m_zividCameraFile.traverseValues(f);
2856 m_zividCameraToshibaTeli.traverseValues(f);
2857 m_zividStudio.traverseValues(f);
2870 void setFromString(
const std::string &value);
2873 friend std::istream &operator>>(std::istream &stream,
SoftwareVersion &value)
2876 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
2892 using ValueType = std::chrono::system_clock::time_point;
2895 static constexpr
bool isContainer{
false };
2898 static constexpr
const char *path{
"TimeStamp" };
2901 static constexpr
const char *name{
"TimeStamp" };
2904 static constexpr
const char *description{ R
"description(The time of frame capture)description" };
2907 TimeStamp() = default;
2910 explicit constexpr TimeStamp(ValueType value) noexcept(std::is_nothrow_copy_constructible<ValueType>::value)
2915 const ValueType &value()
const
2923 return { ValueType::min(), ValueType::max() };
2927 void setFromString(
const std::string &value);
2933 bool operator==(
const TimeStamp &other)
const
2935 return m_value == other.m_value;
2939 bool operator!=(
const TimeStamp &other)
const
2941 return m_value != other.m_value;
2945 bool operator<(
const TimeStamp &other)
const
2947 return m_value < other.m_value;
2951 bool operator>(
const TimeStamp &other)
const
2953 return m_value > other.m_value;
2963 friend std::istream &operator>>(std::istream &stream, TimeStamp &value)
2965 value.setFromString(
2966 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
2974 template<typename T, typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion>::value,
int>::type = 0>
2977 return m_softwareVersion;
2980 template<
typename T,
2981 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI>::value,
int>::type = 0>
2987 template<
typename T,
2988 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI::Comments>::value,
2995 template<
typename T,
2996 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI::FileDescription>::value,
3003 template<
typename T,
3004 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI::FileVersion>::value,
3011 template<
typename T,
3012 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividAPI::ProductVersion>::value,
3021 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile>::value,
int>::type = 0>
3027 template<
typename T,
3028 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile::Comments>::value,
3035 template<
typename T,
3036 typename std::enable_if<
3037 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile::FileDescription>::value,
3046 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile::FileVersion>::value,
3055 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraFile::ProductVersion>::value,
3062 template<
typename T,
3063 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli>::value,
3070 template<
typename T,
3071 typename std::enable_if<
3072 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli::Comments>::value,
3079 template<
typename T,
3080 typename std::enable_if<
3081 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli::FileDescription>::value,
3088 template<
typename T,
3089 typename std::enable_if<
3090 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli::FileVersion>::value,
3097 template<
typename T,
3098 typename std::enable_if<
3099 std::is_same<T, FrameInfo::SoftwareVersion::ZividCameraToshibaTeli::ProductVersion>::value,
3108 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio>::value,
int>::type = 0>
3114 template<
typename T,
3115 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio::Comments>::value,
3124 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio::FileDescription>::value,
3131 template<
typename T,
3132 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio::FileVersion>::value,
3141 typename std::enable_if<std::is_same<T, FrameInfo::SoftwareVersion::ZividStudio::ProductVersion>::value,
3148 template<typename T, typename std::enable_if<std::is_same<T, FrameInfo::TimeStamp>::value,
int>::type = 0>
3154 template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
3157 return m_softwareVersion;
3160 template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
3167 explicit FrameInfo(
const SoftwareVersion &softwareVersion,
const TimeStamp &timeStamp);
3170 SoftwareVersion m_softwareVersion{};
3176 m_softwareVersion = value;
3182 return m_softwareVersion;
3186 FrameInfo &set(
const SoftwareVersion::ZividAPI &value)
3193 FrameInfo &set(
const SoftwareVersion::ZividAPI::Comments &value)
3195 m_softwareVersion.
set(value);
3200 FrameInfo &set(
const SoftwareVersion::ZividAPI::FileDescription &value)
3202 m_softwareVersion.
set(value);
3209 m_softwareVersion.
set(value);
3214 FrameInfo &set(
const SoftwareVersion::ZividAPI::ProductVersion &value)
3216 m_softwareVersion.
set(value);
3221 FrameInfo &set(
const SoftwareVersion::ZividCameraFile &value)
3223 m_softwareVersion.set(value);
3230 m_softwareVersion.
set(value);
3235 FrameInfo &set(
const SoftwareVersion::ZividCameraFile::FileDescription &value)
3237 m_softwareVersion.
set(value);
3244 m_softwareVersion.
set(value);
3249 FrameInfo &set(
const SoftwareVersion::ZividCameraFile::ProductVersion &value)
3251 m_softwareVersion.
set(value);
3256 FrameInfo &set(
const SoftwareVersion::ZividCameraToshibaTeli &value)
3258 m_softwareVersion.
set(value);
3263 FrameInfo &set(
const SoftwareVersion::ZividCameraToshibaTeli::Comments &value)
3270 FrameInfo &set(
const SoftwareVersion::ZividCameraToshibaTeli::FileDescription &value)
3277 FrameInfo &set(
const SoftwareVersion::ZividCameraToshibaTeli::FileVersion &value)
3284 FrameInfo &set(
const SoftwareVersion::ZividCameraToshibaTeli::ProductVersion &value)
3291 FrameInfo &set(
const SoftwareVersion::ZividStudio &value)
3298 FrameInfo &set(
const SoftwareVersion::ZividStudio::Comments &value)
3305 FrameInfo &set(
const SoftwareVersion::ZividStudio::FileDescription &value)
3312 FrameInfo &set(
const SoftwareVersion::ZividStudio::FileVersion &value)
3319 FrameInfo &set(
const SoftwareVersion::ZividStudio::ProductVersion &value)
3326 TimeStamp m_timeStamp{};
3332 if(value.
value().time_since_epoch().count() < value.
range().min().time_since_epoch().count()
3333 || value.
value().time_since_epoch().count() > value.
range().max().time_since_epoch().count())
3335 throw std::out_of_range(
"TimeStamp{ " + std::to_string(value.
value().time_since_epoch().count())
3336 +
" } is not in range ["
3337 + std::to_string(value.
range().min().time_since_epoch().count()) +
", "
3338 + std::to_string(value.
range().max().time_since_epoch().count()) +
"]");
3341 m_timeStamp = value;
3345 const TimeStamp &timeStamp()
const
3351 template<
typename F>
3352 void forEach(
const F &f)
const
3354 f(m_softwareVersion);
3359 template<
typename F>
3360 void forEach(
const F &f)
3362 f(m_softwareVersion);
3367 template<
typename F>
3368 void traverseValues(
const F &f)
const
3370 m_softwareVersion.traverseValues(f);
3375 template<
typename F>
3376 void traverseValues(
const F &f)
3378 m_softwareVersion.traverseValues(f);
3392 void setFromString(
const std::string &value);
3395 friend std::istream &operator>>(std::istream &stream,
FrameInfo &value)
3398 std::string{ std::istreambuf_iterator<char>{ stream }, std::istreambuf_iterator<char>{} });
3403 bool operator==(
const FrameInfo &other)
const;
3406 bool operator!=(
const FrameInfo &other)
const;
3412 void save(
const std::string &fileName)
const;
3415 void load(
const std::string &fileName);
3420 struct FrameInfo::Version<1>
3429 # pragma warning(pop)
3433 # if !(defined(_MSC_VER) && (_MSC_VER <= 1900))
3444 = decltype(declval<Zivid::FrameInfo::SoftwareVersion::ZividAPI>().get<i>());
3455 = decltype(declval<Zivid::FrameInfo::SoftwareVersion::ZividCameraFile>().get<i>());
3463 struct tuple_element<i,
Zivid::FrameInfo::SoftwareVersion::ZividCameraToshibaTeli>
3466 = decltype(declval<Zivid::FrameInfo::SoftwareVersion::ZividCameraToshibaTeli>().get<i>());
3477 = decltype(declval<Zivid::FrameInfo::SoftwareVersion::ZividStudio>().get<i>());
3485 struct tuple_element<i,
Zivid::FrameInfo::SoftwareVersion>
3488 = decltype(declval<Zivid::FrameInfo::SoftwareVersion>().get<i>());
3492 struct tuple_size<
Zivid::FrameInfo> : integral_constant<size_t, 2>
3496 struct tuple_element<i,
Zivid::FrameInfo>
3499 = decltype(declval<Zivid::FrameInfo>().get<i>());