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) { return Create(ParseName(name), ParseNamespace(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");
      }
 
 
      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");
      }
 
      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::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();
      }
 
      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>();
      }
 
      template <class T> T MaxConfig() const
      {
        throw std::runtime_error("requested max config type must be derived from FloatNode or be "
          "of type double");
      }
 
      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");
      }
 
      template <class T> T MinConfig() const
      {
        throw std::runtime_error("requested min config type must be derived from FloatNode or be "
          "of type double");
      }
 
      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");
      }
 
 
      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();
      }
 
 
      void SetUnit(const String& unit)
      {
        SetInfo(NodeInfo::Unit, 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);
      }
 
 
      void SetDisplayPrecision(const double displayPrecision)
      {
        SetInfoAsFloat(NodeInfo::DisplayPrecision, 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");
      }
 
      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");
      }
    };
 
    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);
    }
 
  }
  CVB_END_INLINE_NS
}