FrameInfo.h

Go to the documentation of this file.

/*[
 * This file is part of the Zivid 3D Camera API
 *
 * Copyright 2015-2018 (C) Zivid Labs. All rights reserved.
 * Contact info@zividlabs.com or see http://www.zividlabs.com
 * 
 * This code is proprietary and confidential.
 * Unauthorized copying of this file, via any medium is strictly prohibited.
]*/

#pragma once


#include <chrono>
#include <ctime>
#include <iomanip>
#include <memory>
#include <ostream>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

#include "APIExport.h"
#include "Range.h"

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4251)
#endif

namespace Zivid {
class ZIVID_COMMON FrameInfo {
public:
  FrameInfo() = default;

  explicit FrameInfo(const std::string &fileName);

  static constexpr bool isContainer{true};

  static constexpr const char *path{""};

  static constexpr const char *name{"FrameInfo"};

  void set(const std::string &fullPath, const std::string &value);

  std::string getString(const std::string &fullPath) const;

  class ZIVID_COMMON TimeStamp {
  public:
    using ValueType = std::chrono::system_clock::time_point;

    static constexpr bool isContainer{false};

    static constexpr const char *path{"TimeStamp"};

    static constexpr const char *name{"TimeStamp"};

    TimeStamp() = default;

    explicit constexpr TimeStamp(ValueType value) noexcept(
        std::is_nothrow_move_constructible<ValueType>::value)
        : m_value{value} {}

    const ValueType &value() const { return m_value; }

    Range<ValueType> range() const {
      return {std::numeric_limits<ValueType>::lowest(),
              std::numeric_limits<ValueType>::max()};
    }

    void setFromString(const std::string &value);

    std::string toString() const;

    bool operator==(const TimeStamp &other) const {
      return m_value == other.m_value;
    }

    bool operator!=(const TimeStamp &other) const {
      return m_value != other.m_value;
    }

    bool operator<(const TimeStamp &other) const {
      return m_value < other.m_value;
    }

    bool operator>(const TimeStamp &other) const {
      return m_value > other.m_value;
    }

    friend std::ostream &operator<<(std::ostream &stream,
                                    const TimeStamp &value) {
      return stream << value.toString();
    }

    friend std::istream &operator>>(std::istream &stream, TimeStamp &value) {
      value.setFromString(std::string{std::istreambuf_iterator<char>{stream},
                                      std::istreambuf_iterator<char>{}});
      return stream;
    }

  private:
    ValueType m_value{};
  };

  class ZIVID_COMMON SoftwareVersion {
  public:
    SoftwareVersion() = default;

    explicit SoftwareVersion(const std::string &fileName);

    static constexpr bool isContainer{true};

    static constexpr const char *path{"SoftwareVersion"};

    static constexpr const char *name{"SoftwareVersion"};

    void set(const std::string &fullPath, const std::string &value);

    std::string getString(const std::string &fullPath) const;

    class ZIVID_COMMON ZividStudio {
    public:
      ZividStudio() = default;

      explicit ZividStudio(const std::string &fileName);

      static constexpr bool isContainer{true};

      static constexpr const char *path{"SoftwareVersion/ZividStudio"};

      static constexpr const char *name{"ZividStudio"};

      void set(const std::string &fullPath, const std::string &value);

      std::string getString(const std::string &fullPath) const;

      class ZIVID_COMMON FileDescription {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividStudio/FileDescription"};

        static constexpr const char *name{"FileDescription"};

        FileDescription() = default;

