float_node.hpp

#pragma once
 
#include "../global.hpp"
 
#include "float_base_node.hpp"

#include "_detail/ihas_value_config.hpp"
#include "_detail/iconfigurable_register_node.hpp"
#include "_detail/iconfigurable_command_node.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
  namespace GevServer
  {

    class FloatNode
        : public FloatBaseNode
        , public Private::IHasValueConfig<FloatBaseNodePtr>
    {
    public:
      explicit FloatNode(HandleGuard<Node> &&guard)
          : FloatBaseNode(std::move(guard))
      {
      }

      static FloatNodePtr Create(const String &name, const GevServer::Namespace &nameSpace)
      {
        return std::make_shared<FloatNode>(HandleGuard<Node>(
            CExports::CreateGSFloatNodeTyped(name.data(), static_cast<CExports::TGSNamespace>(nameSpace))));
      }
      static FloatNodePtr Create(const String &name, const GevServer::Namespace &nameSpace) {…}

      static FloatNodePtr Create(const String &name)
      {
        return Create(ParseName(name), ParseNamespace(name));
      }
      static FloatNodePtr Create(const String &name) {…}

      template <class T>
      T IncrementConfig() const
      {
        throw std::runtime_error(
            "requested increment config type must be derived from FloatNode or "
            "be "
            "of type double");
      }
      T IncrementConfig() const {…}


      template <class T>
      void SetIncrementConfig(const T & /*value*/)
      {
        throw std::runtime_error(
            "requested value config type must be derived from "
            "FloatNode or be of type double");
      }
      void SetIncrementConfig(const T & /*value*/) {…}

      GenApi::AccessMode AccessMode() const override
      {
        auto value = GetTerminalRegisterNode<FloatNode, FloatBaseNodePtr>(
            this, [](Node *node) { return dynamic_cast<Private::IConfigurableRegisterNode *>(node) ? true : false; });
        if (value == nullptr)
          return GenApi::AccessMode::ReadWrite;
        else
          return value->AccessMode();
      }
      GenApi::AccessMode AccessMode() const override {…}

      GenApi::CacheMode CacheMode() const override
      {
        auto value = GetTerminalRegisterNode<FloatNode, FloatBaseNodePtr>(
            this, [](Node *node) { return dynamic_cast<Private::IConfigurableRegisterNode *>(node) ? true : false; });
        if (value == nullptr)
          return GenApi::CacheMode::NoCache;
        else
          return value->CacheMode();
      }
      GenApi::CacheMode CacheMode() const override {…}

      template <class Rep, class Period>
      std::chrono::duration<Rep, Period> PollingTime() const
      {
        auto value = GetTerminalRegisterNode<FloatNode, FloatBaseNodePtr>(this, [](Node *node) {
          auto isRegisterNode = dynamic_cast<Private::IConfigurableRegisterNode *>(node);
          auto isCommandNode  = dynamic_cast<Private::IConfigurableCommandNode *>(node);
          return (isRegisterNode || isCommandNode) ? true : false;
        });
        if (value == nullptr)
          return std::chrono::duration<Rep, Period>::zero();
        else
          return value->template PollingTime<Rep, Period>();
      }
      std::chrono::duration<Rep, Period> PollingTime() const {…}

      template <class T>
      T MaxConfig() const
      {
        throw std::runtime_error(
            "requested max config type must be derived from FloatNode or be "
            "of type double");
      }
      T MaxConfig() const {…}

      template <class T>
      void SetMaxConfig(const T & /*value*/)
      {
        throw std::runtime_error(
            "requested value config type must be derived from "
            "FloatNode or be of type double");
      }
      void SetMaxConfig(const T & /*value*/) {…}

      template <class T>
      T MinConfig() const
      {
        throw std::runtime_error(
            "requested min config type must be derived from FloatNode or be "
            "of type double");
      }
      T MinConfig() const {…}

      template <class T>
      void SetMinConfig(const T & /*value*/)
      {
        throw std::runtime_error(
            "requested min config type must be derived from "
            "FloatNode or be of type double");
      }
      void SetMinConfig(const T & /*value*/) {…}


      String Unit() const
      {
        auto bufferSize = NativeCall<size_t>([&](size_t &size) {
          return CExports::GSNGetInfoAsStringTyped(Handle(), CExports::TGSNodeInfo::GSNI_Unit,
                                                   reinterpret_cast<Char *>(0), size);
        });
 
        bufferSize += sizeof(Char);
        std::vector<Char> buffer(bufferSize);
        NativeCall([&]() {
          return CExports::GSNGetInfoAsStringTyped(Handle(), CExports::TGSNodeInfo::GSNI_Unit, buffer.data(),
                                                   bufferSize);
        });
 
        return buffer.data() ? String(buffer.data()) : String();
      }
      String Unit() const {…}


      void SetUnit(const String &unit)
      {
        SetInfo(NodeInfo::Unit, unit);
      }
      void SetUnit(const String &unit) {…}

      // TODO: This is currently not implemented in the RegMap. As I did not find it in a camera xml either (not
      // important?!), I'd like to keep this TODO rather then a "not implemented" which makes customers want this.
      // *  \return Display notation of this node as text.
      // *  \throws Any exception derived from std::exception including CvbException.
      // */
      // String DisplayNotation() const
      //{
 
      //}
 
      // void SetDisplayNotation(const String& displayNotation)
      //{
 
      //}


      double DisplayPrecision() const
      {
        return GetInfoAsFloat(NodeInfo::DisplayPrecision);
      }
      double DisplayPrecision() const {…}


      void SetDisplayPrecision(const double displayPrecision)
      {
        SetInfoAsFloat(NodeInfo::DisplayPrecision, displayPrecision);
      }
      void SetDisplayPrecision(const double displayPrecision) {…}
 
      FloatBaseNodePtr ValueConfigAsNode() const override;

      template <class T>
      T ValueConfig() const
      {
        throw std::runtime_error(
            "requested value config type must be derived from FloatNode or be "
            "of type double");
      }
      T ValueConfig() const {…}

      template <class T>
      void SetValueConfig(const T & /*value*/)
      {
        throw std::runtime_error(
            "requested value config type must be derived from "
            "FloatNode or be of type double");
      }
      void SetValueConfig(const T & /*value*/) {…}
    };
    class FloatNode {…};
 
    template <>
    inline double FloatNode::MaxConfig<double>() const
    {
      return GetInfoAsFloat(NodeInfo::Max);
    }
 
    template <>
    inline void FloatNode::SetMaxConfig<double>(const double &value)
    {
      SetInfoAsFloat(NodeInfo::Max, value);
    }
 
    template <>
    inline double FloatNode::MinConfig<double>() const
    {
      return GetInfoAsFloat(NodeInfo::Min);
    }
 
    template <>
    inline void FloatNode::SetMinConfig<double>(const double &value)
    {
      SetInfoAsFloat(NodeInfo::Min, value);
    }
 
    template <>
    inline double FloatNode::ValueConfig<double>() const
    {
      return GetInfoAsFloat(NodeInfo::Value);
    }
 
    template <>
    inline double FloatNode::IncrementConfig<double>() const
    {
      return GetInfoAsFloat(NodeInfo::Increment);
    }
 
    template <>
    inline void FloatNode::SetIncrementConfig<double>(const double &value)
    {
      SetInfoAsFloat(NodeInfo::Increment, value);
    }
 
    template <>
    inline void FloatNode::SetValueConfig<double>(const double &value)
    {
      SetInfoAsFloat(NodeInfo::Value, value);
    }
 
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb