CameraState.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 CameraState {
public:
  CameraState() = default;

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

  static constexpr bool isContainer{true};

  static constexpr const char *path{""};

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

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

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

  class ZIVID_COMMON Connected {
  public:
    using ValueType = bool;
    static const Connected yes; 
    static const Connected no;  

    static constexpr bool isContainer{false};

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

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

    Connected() = default;

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

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

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

    std::string toString() const { return m_value ? "yes" : "no"; }

    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();
    }

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

  private:
    ValueType m_value{false};
  };

  class ZIVID_COMMON Available {
  public:
    using ValueType = bool;
    static const Available yes; 
    static const Available no;  

    static constexpr bool isContainer{false};

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

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

    Available() = default;

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

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

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

    std::string toString() const { return m_value ? "yes" : "no"; }

    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();
    }

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

  private:
    ValueType m_value{false};
  };

  class ZIVID_COMMON Live {
  public:
    using ValueType = bool;
    static const Live yes; 
    static const Live no;  

    static constexpr bool isContainer{false};

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

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

    Live() = default;

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

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

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

    std::string toString() const { return m_value ? "yes" : "no"; }

    explicit operator bool() const { return m_value; }

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

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

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

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

  private:
    ValueType m_value{false};
  };

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

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

    static constexpr bool isContainer{true};

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

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

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

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

    class ZIVID_COMMON General {
    public:
      using ValueType = double;

      static constexpr bool isContainer{false};

      static constexpr const char *path{"Temperature/General"};

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

      General() = default;

      explicit constexpr General(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) {
        m_value = std::stod(value);
      }

      std::string toString() const { return std::to_string(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();
      }

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

    private:
      ValueType m_value{0.0};
    };

    class ZIVID_COMMON Lens {
    public:
      using ValueType = double;

      static constexpr bool isContainer{false};

      static constexpr const char *path{"Temperature/Lens"};

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

      Lens() = default;

      explicit constexpr Lens(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) {
        m_value = std::stod(value);
      }

      std::string toString() const { return std::to_string(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();
      }

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

    private:
      ValueType m_value{0.0};
    };

    class ZIVID_COMMON LED {
    public:
      using ValueType = double;

      static constexpr bool isContainer{false};

      static constexpr const char *path{"Temperature/LED"};

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

      LED() = default;

      explicit constexpr LED(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) {
        m_value = std::stod(value);
      }

      std::string toString() const { return std::to_string(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();
      }

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

    private:
      ValueType m_value{0.0};
    };

    class ZIVID_COMMON PCB {
    public:
      using ValueType = double;

      static constexpr bool isContainer{false};

      static constexpr const char *path{"Temperature/PCB"};

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

      PCB() = default;

      explicit constexpr PCB(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) {
        m_value = std::stod(value);
      }

      std::string toString() const { return std::to_string(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();
      }

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

    private:
      ValueType m_value{0.0};
    };

    class ZIVID_COMMON DMD {
    public:
      using ValueType = double;

      static constexpr bool isContainer{false};

      static constexpr const char *path{"Temperature/DMD"};

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

      DMD() = default;

      explicit constexpr DMD(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) {
        m_value = std::stod(value);
      }

      std::string toString() const { return std::to_string(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();
      }

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

    private:
      ValueType m_value{0.0};
    };

  private:
    General m_general{};

  public:
    Temperature &set(const General &value) {

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

      m_general = value;
      return *this;
    }
    const General &general() const { return m_general; }

  private:
    Lens m_lens{};

  public:
    Temperature &set(const Lens &value) {

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

      m_lens = value;
      return *this;
    }
    const Lens &lens() const { return m_lens; }

  private:
    LED m_led{};

  public:
    Temperature &set(const LED &value) {

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

      m_led = value;
      return *this;
    }
    const LED &led() const { return m_led; }

  private:
    PCB m_pcb{};

  public:
    Temperature &set(const PCB &value) {

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

      m_pcb = value;
      return *this;
    }
    const PCB &pcb() const { return m_pcb; }

  private:
    DMD m_dmd{};

  public:
    Temperature &set(const DMD &value) {

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

      m_dmd = value;
      return *this;
    }
    const DMD &dmd() const { return m_dmd; }

    template <typename F> void forEach(const F &f) const {
      f(m_general);
      f(m_lens);
      f(m_led);
      f(m_pcb);
      f(m_dmd);
    }

    template <typename F> void forEach(const F &f) {
      f(m_general);
      f(m_lens);
      f(m_led);
      f(m_pcb);
      f(m_dmd);
    }

    template <typename F> void traverseValues(const F &f) const {
      f(m_general);
      f(m_lens);
      f(m_led);
      f(m_pcb);
      f(m_dmd);
    }

    template <typename F> void traverseValues(const F &f) {
      f(m_general);
      f(m_lens);
      f(m_led);
      f(m_pcb);
      f(m_dmd);
    }

    std::string toString() const;

    friend std::ostream &operator<<(std::ostream &stream,
                                    const Temperature &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, Temperature &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 Temperature &other) const;

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

private:
  Connected m_connected{};

public:
  CameraState &set(const Connected &value) {

    m_connected = value;
    return *this;
  }
  const Connected &isConnected() const { return m_connected; }

private:
  Available m_available{};

public:
  CameraState &set(const Available &value) {

    m_available = value;
    return *this;
  }
  const Available &isAvailable() const { return m_available; }

private:
  Live m_live{};

public:
  CameraState &set(const Live &value) {

    m_live = value;
    return *this;
  }
  const Live &live() const { return m_live; }

private:
  Temperature m_temperature{};

public:
  CameraState &set(const Temperature &value) {

    m_temperature = value;
    return *this;
  }
  const Temperature &temperature() const { return m_temperature; }

  CameraState &set(const Temperature::General &value) {

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

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

  CameraState &set(const Temperature::Lens &value) {

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

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

  CameraState &set(const Temperature::LED &value) {

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

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

  CameraState &set(const Temperature::PCB &value) {

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

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

  CameraState &set(const Temperature::DMD &value) {

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

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

  template <typename F> void forEach(const F &f) const {
    f(m_connected);
    f(m_available);
    f(m_live);
    f(m_temperature);
  }

  template <typename F> void forEach(const F &f) {
    f(m_connected);
    f(m_available);
    f(m_live);
    f(m_temperature);
  }

  template <typename F> void traverseValues(const F &f) const {
    f(m_connected);
    f(m_available);
    f(m_live);
    m_temperature.traverseValues(f);
  }

  template <typename F> void traverseValues(const F &f) {
    f(m_connected);
    f(m_available);
    f(m_live);
    m_temperature.traverseValues(f);
  }

  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 setFromString(const std::string &value);

  friend std::istream &operator>>(std::istream &stream, CameraState &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 CameraState &other) const;

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

#ifdef _MSC_VER
#pragma warning(pop)
#endif