integer_node.hpp

#pragma once
 
#include "../global.hpp"
 
#include "integer_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 IntegerNode
    : public IntegerBaseNode
    , public Private::IHasValueConfig<IntegerBaseNodePtr>
{
public:
  explicit IntegerNode(HandleGuard<Node> &&guard) : IntegerBaseNode(std::move(guard)) {}
 
  static IntegerNodePtr Create(const String &name, const GevServer::Namespace &nameSpace)
  {
    return std::make_shared<IntegerNode>(HandleGuard<Node>(
        CExports::CreateGSIntegerNodeTyped(name.data(), static_cast<CExports::TGSNamespace>(nameSpace))));
  }
 
  static IntegerNodePtr 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 IntegerBaseNode or "
                             "be "
                             "of type int64_t");
  }
 
 
  template <class T> void SetIncrementConfig(const T & /*value*/)
  {
    throw std::runtime_error("requested value config type must be derived from "
                             "IntegerBaseNode or be of type std::int64_t");
  }
 
  GenApi::AccessMode AccessMode() const override
  {
    auto value = GetTerminalRegisterNode<IntegerNode, IntegerBaseNodePtr>(
        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<IntegerNode, IntegerBaseNodePtr>(
        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<IntegerNode, IntegerBaseNodePtr>(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 IntegerBaseNode or be "
                             "of type int64_t");
  }
 
  template <class T> void SetMaxConfig(const T & /*value*/)
  {
    throw std::runtime_error("requested value config type must be derived from "
                             "IntegerBaseNode or be of type std::int64_t");
  }
 
  template <class T> T MinConfig() const
  {
    throw std::runtime_error("requested min config type must be derived from IntegerBaseNode or be "
                             "of type int64_t");
  }
 
  template <class T> void SetMinConfig(const T & /*value*/)
  {
    throw std::runtime_error("requested min config type must be derived from "
                             "IntegerBaseNode or be of type std::int64_t");
  }
 
  IntegerBaseNodePtr ValueConfigAsNode() const override;
 
  template <class T> T ValueConfig() const
  {
    throw std::runtime_error("requested value config type must be derived from IntegerBaseNode or be "
                             "of type int64_t");
  }
 
  template <class T> void SetValueConfig(const T & /*value*/)
  {
    throw std::runtime_error("requested value config type must be derived from "
                             "IntegerBaseNode or be of integral type");
  }
 
 
 
  String Unit() const override
  {
    return {}; // Not implemented in register map
  }
 
  void SetUnit(const String& /*unit*/) override
  {
    //SetInfo(NodeInfo::Unit, unit); // not implemented in register map
  }
};
 
template <> inline std::int64_t IntegerNode::MaxConfig<std::int64_t>() const
{
  return GetInfoAsInt(NodeInfo::Max);
}
 
template <> inline void IntegerNode::SetMaxConfig<std::int64_t>(const std::int64_t &value)
{
  SetInfoAsInt(NodeInfo::Max, value);
}
 
template <> inline std::int64_t IntegerNode::MinConfig<std::int64_t>() const
{
  return GetInfoAsInt(NodeInfo::Min);
}
 
template <> inline void IntegerNode::SetMinConfig<std::int64_t>(const std::int64_t &value)
{
  SetInfoAsInt(NodeInfo::Min, value);
}
 
template <> inline std::int64_t IntegerNode::ValueConfig<std::int64_t>() const
{
  return GetInfoAsInt(NodeInfo::Value);
}
 
template <> inline std::int64_t IntegerNode::IncrementConfig<std::int64_t>() const
{
  return GetInfoAsInt(NodeInfo::Increment);
}
 
template <> inline void IntegerNode::SetIncrementConfig<std::int64_t>(const std::int64_t &value)
{
  SetInfoAsInt(NodeInfo::Increment, value);
}
 
template <> inline void IntegerNode::SetValueConfig<std::int64_t>(const std::int64_t &value)
{
  SetInfoAsInt(NodeInfo::Value, value);
}
 
}
CVB_END_INLINE_NS
}