NetworkConfiguration.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/Detail/Validator.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 NetworkConfiguration
    {
    public:
        static constexpr DataModel::NodeType nodeType = DataModel::NodeType::group;
 
        static constexpr const char *path{ "" };
 
        static constexpr const char *name{ "NetworkConfiguration" };
 
        static constexpr const char *description{ R"description(Network configuration of a camera
)description" };
 
        static constexpr size_t version{ 1 };
 
#ifndef NO_DOC
        template<size_t>
        struct Version;
 
        using LatestVersion = Zivid::NetworkConfiguration;
 
        // 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', 'n', 'c' };
 
#endif
 
 
        // 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{ "IPV4" };
 
            static constexpr const char *name{ "IPV4" };
 
            static constexpr const char *description{ R"description(IPv4 network configuration)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{ "IPV4/Address" };
 
                static constexpr const char *name{ "Address" };
 
                static constexpr const char *description{
                    R"description(The camera's IPv4 address. Only used in manual mode.
 
To be able to connect to the camera, the camera's IP address must be in the same subnet as the IP
address of the computer's local network interface.
)description"
                };
 
                using ValueType = std::string;
 
                Address() = default;
 
                explicit Address(std::string value)
                    : m_value{ verifyValue(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);
 
                ValueType static verifyValue(ValueType &&value)
                {
                    return DataModel::Detail::isValidIPv4Address(value)
                               ? std::move(value)
                               : throw std::invalid_argument{ "The value '" + value
                                                              + "' is not a valid IPv4 address." };
                }
 
                std::string m_value{ "172.28.60.5" };
 
                friend struct DataModel::Detail::Befriend<Address>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT Mode
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "IPV4/Mode" };
 
                static constexpr const char *name{ "Mode" };
 
                static constexpr const char *description{ R"description(DHCP or manual configuration)description" };
 
                enum class ValueType
                {
                    dhcp,
                    manual
                };
                static const Mode dhcp;   
                static const Mode manual; 
 
                static std::set<ValueType> validValues()
                {
                    return { ValueType::dhcp, ValueType::manual };
                }
 
                Mode() = default;
 
                explicit constexpr Mode(ValueType value)
                    : m_value{ verifyValue(value) }
                {}
 
                ValueType value() const;
 
                std::string toString() const;
 
                friend std::ostream &operator<<(std::ostream &stream, const Mode::ValueType &value)
                {
                    return stream << Mode{ value }.toString();
                }
 
                bool operator==(const Mode &other) const
                {
                    return m_value == other.m_value;
                }
 
                bool operator!=(const Mode &other) const
                {
                    return m_value != other.m_value;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const Mode &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                constexpr ValueType static verifyValue(const ValueType &value)
                {
                    return value == ValueType::dhcp || value == ValueType::manual
                               ? value
                               : throw std::invalid_argument{
                                     "Invalid value: Mode{ "
                                     + std::to_string(static_cast<std::underlying_type<ValueType>::type>(value)) + " }"
                                 };
                }
 
                ValueType m_value{ ValueType::manual };
 
                friend struct DataModel::Detail::Befriend<Mode>;
            };
 
 
            // NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
            class ZIVID_CORE_EXPORT SubnetMask
            {
            public:
                static constexpr DataModel::NodeType nodeType = DataModel::NodeType::leafValue;
 
                static constexpr const char *path{ "IPV4/SubnetMask" };
 
                static constexpr const char *name{ "SubnetMask" };
 
                static constexpr const char *description{
                    R"description(The camera's subnet mask (for example 255.255.255.0). Only used in manual mode.
 
To be able to connect to the camera, the camera's subnet mask must be the same as the subnet mask of the
computer's local network interface.
)description"
                };
 
                using ValueType = std::string;
 
                SubnetMask() = default;
 
                explicit SubnetMask(std::string value)
                    : m_value{ verifyValue(std::move(value)) }
                {}
 
                const std::string &value() const;
 
                std::string toString() const;
 
                bool operator==(const SubnetMask &other) const
                {
                    return m_value == other.m_value;
                }
 
                bool operator!=(const SubnetMask &other) const
                {
                    return m_value != other.m_value;
                }
 
                bool operator<(const SubnetMask &other) const
                {
                    return m_value < other.m_value;
                }
 
                bool operator>(const SubnetMask &other) const
                {
                    return m_value > other.m_value;
                }
 
                bool operator<=(const SubnetMask &other) const
                {
                    return m_value <= other.m_value;
                }
 
                bool operator>=(const SubnetMask &other) const
                {
                    return m_value >= other.m_value;
                }
 
                friend std::ostream &operator<<(std::ostream &stream, const SubnetMask &value)
                {
                    return stream << value.toString();
                }
 
            private:
                void setFromString(const std::string &value);
 
                ValueType static verifyValue(ValueType &&value)
                {
                    return DataModel::Detail::isValidIPv4SubnetMask(value)
                               ? std::move(value)
                               : throw std::invalid_argument{ "The value '" + value
                                                              + "' is not a valid IPv4 subnet mask." };
                }
 
                std::string m_value{ "255.255.255.0" };
 
                friend struct DataModel::Detail::Befriend<SubnetMask>;
            };
 
            using Descendants = std::tuple<
                NetworkConfiguration::IPV4::Address,
                NetworkConfiguration::IPV4::Mode,
                NetworkConfiguration::IPV4::SubnetMask>;
 
            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;
            }
 
            const Mode &mode() const
            {
                return m_mode;
            }
 
            Mode &mode()
            {
                return m_mode;
            }
 
            IPV4 &set(const Mode &value)
            {
                m_mode = value;
                return *this;
            }
 
            const SubnetMask &subnetMask() const
            {
                return m_subnetMask;
            }
 
            SubnetMask &subnetMask()
            {
                return m_subnetMask;
            }
 
            IPV4 &set(const SubnetMask &value)
            {
                m_subnetMask = value;
                return *this;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, NetworkConfiguration::IPV4::Address>::value, int>::type = 0>
            const NetworkConfiguration::IPV4::Address &get() const
            {
                return m_address;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, NetworkConfiguration::IPV4::Mode>::value, int>::type = 0>
            const NetworkConfiguration::IPV4::Mode &get() const
            {
                return m_mode;
            }
 
            template<
                typename T,
                typename std::enable_if<std::is_same<T, NetworkConfiguration::IPV4::SubnetMask>::value, int>::type = 0>
            const NetworkConfiguration::IPV4::SubnetMask &get() const
            {
                return m_subnetMask;
            }
 
            template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
            const NetworkConfiguration::IPV4::Address &get() const
            {
                return m_address;
            }
 
            template<size_t i, typename std::enable_if<i == 1, int>::type = 0>
            const NetworkConfiguration::IPV4::Mode &get() const
            {
                return m_mode;
            }
 
            template<size_t i, typename std::enable_if<i == 2, int>::type = 0>
            const NetworkConfiguration::IPV4::SubnetMask &get() const
            {
                return m_subnetMask;
            }
 
            template<typename F>
            void forEach(const F &f) const
            {
                f(m_address);
                f(m_mode);
                f(m_subnetMask);
            }
 
            template<typename F>
            void forEach(const F &f)
            {
                f(m_address);
                f(m_mode);
                f(m_subnetMask);
            }
 
            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;
            Mode m_mode;
            SubnetMask m_subnetMask;
 
            friend struct DataModel::Detail::Befriend<IPV4>;
        };
 
        using Descendants = std::tuple<
            NetworkConfiguration::IPV4,
            NetworkConfiguration::IPV4::Address,
            NetworkConfiguration::IPV4::Mode,
            NetworkConfiguration::IPV4::SubnetMask>;
 
        NetworkConfiguration();
 
        explicit NetworkConfiguration(const std::string &fileName);
 
        [[nodiscard]] static NetworkConfiguration fromSerialized(const std::string &value);
 
        std::string serialize() const;
 
#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 NetworkConfiguration(Args &&...args)
        {
            using namespace Zivid::Detail::TypeTraits;
 
            static_assert(
                AllArgsDecayedAreUnique<Args...>::value,
                "Found duplicate types among the arguments passed to NetworkConfiguration(...). "
                "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
        NetworkConfiguration 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;
        }
 
        NetworkConfiguration &set(const IPV4 &value)
        {
            m_ipv4 = value;
            return *this;
        }
 
        NetworkConfiguration &set(const IPV4::Address &value)
        {
            m_ipv4.set(value);
            return *this;
        }
 
        NetworkConfiguration &set(const IPV4::Mode &value)
        {
            m_ipv4.set(value);
            return *this;
        }
 
        NetworkConfiguration &set(const IPV4::SubnetMask &value)
        {
            m_ipv4.set(value);
            return *this;
        }
 
        template<typename T, typename std::enable_if<std::is_same<T, NetworkConfiguration::IPV4>::value, int>::type = 0>
        const NetworkConfiguration::IPV4 &get() const
        {
            return m_ipv4;
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, NetworkConfiguration::IPV4::Address>::value, int>::type = 0>
        const NetworkConfiguration::IPV4::Address &get() const
        {
            return m_ipv4.get<NetworkConfiguration::IPV4::Address>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, NetworkConfiguration::IPV4::Mode>::value, int>::type = 0>
        const NetworkConfiguration::IPV4::Mode &get() const
        {
            return m_ipv4.get<NetworkConfiguration::IPV4::Mode>();
        }
 
        template<
            typename T,
            typename std::enable_if<std::is_same<T, NetworkConfiguration::IPV4::SubnetMask>::value, int>::type = 0>
        const NetworkConfiguration::IPV4::SubnetMask &get() const
        {
            return m_ipv4.get<NetworkConfiguration::IPV4::SubnetMask>();
        }
 
        template<size_t i, typename std::enable_if<i == 0, int>::type = 0>
        const NetworkConfiguration::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 NetworkConfiguration &other) const;
 
        bool operator!=(const NetworkConfiguration &other) const;
 
        std::string toString() const;
 
        friend std::ostream &operator<<(std::ostream &stream, const NetworkConfiguration &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;
 
        IPV4 m_ipv4;
 
        friend struct DataModel::Detail::Befriend<NetworkConfiguration>;
    };
 
#ifndef NO_DOC
    template<>
    struct NetworkConfiguration::Version<1>
    {
        using Type = NetworkConfiguration;
    };
#endif
 
} // namespace Zivid
 
#ifndef NO_DOC
namespace Zivid::Detail
{
 
    ZIVID_CORE_EXPORT void save(const Zivid::NetworkConfiguration &dataModel, std::ostream &ostream);
    ZIVID_CORE_EXPORT void load(Zivid::NetworkConfiguration &dataModel, std::istream &istream);
 
    ZIVID_CORE_EXPORT std::vector<uint8_t> serializeToBinaryVector(const Zivid::NetworkConfiguration &source);
    ZIVID_CORE_EXPORT void deserializeFromBinaryVector(
        Zivid::NetworkConfiguration &dest,
        const std::vector<uint8_t> &data);
 
} // namespace Zivid::Detail
#endif
 
#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::NetworkConfiguration::IPV4> : integral_constant<size_t, 3>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::NetworkConfiguration::IPV4>
    {
        static_assert(i < tuple_size<Zivid::NetworkConfiguration::IPV4>::value, "Index must be less than 3");
 
        using type // NOLINT
            = decltype(declval<Zivid::NetworkConfiguration::IPV4>().get<i>());
    };
 
    template<>
    struct tuple_size<Zivid::NetworkConfiguration> : integral_constant<size_t, 1>
    {};
 
    template<size_t i>
    struct tuple_element<i, Zivid::NetworkConfiguration>
    {
        static_assert(i < tuple_size<Zivid::NetworkConfiguration>::value, "Index must be less than 1");
 
        using type // NOLINT
            = decltype(declval<Zivid::NetworkConfiguration>().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/NetworkConfigurationInternal.h") && __has_include("Zivid/DataModelNodeMetaData.h")
#        include "Zivid/NetworkConfigurationInternal.h"
#    endif
#endif