CameraState.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of the Zivid API
 *
 * Copyright 2015-2024 (C) Zivid AS
 * All rights reserved.
 *
 * Zivid Software License, v1.0
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. Neither the name of Zivid AS nor the names of its contributors may be used
 * to endorse or promote products derived from this software without specific
 * prior written permission.
 *
 * 4. This software, with or without modification, must not be used with any
 * other 3D camera than from Zivid AS.
 *
 * 5. Any software provided in binary form under this license must not be
 * reverse engineered, decompiled, modified and/or disassembled.
 *
 * THIS SOFTWARE IS PROVIDED BY ZIVID AS "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ZIVID AS OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * Contact: Zivid Customer Success Team <customersuccess@zivid.com>
 * Info:    http://www.zivid.com
 ******************************************************************************/
 
#pragma once
 
#include <array>
#include <chrono>
#include <cmath>
#include <ctime>
#include <iomanip>
#include <memory>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include "Zivid/DataModel/Detail/Detail.h"
#include "Zivid/DataModel/NodeType.h"
#include "Zivid/DataModel/Traits.h"
#include "Zivid/Detail/CoreExport.h"
#include "Zivid/Detail/TypeTraits.h"
#include "Zivid/Range.h"
 
#ifdef _MSC_VER
#    pragma warning(push)
#    pragma warning(disable : 4251) // "X needs to have dll-interface to be used by clients of class Y."
#endif
 
namespace Zivid
{
 
 
    // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
    class ZIVID_CORE_EXPORT CameraState
    {
    public:
        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
        static constexpr const char *path{ "" };
 
        static constexpr const char *name{ "CameraState" };
 
        static constexpr const char *description{
            R"description(Information about camera connection state, temperatures, etc.)description"
        };
 
        static constexpr size_t version{ 5 };
 
#ifndef NO_DOC
        template<size_t>
        struct Version;
 
        using LatestVersion = Zivid::CameraState;
 
        // Short identifier. This value is not guaranteed to be universally unique
        // Todo(ZIVID-2808): Move this to internal DataModelExt header
        static constexpr std::array<uint8_t, 3> binaryId{ 'c', 's', 't' };
 
#endif
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Available
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
            static constexpr const char *path{ "Available" };
 
            static constexpr const char *name{ "Available" };
 
            static constexpr const char *description{
                R"description(Flag if camera is physically connected to the computer and is available for use, but not connected in
software. This corresponds to the Status enums `available` or `firmwareUpdateRequired`. Zivid
recommends to use the Status enum instead of this bool.
)description"
            };
 
            using ValueType = bool;
            static const Available yes; 
            static const Available no;  
 
            static std::set<bool> validValues()
            {
                return { false, true };
            }
 
            Available() = default;
 
            explicit constexpr Available(bool value)
                : m_value{ value }
            {}
 
            bool value() const;
 
            std::string toString() const;
 
            explicit operator bool() const
            {
                return m_value;
            }
 
            bool operator==(const Available &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const Available &other) const
            {
                return m_value != other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const Available &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            bool m_value{ false };
 
            friend struct DataModel::Detail::Befriend<Available>;
        };
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Connected
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
            static constexpr const char *path{ "Connected" };
 
            static constexpr const char *name{ "Connected" };
 