        explicit FileDescription(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const FileDescription &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const FileDescription &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const FileDescription &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const FileDescription &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const FileDescription &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream,
                                        FileDescription &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

      class ZIVID_COMMON FileVersion {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividStudio/FileVersion"};

        static constexpr const char *name{"FileVersion"};

        FileVersion() = default;

        explicit FileVersion(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const FileVersion &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const FileVersion &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const FileVersion &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const FileVersion &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const FileVersion &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream,
                                        FileVersion &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

      class ZIVID_COMMON ProductVersion {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividStudio/ProductVersion"};

        static constexpr const char *name{"ProductVersion"};

        ProductVersion() = default;

        explicit ProductVersion(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const ProductVersion &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const ProductVersion &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const ProductVersion &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const ProductVersion &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const ProductVersion &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream,
                                        ProductVersion &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

      class ZIVID_COMMON Comments {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividStudio/Comments"};

        static constexpr const char *name{"Comments"};

        Comments() = default;

        explicit Comments(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const Comments &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const Comments &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const Comments &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const Comments &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const Comments &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream, Comments &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

    private:
      FileDescription m_fileDescription{};

    public:
      ZividStudio &set(const FileDescription &value) {

        m_fileDescription = value;
        return *this;
      }
      const FileDescription &fileDescription() const {
        return m_fileDescription;
      }

    private:
      FileVersion m_fileVersion{};

    public:
      ZividStudio &set(const FileVersion &value) {

        m_fileVersion = value;
        return *this;
      }
      const FileVersion &fileVersion() const { return m_fileVersion; }

    private:
      ProductVersion m_productVersion{};

    public:
      ZividStudio &set(const ProductVersion &value) {

        m_productVersion = value;
        return *this;
      }
      const ProductVersion &productVersion() const { return m_productVersion; }

    private:
      Comments m_comments{};

    public:
      ZividStudio &set(const Comments &value) {

        m_comments = value;
        return *this;
      }
      const Comments &comments() const { return m_comments; }

      template <typename F> void forEach(const F &f) const {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      template <typename F> void forEach(const F &f) {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      template <typename F> void traverseValues(const F &f) const {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      template <typename F> void traverseValues(const F &f) {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      std::string toString() const;

      friend std::ostream &operator<<(std::ostream &stream,
                                      const ZividStudio &value) {
        return stream << value.toString();
      }

      void save(const std::string &fileName) const;

      void setFromString(const std::string &value);

      friend std::istream &operator>>(std::istream &stream,
                                      ZividStudio &value) {
        value.setFromString(std::string{std::istreambuf_iterator<char>{stream},
                                        std::istreambuf_iterator<char>{}});
        return stream;
      }

      void load(const std::string &fileName);

      bool operator==(const ZividStudio &other) const;

      bool operator!=(const ZividStudio &other) const;
    };

    class ZIVID_COMMON ZividAPI {
    public:
      ZividAPI() = default;

      explicit ZividAPI(const std::string &fileName);

      static constexpr bool isContainer{true};

      static constexpr const char *path{"SoftwareVersion/ZividAPI"};

      static constexpr const char *name{"ZividAPI"};

      void set(const std::string &fullPath, const std::string &value);

      std::string getString(const std::string &fullPath) const;

      class ZIVID_COMMON FileDescription {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividAPI/FileDescription"};

        static constexpr const char *name{"FileDescription"};

        FileDescription() = default;

        explicit FileDescription(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const FileDescription &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const FileDescription &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const FileDescription &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const FileDescription &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const FileDescription &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream,
                                        FileDescription &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

      class ZIVID_COMMON FileVersion {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividAPI/FileVersion"};

        static constexpr const char *name{"FileVersion"};

        FileVersion() = default;

        explicit FileVersion(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const FileVersion &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const FileVersion &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const FileVersion &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const FileVersion &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const FileVersion &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream,
                                        FileVersion &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

      class ZIVID_COMMON ProductVersion {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividAPI/ProductVersion"};

        static constexpr const char *name{"ProductVersion"};

        ProductVersion() = default;

        explicit ProductVersion(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const ProductVersion &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const ProductVersion &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const ProductVersion &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const ProductVersion &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const ProductVersion &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream,
                                        ProductVersion &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

      class ZIVID_COMMON Comments {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{"SoftwareVersion/ZividAPI/Comments"};

        static constexpr const char *name{"Comments"};

        Comments() = default;

        explicit Comments(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const Comments &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const Comments &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const Comments &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const Comments &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const Comments &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream, Comments &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

    private:
      FileDescription m_fileDescription{};

    public:
      ZividAPI &set(const FileDescription &value) {

        m_fileDescription = value;
        return *this;
      }
      const FileDescription &fileDescription() const {
        return m_fileDescription;
      }

    private:
      FileVersion m_fileVersion{};

    public:
      ZividAPI &set(const FileVersion &value) {

        m_fileVersion = value;
        return *this;
      }
      const FileVersion &fileVersion() const { return m_fileVersion; }

    private:
      ProductVersion m_productVersion{};

    public:
      ZividAPI &set(const ProductVersion &value) {

        m_productVersion = value;
        return *this;
      }
      const ProductVersion &productVersion() const { return m_productVersion; }

    private:
      Comments m_comments{};

    public:
      ZividAPI &set(const Comments &value) {

        m_comments = value;
        return *this;
      }
      const Comments &comments() const { return m_comments; }

      template <typename F> void forEach(const F &f) const {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      template <typename F> void forEach(const F &f) {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      template <typename F> void traverseValues(const F &f) const {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      template <typename F> void traverseValues(const F &f) {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      std::string toString() const;

      friend std::ostream &operator<<(std::ostream &stream,
                                      const ZividAPI &value) {
        return stream << value.toString();
      }

      void save(const std::string &fileName) const;

      void setFromString(const std::string &value);

      friend std::istream &operator>>(std::istream &stream, ZividAPI &value) {
        value.setFromString(std::string{std::istreambuf_iterator<char>{stream},
                                        std::istreambuf_iterator<char>{}});
        return stream;
      }

      void load(const std::string &fileName);

      bool operator==(const ZividAPI &other) const;

      bool operator!=(const ZividAPI &other) const;
    };

    class ZIVID_COMMON ZividCameraToshibaTeli {
    public:
      ZividCameraToshibaTeli() = default;

      explicit ZividCameraToshibaTeli(const std::string &fileName);

      static constexpr bool isContainer{true};

      static constexpr const char *path{
          "SoftwareVersion/ZividCameraToshibaTeli"};

      static constexpr const char *name{"ZividCameraToshibaTeli"};

      void set(const std::string &fullPath, const std::string &value);

      std::string getString(const std::string &fullPath) const;

      class ZIVID_COMMON FileDescription {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividCameraToshibaTeli/FileDescription"};

        static constexpr const char *name{"FileDescription"};

        FileDescription() = default;

        explicit FileDescription(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const FileDescription &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const FileDescription &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const FileDescription &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const FileDescription &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const FileDescription &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream,
                                        FileDescription &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

      class ZIVID_COMMON FileVersion {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividCameraToshibaTeli/FileVersion"};

        static constexpr const char *name{"FileVersion"};

        FileVersion() = default;

        explicit FileVersion(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const FileVersion &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const FileVersion &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const FileVersion &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const FileVersion &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const FileVersion &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream,
                                        FileVersion &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

      class ZIVID_COMMON ProductVersion {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividCameraToshibaTeli/ProductVersion"};

        static constexpr const char *name{"ProductVersion"};

        ProductVersion() = default;

        explicit ProductVersion(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const ProductVersion &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const ProductVersion &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const ProductVersion &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const ProductVersion &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const ProductVersion &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream,
                                        ProductVersion &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

      class ZIVID_COMMON Comments {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividCameraToshibaTeli/Comments"};

        static constexpr const char *name{"Comments"};

        Comments() = default;

        explicit Comments(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const Comments &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const Comments &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const Comments &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const Comments &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const Comments &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream, Comments &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

    private:
      FileDescription m_fileDescription{};

    public:
      ZividCameraToshibaTeli &set(const FileDescription &value) {

        m_fileDescription = value;
        return *this;
      }
      const FileDescription &fileDescription() const {
        return m_fileDescription;
      }

    private:
      FileVersion m_fileVersion{};

    public:
      ZividCameraToshibaTeli &set(const FileVersion &value) {

        m_fileVersion = value;
        return *this;
      }
      const FileVersion &fileVersion() const { return m_fileVersion; }

    private:
      ProductVersion m_productVersion{};

    public:
      ZividCameraToshibaTeli &set(const ProductVersion &value) {

        m_productVersion = value;
        return *this;
      }
      const ProductVersion &productVersion() const { return m_productVersion; }

    private:
      Comments m_comments{};

    public:
      ZividCameraToshibaTeli &set(const Comments &value) {

        m_comments = value;
        return *this;
      }
      const Comments &comments() const { return m_comments; }

      template <typename F> void forEach(const F &f) const {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      template <typename F> void forEach(const F &f) {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      template <typename F> void traverseValues(const F &f) const {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      template <typename F> void traverseValues(const F &f) {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      std::string toString() const;

      friend std::ostream &operator<<(std::ostream &stream,
                                      const ZividCameraToshibaTeli &value) {
        return stream << value.toString();
      }

      void save(const std::string &fileName) const;

      void setFromString(const std::string &value);

      friend std::istream &operator>>(std::istream &stream,
                                      ZividCameraToshibaTeli &value) {
        value.setFromString(std::string{std::istreambuf_iterator<char>{stream},
                                        std::istreambuf_iterator<char>{}});
        return stream;
      }

      void load(const std::string &fileName);

      bool operator==(const ZividCameraToshibaTeli &other) const;

      bool operator!=(const ZividCameraToshibaTeli &other) const;
    };

    class ZIVID_COMMON ZividCameraFile {
    public:
      ZividCameraFile() = default;

      explicit ZividCameraFile(const std::string &fileName);

      static constexpr bool isContainer{true};

      static constexpr const char *path{"SoftwareVersion/ZividCameraFile"};

      static constexpr const char *name{"ZividCameraFile"};

      void set(const std::string &fullPath, const std::string &value);

      std::string getString(const std::string &fullPath) const;

      class ZIVID_COMMON FileDescription {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividCameraFile/FileDescription"};

        static constexpr const char *name{"FileDescription"};

        FileDescription() = default;

        explicit FileDescription(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const FileDescription &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const FileDescription &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const FileDescription &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const FileDescription &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const FileDescription &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream,
                                        FileDescription &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

      class ZIVID_COMMON FileVersion {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividCameraFile/FileVersion"};

        static constexpr const char *name{"FileVersion"};

        FileVersion() = default;

        explicit FileVersion(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const FileVersion &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const FileVersion &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const FileVersion &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const FileVersion &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const FileVersion &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream,
                                        FileVersion &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

      class ZIVID_COMMON ProductVersion {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividCameraFile/ProductVersion"};

        static constexpr const char *name{"ProductVersion"};

        ProductVersion() = default;

        explicit ProductVersion(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const ProductVersion &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const ProductVersion &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const ProductVersion &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const ProductVersion &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const ProductVersion &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream,
                                        ProductVersion &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

      class ZIVID_COMMON Comments {
      public:
        using ValueType = std::string;

        static constexpr bool isContainer{false};

        static constexpr const char *path{
            "SoftwareVersion/ZividCameraFile/Comments"};

        static constexpr const char *name{"Comments"};

        Comments() = default;

        explicit Comments(ValueType value) noexcept(
            std::is_nothrow_move_constructible<ValueType>::value)
            : m_value{std::move(value)} {}

        const ValueType &value() const { return m_value; }

        void setFromString(const std::string &value) { m_value = value; }

        std::string toString() const { return m_value; }

        bool operator==(const Comments &other) const {
          return m_value == other.m_value;
        }

        bool operator!=(const Comments &other) const {
          return m_value != other.m_value;
        }

        bool operator<(const Comments &other) const {
          return m_value < other.m_value;
        }

        bool operator>(const Comments &other) const {
          return m_value > other.m_value;
        }

        friend std::ostream &operator<<(std::ostream &stream,
                                        const Comments &value) {
          return stream << value.toString();
        }

        friend std::istream &operator>>(std::istream &stream, Comments &value) {
          value.setFromString(
              std::string{std::istreambuf_iterator<char>{stream},
                          std::istreambuf_iterator<char>{}});
          return stream;
        }

      private:
        ValueType m_value{"NA"};
      };

    private:
      FileDescription m_fileDescription{};

    public:
      ZividCameraFile &set(const FileDescription &value) {

        m_fileDescription = value;
        return *this;
      }
      const FileDescription &fileDescription() const {
        return m_fileDescription;
      }

    private:
      FileVersion m_fileVersion{};

    public:
      ZividCameraFile &set(const FileVersion &value) {

        m_fileVersion = value;
        return *this;
      }
      const FileVersion &fileVersion() const { return m_fileVersion; }

    private:
      ProductVersion m_productVersion{};

    public:
      ZividCameraFile &set(const ProductVersion &value) {

        m_productVersion = value;
        return *this;
      }
      const ProductVersion &productVersion() const { return m_productVersion; }

    private:
      Comments m_comments{};

    public:
      ZividCameraFile &set(const Comments &value) {

        m_comments = value;
        return *this;
      }
      const Comments &comments() const { return m_comments; }

      template <typename F> void forEach(const F &f) const {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      template <typename F> void forEach(const F &f) {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      template <typename F> void traverseValues(const F &f) const {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      template <typename F> void traverseValues(const F &f) {
        f(m_fileDescription);
        f(m_fileVersion);
        f(m_productVersion);
        f(m_comments);
      }

      std::string toString() const;

      friend std::ostream &operator<<(std::ostream &stream,
                                      const ZividCameraFile &value) {
        return stream << value.toString();
      }

      void save(const std::string &fileName) const;

      void setFromString(const std::string &value);

      friend std::istream &operator>>(std::istream &stream,
                                      ZividCameraFile &value) {
        value.setFromString(std::string{std::istreambuf_iterator<char>{stream},
                                        std::istreambuf_iterator<char>{}});
        return stream;
      }

      void load(const std::string &fileName);

      bool operator==(const ZividCameraFile &other) const;

      bool operator!=(const ZividCameraFile &other) const;
    };

  private:
    ZividStudio m_zividStudio{};

  public:
    SoftwareVersion &set(const ZividStudio &value) {

      m_zividStudio = value;
      return *this;
    }
    const ZividStudio &zividStudio() const { return m_zividStudio; }

    SoftwareVersion &set(const ZividStudio::FileDescription &value) {

      m_zividStudio.set(value);
      return *this;
    }

    SoftwareVersion &set(const ZividStudio::FileVersion &value) {

      m_zividStudio.set(value);
      return *this;
    }

    SoftwareVersion &set(const ZividStudio::ProductVersion &value) {

      m_zividStudio.set(value);
      return *this;
    }

    SoftwareVersion &set(const ZividStudio::Comments &value) {

      m_zividStudio.set(value);
      return *this;
    }

  private:
    ZividAPI m_zividAPI{};

  public:
    SoftwareVersion &set(const ZividAPI &value) {

      m_zividAPI = value;
      return *this;
    }
    const ZividAPI &zividAPI() const { return m_zividAPI; }

    SoftwareVersion &set(const ZividAPI::FileDescription &value) {

      m_zividAPI.set(value);
      return *this;
    }

    SoftwareVersion &set(const ZividAPI::FileVersion &value) {

      m_zividAPI.set(value);
      return *this;
    }

    SoftwareVersion &set(const ZividAPI::ProductVersion &value) {

      m_zividAPI.set(value);
      return *this;
    }

    SoftwareVersion &set(const ZividAPI::Comments &value) {

      m_zividAPI.set(value);
      return *this;
    }

  private:
    ZividCameraToshibaTeli m_zividCameraToshibaTeli{};

  public:
    SoftwareVersion &set(const ZividCameraToshibaTeli &value) {

      m_zividCameraToshibaTeli = value;
      return *this;
    }
    const ZividCameraToshibaTeli &zividCameraToshibaTeli() const {
      return m_zividCameraToshibaTeli;
    }

    SoftwareVersion &set(const ZividCameraToshibaTeli::FileDescription &value) {

      m_zividCameraToshibaTeli.set(value);
      return *this;
    }

    SoftwareVersion &set(const ZividCameraToshibaTeli::FileVersion &value) {

      m_zividCameraToshibaTeli.set(value);
      return *this;
    }

    SoftwareVersion &set(const ZividCameraToshibaTeli::ProductVersion &value) {

      m_zividCameraToshibaTeli.set(value);
      return *this;
    }

    SoftwareVersion &set(const ZividCameraToshibaTeli::Comments &value) {

      m_zividCameraToshibaTeli.set(value);
      return *this;
    }

  private:
    ZividCameraFile m_zividCameraFile{};

  public:
    SoftwareVersion &set(const ZividCameraFile &value) {

      m_zividCameraFile = value;
      return *this;
    }
    const ZividCameraFile &zividCameraFile() const { return m_zividCameraFile; }

    SoftwareVersion &set(const ZividCameraFile::FileDescription &value) {

      m_zividCameraFile.set(value);
      return *this;
    }

    SoftwareVersion &set(const ZividCameraFile::FileVersion &value) {

      m_zividCameraFile.set(value);
      return *this;
    }

    SoftwareVersion &set(const ZividCameraFile::ProductVersion &value) {

      m_zividCameraFile.set(value);
      return *this;
    }

    SoftwareVersion &set(const ZividCameraFile::Comments &value) {

      m_zividCameraFile.set(value);
      return *this;
    }

    template <typename F> void forEach(const F &f) const {
      f(m_zividStudio);
      f(m_zividAPI);
      f(m_zividCameraToshibaTeli);
      f(m_zividCameraFile);
    }

    template <typename F> void forEach(const F &f) {
      f(m_zividStudio);
      f(m_zividAPI);
      f(m_zividCameraToshibaTeli);
      f(m_zividCameraFile);
    }

    template <typename F> void traverseValues(const F &f) const {
      m_zividStudio.traverseValues(f);
      m_zividAPI.traverseValues(f);
      m_zividCameraToshibaTeli.traverseValues(f);
      m_zividCameraFile.traverseValues(f);
    }

    template <typename F> void traverseValues(const F &f) {
      m_zividStudio.traverseValues(f);
      m_zividAPI.traverseValues(f);
      m_zividCameraToshibaTeli.traverseValues(f);
      m_zividCameraFile.traverseValues(f);
    }

    std::string toString() const;

    friend std::ostream &operator<<(std::ostream &stream,
                                    const SoftwareVersion &value) {
      return stream << value.toString();
    }

    void save(const std::string &fileName) const;

    void setFromString(const std::string &value);

    friend std::istream &operator>>(std::istream &stream,
                                    SoftwareVersion &value) {
      value.setFromString(std::string{std::istreambuf_iterator<char>{stream},
                                      std::istreambuf_iterator<char>{}});
      return stream;
    }

    void load(const std::string &fileName);

    bool operator==(const SoftwareVersion &other) const;

    bool operator!=(const SoftwareVersion &other) const;
  };

private:
  TimeStamp m_timeStamp{};

public:
  FrameInfo &set(const TimeStamp &value) {

    if (value.value().time_since_epoch().count() <
            value.range().min().time_since_epoch().count() ||
        value.value().time_since_epoch().count() >
            value.range().max().time_since_epoch().count()) {
      throw std::out_of_range(
          "FrameInfo: " +
          std::to_string(value.value().time_since_epoch().count()) +
          ", is out of range: {" +
          std::to_string(value.range().min().time_since_epoch().count()) +
          ", " +
          std::to_string(value.range().max().time_since_epoch().count()) + "}");
    }

    m_timeStamp = value;
    return *this;
  }
  const TimeStamp &timeStamp() const { return m_timeStamp; }

private:
  SoftwareVersion m_softwareVersion{};

public:
  FrameInfo &set(const SoftwareVersion &value) {

    m_softwareVersion = value;
    return *this;
  }
  const SoftwareVersion &softwareVersion() const { return m_softwareVersion; }

  FrameInfo &set(const SoftwareVersion::ZividStudio &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividStudio::FileDescription &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividStudio::FileVersion &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividStudio::ProductVersion &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividStudio::Comments &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividAPI &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividAPI::FileDescription &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividAPI::FileVersion &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividAPI::ProductVersion &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividAPI::Comments &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividCameraToshibaTeli &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &
  set(const SoftwareVersion::ZividCameraToshibaTeli::FileDescription &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &
  set(const SoftwareVersion::ZividCameraToshibaTeli::FileVersion &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &
  set(const SoftwareVersion::ZividCameraToshibaTeli::ProductVersion &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &
  set(const SoftwareVersion::ZividCameraToshibaTeli::Comments &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividCameraFile &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &
  set(const SoftwareVersion::ZividCameraFile::FileDescription &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividCameraFile::FileVersion &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &
  set(const SoftwareVersion::ZividCameraFile::ProductVersion &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  FrameInfo &set(const SoftwareVersion::ZividCameraFile::Comments &value) {

    m_softwareVersion.set(value);
    return *this;
  }

  template <typename F> void forEach(const F &f) const {
    f(m_timeStamp);
    f(m_softwareVersion);
  }

  template <typename F> void forEach(const F &f) {
    f(m_timeStamp);
    f(m_softwareVersion);
  }

  template <typename F> void traverseValues(const F &f) const {
    f(m_timeStamp);
    m_softwareVersion.traverseValues(f);
  }

  template <typename F> void traverseValues(const F &f) {
    f(m_timeStamp);
    m_softwareVersion.traverseValues(f);
  }

  std::string toString() const;

  friend std::ostream &operator<<(std::ostream &stream,
                                  const FrameInfo &value) {
    return stream << value.toString();
  }

  void save(const std::string &fileName) const;

  void setFromString(const std::string &value);

  friend std::istream &operator>>(std::istream &stream, FrameInfo &value) {
    value.setFromString(std::string{std::istreambuf_iterator<char>{stream},
                                    std::istreambuf_iterator<char>{}});
    return stream;
  }

  void load(const std::string &fileName);

  bool operator==(const FrameInfo &other) const;

  bool operator!=(const FrameInfo &other) const;
};
} // namespace Zivid

#ifdef _MSC_VER
#pragma warning(pop)
#endif