            static constexpr const char *description{
                R"description(Flag if camera is connected in software. This bool is true when the Status value is `connected`. Zivid
recommends to use the Status enum instead of this bool.
)description"
            };
 
            using ValueType = bool;
            static const Connected yes; 
            static const Connected no;  
 
            static std::set<bool> validValues()
            {
                return { false, true };
            }
 
            Connected() = default;
 
            explicit constexpr Connected(bool value)
                : m_value{ value }
            {}
 
            bool value() const;
 
            std::string toString() const;
 
            explicit operator bool() const
            {
                return m_value;
            }
 
            bool operator==(const Connected &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const Connected &other) const
            {
                return m_value != other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const Connected &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            bool m_value{ false };
 
            friend struct DataModel::Detail::Befriend<Connected>;
        };
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT InaccessibleReason
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
            static constexpr const char *path{ "InaccessibleReason" };
 
            static constexpr const char *name{ "InaccessibleReason" };
 
            static constexpr const char *description{
                R"description(If the camera status is `inaccessible`, then this enum value will give you the reason.)description"
            };
 
            enum class ValueType
            {
                ipConflictWithAnotherCamera,
                ipConflictWithLocalNetworkAdapter,
                ipNotInLocalSubnet,
                ipInMultipleLocalSubnets
            };
            static const InaccessibleReason ipConflictWithAnotherCamera;       
            static const InaccessibleReason ipConflictWithLocalNetworkAdapter; 
            static const InaccessibleReason ipNotInLocalSubnet;                
            static const InaccessibleReason ipInMultipleLocalSubnets;          
 
            static std::set<ValueType> validValues()
            {
                return { ValueType::ipConflictWithAnotherCamera,
                         ValueType::ipConflictWithLocalNetworkAdapter,
                         ValueType::ipNotInLocalSubnet,
                         ValueType::ipInMultipleLocalSubnets };
            }
 
            InaccessibleReason() = default;
 
            explicit constexpr InaccessibleReason(ValueType value)
                : m_opt{ verifyValue(value) }
            {}
 
            ValueType value() const;
 
            bool hasValue() const;
 
            void reset();
 
            std::string toString() const;
 
            friend std::ostream &operator<<(std::ostream &stream, const InaccessibleReason::ValueType &value)
            {
                return stream << InaccessibleReason{ value }.toString();
            }
 
            bool operator==(const InaccessibleReason &other) const
            {
                return m_opt == other.m_opt;
            }
 
            bool operator!=(const InaccessibleReason &other) const
            {
                return m_opt != other.m_opt;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const InaccessibleReason &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            constexpr ValueType static verifyValue(const ValueType &value)
            {
                return value == ValueType::ipConflictWithAnotherCamera
                               || value == ValueType::ipConflictWithLocalNetworkAdapter
                               || value == ValueType::ipNotInLocalSubnet || value == ValueType::ipInMultipleLocalSubnets
                           ? value
                           : throw std::invalid_argument{
                                 "Invalid value: InaccessibleReason{ "
                                 + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                             };
            }
 
            Zivid::DataModel::Detail::Optional<ValueType> m_opt;
 
            friend struct DataModel::Detail::Befriend<InaccessibleReason>;
        };
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Network
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
            static constexpr const char *path{ "Network" };
 
            static constexpr const char *name{ "Network" };
 
            static constexpr const char *description{ R"description(Current network state)description" };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT IPV4
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
                static constexpr const char *path{ "Network/IPV4" };
 
                static constexpr const char *name{ "IPV4" };
 
                static constexpr const char *description{ R"description(Current IPv4 protocol state)description" };
 
 
                // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
                class ZIVID_CORE_EXPORT Address
                {
                public:
                    static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                    static constexpr const char *path{ "Network/IPV4/Address" };
 
                    static constexpr const char *name{ "Address" };
 
                    static constexpr const char *description{ R"description(Current IPv4 address)description" };
 
                    using ValueType = std::string;
 
                    static constexpr Range<ValueType::size_type> validSize()
                    {
                        return { 0, std::numeric_limits<ValueType::size_type>::max() };
                    }
 
                    Address() = default;
 
                    explicit Address(std::string value)
                        : m_value{ std::move(value) }
                    {}
 
                    const std::string &value() const;
 
                    std::string toString() const;
 
                    bool operator==(const Address &other) const
                    {
                        return m_value == other.m_value;
                    }
 
                    bool operator!=(const Address &other) const
                    {
                        return m_value != other.m_value;
                    }
 
                    bool operator<(const Address &other) const
                    {
                        return m_value < other.m_value;
                    }
 
                    bool operator>(const Address &other) const
                    {
                        return m_value > other.m_value;
                    }
 
                    bool operator<=(const Address &other) const
                    {
                        return m_value <= other.m_value;
                    }
 
                    bool operator>=(const Address &other) const
                    {
                        return m_value >= other.m_value;
                    }
 
                    friend std::ostream &operator<<(std::ostream &stream, const Address &value)
                    {
                        return stream << value.toString();
                    }
 
                private:
                    void setFromString(const std::string &value);
 
                    std::string m_value{};
 
                    friend struct DataModel::Detail::Befriend<Address>;
                };
 
                using Descendants = std::tuple<CameraState::Network::IPV4::Address>;
 
                IPV4();
 
#ifndef NO_DOC
                template<
                    typename... Args,
                    typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                    typename std::enable_if<
                        Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                            value,
                        int>::type = 0>
#else
                template<typename... Args>
#endif
                explicit IPV4(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to IPV4(...). "
                        "Types should be listed at most once.");
 
                    set(std::forward<Args>(args)...);
                }
 
#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
                template<typename... Args>
#endif
                void set(Args &&...args)
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to set(...). "
                        "Types should be listed at most once.");
 
                    Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
                }
 
#ifndef NO_DOC
                template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
                template<typename... Args>
#endif
                IPV4 copyWith(Args &&...args) const
                {
                    using namespace Zivid::Detail::TypeTraits;
 
                    using AllArgsAreDescendantNodes =
                        AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                    static_assert(
                        AllArgsAreDescendantNodes::value,
                        "All arguments passed to copyWith(...) must be descendant nodes.");
 
                    static_assert(
                        AllArgsDecayedAreUnique<Args...>::value,
                        "Found duplicate types among the arguments passed to copyWith(...). "
                        "Types should be listed at most once.");
 
                    auto copy{ *this };
                    copy.set(std::forward<Args>(args)...);
                    return copy;
                }
 
                const Address &address() const
                {
                    return m_address;
                }
 
                Address &address()
                {
                    return m_address;
                }
 
                IPV4 &set(const Address &value)
                {
                    m_address = value;
                    return *this;
                }
 
                template<
                    typename T,
                    typename std::enable_if<std::is_same<T, CameraState::Network::IPV4::Address>::value, int>::type = 0>
                const CameraState::Network::IPV4::Address &get() const
                {
                    return m_address;
                }
 
                template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
                const CameraState::Network::IPV4::Address &get() const
                {
                    return m_address;
                }
 
                template<typename F>
                void forEach(const F &f) const
                {
                    f(m_address);
                }
 
                template<typename F>
                void forEach(const F &f)
                {
                    f(m_address);
                }
 
                bool operator==(const IPV4 &other) const;
 
                bool operator!=(const IPV4 &other) const;
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const IPV4 &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                void setFromString(const std::string &fullPath, const std::string &value);
 
                std::string getString(const std::string &fullPath) const;
 
                Address m_address;
 
                friend struct DataModel::Detail::Befriend<IPV4>;
            };
 
            using Descendants = std::tuple<CameraState::Network::IPV4, CameraState::Network::IPV4::Address>;
 
            Network();
 
#ifndef NO_DOC
            template<
                typename... Args,
                typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                typename std::enable_if<
                    Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                        value,
                    int>::type = 0>
#else
            template<typename... Args>
#endif
            explicit Network(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Network(...). "
                    "Types should be listed at most once.");
 
                set(std::forward<Args>(args)...);
            }
 
#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
            template<typename... Args>
#endif
            void set(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to set(...). "
                    "Types should be listed at most once.");
 
                Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
            }
 
#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
            template<typename... Args>
#endif
            Network copyWith(Args &&...args) const
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value,
                    "All arguments passed to copyWith(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to copyWith(...). "
                    "Types should be listed at most once.");
 
                auto copy{ *this };
                copy.set(std::forward<Args>(args)...);
                return copy;
            }
 
            const IPV4 &ipv4() const
            {
                return m_ipv4;
            }
 
            IPV4 &ipv4()
            {
                return m_ipv4;
            }
 
            Network &set(const IPV4 &value)
            {
                m_ipv4 = value;
                return *this;
            }
 
            Network &set(const IPV4::Address &value)
            {
                m_ipv4.set(value);
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraState::Network::IPV4>::value, int>::type = 0>
            const CameraState::Network::IPV4 &get() const
            {
                return m_ipv4;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraState::Network::IPV4::Address>::value, int>::type = 0>
            const CameraState::Network::IPV4::Address &get() const
            {
                return m_ipv4.get<CameraState::Network::IPV4::Address>();
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const CameraState::Network::IPV4 &get() const
            {
                return m_ipv4;
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                f(m_ipv4);
            }
 
            template<typename F>
            void forEach(const F &f)
            {
                f(m_ipv4);
            }
 
            bool operator==(const Network &other) const;
 
            bool operator!=(const Network &other) const;
 
            std::string toString() const;
 
            friend std::ostream &operator<<(std::ostream &stream, const Network &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            void setFromString(const std::string &fullPath, const std::string &value);
 
            std::string getString(const std::string &fullPath) const;
 
            IPV4 m_ipv4;
 
            friend struct DataModel::Detail::Befriend<Network>;
        };
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Status
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
            static constexpr const char *path{ "Status" };
 
            static constexpr const char *name{ "Status" };
 
            static constexpr const char *description{
                R"description(This enum describes the current status of this camera. The enum can have the following values:
 
* `inaccessible`: The camera was discovered, but the SDK is not able to connect to this camera. This can
  be because the IP settings of the camera and the PC are not compatible, or because there are several
  cameras with the same IP connected to your PC. The `InaccessibleReason` enum will give you more
  details about why this camera is not accessible. The network configuration of the camera can be changed
  using the ZividNetworkCameraConfigurator CLI tool. See the knowledge base for more information.
 
* `busy`: The camera is currently in use by another process. This can be a different process on the same
  PC, or on a different PC if the camera is shared on a network.
 
* `firmwareUpdateRequired`: The camera is accessible, but requires a firmware update before you can connect
  to it.
 
* `updatingFirmware`: The camera firmware is currently being updated in the current process.
 
* `available`: The camera is available for use by the current process. This means that you can invoke
  camera.connect() on this camera.
 
* `connecting`: The camera is currently connecting in the current process.
 
* `connected`: The camera is connected in the current process. This means camera.connect() has successfully
  completed and you can capture using this camera.
 
* `disconnecting`: The camera is currently disconnecting in the current process. When disconnection has
  completed, the camera will normally go back to the `available` state.
 
* `disappeared`: The camera was found earlier, but it can no longer be found. The connection between the
  PC and the camera may be disrupted, or the camera may have lost power. When in `disappeared` state, the
  camera will not be returned from `Application::cameras()`. The camera will go back to one of the other
  states if the camera is later found again.
)description"
            };
 
            enum class ValueType
            {
                inaccessible,
                busy,
                firmwareUpdateRequired,
                updatingFirmware,
                available,
                connecting,
                connected,
                disconnecting,
                disappeared
            };
            static const Status inaccessible;           
            static const Status busy;                   
            static const Status firmwareUpdateRequired; 
            static const Status updatingFirmware;       
            static const Status available;              
            static const Status connecting;             
            static const Status connected;              
            static const Status disconnecting;          
            static const Status disappeared;            
 
            static std::set<ValueType> validValues()
            {
                return { ValueType::inaccessible,     ValueType::busy,          ValueType::firmwareUpdateRequired,
                         ValueType::updatingFirmware, ValueType::available,     ValueType::connecting,
                         ValueType::connected,        ValueType::disconnecting, ValueType::disappeared };
            }
 
            Status() = default;
 
            explicit constexpr Status(ValueType value)
                : m_value{ verifyValue(value) }
            {}
 
            ValueType value() const;
 
            std::string toString() const;
 
            friend std::ostream &operator<<(std::ostream &stream, const Status::ValueType &value)
            {
                return stream << Status{ value }.toString();
            }
 
            bool operator==(const Status &other) const
            {
                return m_value == other.m_value;
            }
 
            bool operator!=(const Status &other) const
            {
                return m_value != other.m_value;
            }
 
            friend std::ostream &operator<<(std::ostream &stream, const Status &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            constexpr ValueType static verifyValue(const ValueType &value)
            {
                return value == ValueType::inaccessible || value == ValueType::busy
                               || value == ValueType::firmwareUpdateRequired || value == ValueType::updatingFirmware
                               || value == ValueType::available || value == ValueType::connecting
                               || value == ValueType::connected || value == ValueType::disconnecting
                               || value == ValueType::disappeared
                           ? value
                           : throw std::invalid_argument{
                                 "Invalid value: Status{ "
                                 + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                             };
            }
 
            ValueType m_value{ ValueType::inaccessible };
 
            friend struct DataModel::Detail::Befriend<Status>;
        };
 
 
        // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
        class ZIVID_CORE_EXPORT Temperature
        {
        public:
            static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
            static constexpr const char *path{ "Temperature" };
 
            static constexpr const char *name{ "Temperature" };
 
            static constexpr const char *description{ R"description(Current temperature(s))description" };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT DMD
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Temperature/DMD" };
 
                static constexpr const char *name{ "DMD" };
 
                static constexpr const char *description{ R"description(DMD temperature)description" };
 
                using ValueType = double;
 
                static constexpr Range<double> validRange()
                {
                    return { std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max() };
                }
 
                DMD() = default;
 
                explicit constexpr DMD(double value)
                    : m_value{ value }
                {}
 
                double value() const;
 
                std::string toString() const;
 
                bool operator==(const DMD &other) const
                {
                    return m_value == other.m_value;
                }
 
                bool operator!=(const DMD &other) const
                {
                    return m_value != other.m_value;
                }
 
                bool operator<(const DMD &other) const
                {
                    return m_value < other.m_value;
                }
 
                bool operator>(const DMD &other) const
                {
                    return m_value > other.m_value;
                }
 
                bool operator<=(const DMD &other) const
                {
                    return m_value <= other.m_value;
                }
 
                bool operator>=(const DMD &other) const
                {
                    return m_value >= other.m_value;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const DMD &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                double m_value{ 0.0 };
 
                friend struct DataModel::Detail::Befriend<DMD>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT General
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Temperature/General" };
 
                static constexpr const char *name{ "General" };
 
                static constexpr const char *description{ R"description(General temperature)description" };
 
                using ValueType = double;
 
                static constexpr Range<double> validRange()
                {
                    return { std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max() };
                }
 
                General() = default;
 
                explicit constexpr General(double value)
                    : m_value{ value }
                {}
 
                double value() const;
 
                std::string toString() const;
 
                bool operator==(const General &other) const
                {
                    return m_value == other.m_value;
                }
 
                bool operator!=(const General &other) const
                {
                    return m_value != other.m_value;
                }
 
                bool operator<(const General &other) const
                {
                    return m_value < other.m_value;
                }
 
                bool operator>(const General &other) const
                {
                    return m_value > other.m_value;
                }
 
                bool operator<=(const General &other) const
                {
                    return m_value <= other.m_value;
                }
 
                bool operator>=(const General &other) const
                {
                    return m_value >= other.m_value;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const General &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                double m_value{ 0.0 };
 
                friend struct DataModel::Detail::Befriend<General>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT LED
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Temperature/LED" };
 
                static constexpr const char *name{ "LED" };
 
                static constexpr const char *description{ R"description(LED temperature)description" };
 
                using ValueType = double;
 
                static constexpr Range<double> validRange()
                {
                    return { std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max() };
                }
 
                LED() = default;
 
                explicit constexpr LED(double value)
                    : m_value{ value }
                {}
 
                double value() const;
 
                std::string toString() const;
 
                bool operator==(const LED &other) const
                {
                    return m_value == other.m_value;
                }
 
                bool operator!=(const LED &other) const
                {
                    return m_value != other.m_value;
                }
 
                bool operator<(const LED &other) const
                {
                    return m_value < other.m_value;
                }
 
                bool operator>(const LED &other) const
                {
                    return m_value > other.m_value;
                }
 
                bool operator<=(const LED &other) const
                {
                    return m_value <= other.m_value;
                }
 
                bool operator>=(const LED &other) const
                {
                    return m_value >= other.m_value;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const LED &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                double m_value{ 0.0 };
 
                friend struct DataModel::Detail::Befriend<LED>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Lens
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Temperature/Lens" };
 
                static constexpr const char *name{ "Lens" };
 
                static constexpr const char *description{ R"description(Lens temperature)description" };
 
                using ValueType = double;
 
                static constexpr Range<double> validRange()
                {
                    return { std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max() };
                }
 
                Lens() = default;
 
                explicit constexpr Lens(double value)
                    : m_value{ value }
                {}
 
                double value() const;
 
                std::string toString() const;
 
                bool operator==(const Lens &other) const
                {
                    return m_value == other.m_value;
                }
 
                bool operator!=(const Lens &other) const
                {
                    return m_value != other.m_value;
                }
 
                bool operator<(const Lens &other) const
                {
                    return m_value < other.m_value;
                }
 
                bool operator>(const Lens &other) const
                {
                    return m_value > other.m_value;
                }
 
                bool operator<=(const Lens &other) const
                {
                    return m_value <= other.m_value;
                }
 
                bool operator>=(const Lens &other) const
                {
                    return m_value >= other.m_value;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const Lens &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                double m_value{ 0.0 };
 
                friend struct DataModel::Detail::Befriend<Lens>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT PCB
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "Temperature/PCB" };
 
                static constexpr const char *name{ "PCB" };
 
                static constexpr const char *description{ R"description(PCB temperature)description" };
 
                using ValueType = double;
 
                static constexpr Range<double> validRange()
                {
                    return { std::numeric_limits<double>::lowest(), std::numeric_limits<double>::max() };
                }
 
                PCB() = default;
 
                explicit constexpr PCB(double value)
                    : m_value{ value }
                {}
 
                double value() const;
 
                std::string toString() const;
 
                bool operator==(const PCB &other) const
                {
                    return m_value == other.m_value;
                }
 
                bool operator!=(const PCB &other) const
                {
                    return m_value != other.m_value;
                }
 
                bool operator<(const PCB &other) const
                {
                    return m_value < other.m_value;
                }
 
                bool operator>(const PCB &other) const
                {
                    return m_value > other.m_value;
                }
 
                bool operator<=(const PCB &other) const
                {
                    return m_value <= other.m_value;
                }
 
                bool operator>=(const PCB &other) const
                {
                    return m_value >= other.m_value;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const PCB &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                double m_value{ 0.0 };
 
                friend struct DataModel::Detail::Befriend<PCB>;
            };
 
            using Descendants = std::tuple<
                CameraState::Temperature::DMD,
                CameraState::Temperature::General,
                CameraState::Temperature::LED,
                CameraState::Temperature::Lens,
                CameraState::Temperature::PCB>;
 
            Temperature();
 
#ifndef NO_DOC
            template<
                typename... Args,
                typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
                typename std::enable_if<
                    Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::
                        value,
                    int>::type = 0>
#else
            template<typename... Args>
#endif
            explicit Temperature(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to Temperature(...). "
                    "Types should be listed at most once.");
 
                set(std::forward<Args>(args)...);
            }
 
#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
            template<typename... Args>
#endif
            void set(Args &&...args)
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to set(...). "
                    "Types should be listed at most once.");
 
                Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
            }
 
#ifndef NO_DOC
            template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
            template<typename... Args>
#endif
            Temperature copyWith(Args &&...args) const
            {
                using namespace Zivid::Detail::TypeTraits;
 
                using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
                static_assert(
                    AllArgsAreDescendantNodes::value,
                    "All arguments passed to copyWith(...) must be descendant nodes.");
 
                static_assert(
                    AllArgsDecayedAreUnique<Args...>::value,
                    "Found duplicate types among the arguments passed to copyWith(...). "
                    "Types should be listed at most once.");
 
                auto copy{ *this };
                copy.set(std::forward<Args>(args)...);
                return copy;
            }
 
            const DMD &dmd() const
            {
                return m_dmd;
            }
 
            DMD &dmd()
            {
                return m_dmd;
            }
 
            Temperature &set(const DMD &value)
            {
                m_dmd = value;
                return *this;
            }
 
            const General &general() const
            {
                return m_general;
            }
 
            General &general()
            {
                return m_general;
            }
 
            Temperature &set(const General &value)
            {
                m_general = value;
                return *this;
            }
 
            const LED &led() const
            {
                return m_led;
            }
 
            LED &led()
            {
                return m_led;
            }
 
            Temperature &set(const LED &value)
            {
                m_led = value;
                return *this;
            }
 
            const Lens &lens() const
            {
                return m_lens;
            }
 
            Lens &lens()
            {
                return m_lens;
            }
 
            Temperature &set(const Lens &value)
            {
                m_lens = value;
                return *this;
            }
 
            const PCB &pcb() const
            {
                return m_pcb;
            }
 
            PCB &pcb()
            {
                return m_pcb;
            }
 
            Temperature &set(const PCB &value)
            {
                m_pcb = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraState::Temperature::DMD>::value, int>::type = 0>
            const CameraState::Temperature::DMD &get() const
            {
                return m_dmd;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraState::Temperature::General>::value, int>::type = 0>
            const CameraState::Temperature::General &get() const
            {
                return m_general;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraState::Temperature::LED>::value, int>::type = 0>
            const CameraState::Temperature::LED &get() const
            {
                return m_led;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraState::Temperature::Lens>::value, int>::type = 0>
            const CameraState::Temperature::Lens &get() const
            {
                return m_lens;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, CameraState::Temperature::PCB>::value, int>::type = 0>
            const CameraState::Temperature::PCB &get() const
            {
                return m_pcb;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const CameraState::Temperature::DMD &get() const
            {
                return m_dmd;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const CameraState::Temperature::General &get() const
            {
                return m_general;
            }
 
            template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
            const CameraState::Temperature::LED &get() const
            {
                return m_led;
            }
 
            template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
            const CameraState::Temperature::Lens &get() const
            {
                return m_lens;
            }
 
            template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
            const CameraState::Temperature::PCB &get() const
            {
                return m_pcb;
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                f(m_dmd);
                f(m_general);
                f(m_led);
                f(m_lens);
                f(m_pcb);
            }
 
            template<typename F>
            void forEach(const F &f)
            {
                f(m_dmd);
                f(m_general);
                f(m_led);
                f(m_lens);
                f(m_pcb);
            }
 
            bool operator==(const Temperature &other) const;
 
            bool operator!=(const Temperature &other) const;
 
            std::string toString() const;
 
            friend std::ostream &operator<<(std::ostream &stream, const Temperature &value)
            {
                return stream << value.toString();
            }
 
        private:
            void setFromString(const std::string &value);
 
            void setFromString(const std::string &fullPath, const std::string &value);
 
            std::string getString(const std::string &fullPath) const;
 
            DMD m_dmd;
            General m_general;
            LED m_led;
            Lens m_lens;
            PCB m_pcb;
 
            friend struct DataModel::Detail::Befriend<Temperature>;
        };
 
        using Descendants = std::tuple<
            CameraState::Available,
            CameraState::Connected,
            CameraState::InaccessibleReason,
            CameraState::Network,
            CameraState::Network::IPV4,
            CameraState::Network::IPV4::Address,
            CameraState::Status,
            CameraState::Temperature,
            CameraState::Temperature::DMD,
            CameraState::Temperature::General,
            CameraState::Temperature::LED,
            CameraState::Temperature::Lens,
            CameraState::Temperature::PCB>;
 
        CameraState();
 
        explicit CameraState(const std::string &fileName);
 
#ifndef NO_DOC
        template<
            typename... Args,
            typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0,
            typename std::enable_if<
                Zivid::Detail::TypeTraits::AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>::value,
                int>::type = 0>
#else
        template<typename... Args>
#endif
        explicit CameraState(Args &&...args)
        {
            using namespace Zivid::Detail::TypeTraits;
 
            static_assert(
                AllArgsDecayedAreUnique<Args...>::value,
                "Found duplicate types among the arguments passed to CameraState(...). "
                "Types should be listed at most once.");
 
            set(std::forward<Args>(args)...);
        }
 
#ifndef NO_DOC
        template<typename... Args, typename std::enable_if<sizeof...(Args) >= 2, int>::type = 0>
#else
        template<typename... Args>
#endif
        void set(Args &&...args)
        {
            using namespace Zivid::Detail::TypeTraits;
 
            using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
            static_assert(
                AllArgsAreDescendantNodes::value, "All arguments passed to set(...) must be descendant nodes.");
 
            static_assert(
                AllArgsDecayedAreUnique<Args...>::value,
                "Found duplicate types among the arguments passed to set(...). "
                "Types should be listed at most once.");
 
            Zivid::DataModel::Detail::invokeSetWithEachArgument(*this, std::forward<Args>(args)...);
        }
 
#ifndef NO_DOC
        template<typename... Args, typename std::enable_if<sizeof...(Args) >= 1, int>::type = 0>
#else
        template<typename... Args>
#endif
        CameraState copyWith(Args &&...args) const
        {
            using namespace Zivid::Detail::TypeTraits;
 
            using AllArgsAreDescendantNodes = AllArgsAreInTuple<Descendants, typename std::decay<Args>::type...>;
            static_assert(
                AllArgsAreDescendantNodes::value, "All arguments passed to copyWith(...) must be descendant nodes.");
 
            static_assert(
                AllArgsDecayedAreUnique<Args...>::value,
                "Found duplicate types among the arguments passed to copyWith(...). "
                "Types should be listed at most once.");
 
            auto copy{ *this };
            copy.set(std::forward<Args>(args)...);
            return copy;
        }
 
        const Available &isAvailable() const
        {
            return m_available;
        }
 
        Available &isAvailable()
        {
            return m_available;
        }
 
        CameraState &set(const Available &value)
        {
            m_available = value;
            return *this;
        }
 
        const Connected &isConnected() const
        {
            return m_connected;
        }
 
        Connected &isConnected()
        {
            return m_connected;
        }
 
        CameraState &set(const Connected &value)
        {
            m_connected = value;
            return *this;
        }
 
        const InaccessibleReason &inaccessibleReason() const
        {
            return m_inaccessibleReason;
        }
 
        InaccessibleReason &inaccessibleReason()
        {
            return m_inaccessibleReason;
        }
 
        CameraState &set(const InaccessibleReason &value)
        {
            m_inaccessibleReason = value;
            return *this;
        }
 
        const Network &network() const
        {
            return m_network;
        }
 
        Network &network()
        {
            return m_network;
        }
 
        CameraState &set(const Network &value)
        {
            m_network = value;
            return *this;
        }
 
        CameraState &set(const Network::IPV4 &value)
        {
            m_network.set(value);
            return *this;
        }
 
        CameraState &set(const Network::IPV4::Address &value)
        {
            m_network.set(value);
            return *this;
        }
 
        const Status &status() const
        {
            return m_status;
        }
 
        Status &status()
        {
            return m_status;
        }
 
        CameraState &set(const Status &value)
        {
            m_status = value;
            return *this;
        }
 
        const Temperature &temperature() const
        {
            return m_temperature;
        }
 
        Temperature &temperature()
        {
            return m_temperature;
        }
 
        CameraState &set(const Temperature &value)
        {
            m_temperature = value;
            return *this;
        }
 
        CameraState &set(const Temperature::DMD &value)
        {
            m_temperature.set(value);
            return *this;
        }
 
        CameraState &set(const Temperature::General &value)
        {
            m_temperature.set(value);
            return *this;
        }
 
        CameraState &set(const Temperature::LED &value)
        {
            m_temperature.set(value);
            return *this;
        }
 
        CameraState &set(const Temperature::Lens &value)
        {
            m_temperature.set(value);
            return *this;
        }
 
        CameraState &set(const Temperature::PCB &value)
        {
            m_temperature.set(value);
            return *this;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, CameraState::Available>::value, int>::type = 0>
        const CameraState::Available &get() const
        {
            return m_available;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, CameraState::Connected>::value, int>::type = 0>
        const CameraState::Connected &get() const
        {
            return m_connected;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraState::InaccessibleReason>::value, int>::type = 0>
        const CameraState::InaccessibleReason &get() const
        {
            return m_inaccessibleReason;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, CameraState::Network>::value, int>::type = 0>
        const CameraState::Network &get() const
        {
            return m_network;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, CameraState::Network::IPV4>::value, int>::type = 0>
        const CameraState::Network::IPV4 &get() const
        {
            return m_network.get<CameraState::Network::IPV4>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraState::Network::IPV4::Address>::value, int>::type = 0>
        const CameraState::Network::IPV4::Address &get() const
        {
            return m_network.get<CameraState::Network::IPV4::Address>();
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, CameraState::Status>::value, int>::type = 0>
        const CameraState::Status &get() const
        {
            return m_status;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, CameraState::Temperature>::value, int>::type = 0>
        const CameraState::Temperature &get() const
        {
            return m_temperature;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraState::Temperature::DMD>::value, int>::type = 0>
        const CameraState::Temperature::DMD &get() const
        {
            return m_temperature.get<CameraState::Temperature::DMD>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraState::Temperature::General>::value, int>::type = 0>
        const CameraState::Temperature::General &get() const
        {
            return m_temperature.get<CameraState::Temperature::General>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraState::Temperature::LED>::value, int>::type = 0>
        const CameraState::Temperature::LED &get() const
        {
            return m_temperature.get<CameraState::Temperature::LED>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraState::Temperature::Lens>::value, int>::type = 0>
        const CameraState::Temperature::Lens &get() const
        {
            return m_temperature.get<CameraState::Temperature::Lens>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, CameraState::Temperature::PCB>::value, int>::type = 0>
        const CameraState::Temperature::PCB &get() const
        {
            return m_temperature.get<CameraState::Temperature::PCB>();
        }
 
        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
        const CameraState::Available &get() const
        {
            return m_available;
        }
 
        template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
        const CameraState::Connected &get() const
        {
            return m_connected;
        }
 
        template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
        const CameraState::InaccessibleReason &get() const
        {
            return m_inaccessibleReason;
        }
 
        template<size_t i, typename std::enable_if<i == 3, int>::type = 0>
        const CameraState::Network &get() const
        {
            return m_network;
        }
 
        template<size_t i, typename std::enable_if<i == 4, int>::type = 0>
        const CameraState::Status &get() const
        {
            return m_status;
        }
 
        template<size_t i, typename std::enable_if<i == 5, int>::type = 0>
        const CameraState::Temperature &get() const
        {
            return m_temperature;
        }
 
        template<typename F>
        void forEach(const F &f) const
        {
            f(m_available);
            f(m_connected);
            f(m_inaccessibleReason);
            f(m_network);
            f(m_status);
            f(m_temperature);
        }
 
        template<typename F>
        void forEach(const F &f)
        {
            f(m_available);
            f(m_connected);
            f(m_inaccessibleReason);
            f(m_network);
            f(m_status);
            f(m_temperature);
        }
 
        bool operator==(const CameraState &other) const;
 
        bool operator!=(const CameraState &other) const;
 
        std::string toString() const;
 
        friend std::ostream &operator<<(std::ostream &stream, const CameraState &value)
        {
            return stream << value.toString();
        }
 
        void save(const std::string &fileName) const;
 
        void load(const std::string &fileName);
 
    private:
        void setFromString(const std::string &value);
 
        void setFromString(const std::string &fullPath, const std::string &value);
 
        std::string getString(const std::string &fullPath) const;
 
        Available m_available;
        Connected m_connected;
        InaccessibleReason m_inaccessibleReason;
        Network m_network;
        Status m_status;
        Temperature m_temperature;
 
        friend struct DataModel::Detail::Befriend<CameraState>;
    };
 
#ifndef NO_DOC
    namespace Detail
    {
        ZIVID_CORE_EXPORT void save(const CameraState &dataModel, std::ostream &ostream);
        ZIVID_CORE_EXPORT void load(CameraState &dataModel, std::istream &istream);
    } // namespace Detail
#endif
 
#ifndef NO_DOC
    template<>
    struct CameraState::Version<5>
    {
        using Type = CameraState;
    };
#endif
 
} // namespace Zivid
 
#ifdef _MSC_VER
#    pragma warning(pop)
#endif
 
#ifndef NO_DOC
#    if !(defined(_MSC_VER) && (_MSC_VER <= 1900))
namespace std // NOLINT
{
 
    template<>
    struct tuple_size<Zivid::CameraState::Network> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraState::Network>
    {
        static_assert(i < tuple_size<Zivid::CameraState::Network>::value, "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraState::Network>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::CameraState::Network::IPV4> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraState::Network::IPV4>
    {
        static_assert(i < tuple_size<Zivid::CameraState::Network::IPV4>::value, "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraState::Network::IPV4>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::CameraState::Temperature> : integral_constant<size_t, 5>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraState::Temperature>
    {
        static_assert(i < tuple_size<Zivid::CameraState::Temperature>::value, "Index must be less than 5");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraState::Temperature>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::CameraState> : integral_constant<size_t, 6>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::CameraState>
    {
        static_assert(i < tuple_size<Zivid::CameraState>::value, "Index must be less than 6");
 
        using type // NOLINT
            = decltype(declval<Zivid::CameraState>().get<i>());
    };
 
} // namespace std
#    endif
#endif
 
// If we have access to the DataModel library, automatically include internal DataModel
// header. This header is necessary for serialization and deserialization.
#if defined(__has_include) && !defined(NO_DOC)
#    if __has_include("Zivid/CameraStateInternal.h") && __has_include("Zivid/DataModelNodeMetaData.h")
#        include "Zivid/CameraStateInternal.h"
#    endif
#endif