variable_node.hpp

#pragma once
 
#include "../global.hpp" 
 
#include "opcua.hpp"
#include "exception.hpp"
 
#include "base_node.hpp"
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
namespace OpcUa
{
 
class VariableNode : public OpcUa::BaseNode
{
  friend class Client;
  friend class Server;
 
  friend class FloatNode;
  friend class IntegerNode;
  friend class StringNode;
 
public:
 
  OpcUa::DataType DataType() const
  {
    return static_cast<OpcUa::DataType>(GetAttributeAsInt(AttributeID::DataType));
  }
 
 
  EventCookie RegisterWriteCallback(std::function<void()> handler)
  {
    auto holder = Internal::CbCarrier<void()>::Create(handler);
    return writeCarrierContainer_.Register(holder);
  }
 
  EventCookie RegisterReadCallback(std::function<void()> handler)
  {
    auto holder = Internal::CbCarrier<void()>::Create(handler);
    return readCarrierContainer_.Register(holder);
  }
   
  void UnregisterCallback(EventCookie eventCookie)
  {
    readCarrierContainer_.Unregister(eventCookie);
    writeCarrierContainer_.Unregister(eventCookie);
  }   
 
protected:
  explicit VariableNode(OpcUa::BaseNode && node) noexcept
    : OpcUa::BaseNode(std::move(node))
  {
  } 
 
private:
  size_t callbackCookie_ = 0;
  Internal::CarrierContainer writeCarrierContainer_;
  Internal::CarrierContainer readCarrierContainer_;
 
  static void __stdcall ReadCallback(CExports::CVOPCNODE, void * pPrivate)
  {
    try
    {
      auto node = reinterpret_cast<VariableNode *>(pPrivate);
      node->readCarrierContainer_.Call<void()>();
    }
    catch (...)
    {
      // swallow exception so they don't propagate to native library.
    }
  }
 
  static void __stdcall WriteCallback(CExports::CVOPCNODE, void * pPrivate)
  {
    try
    {
      auto node = reinterpret_cast<VariableNode*>(pPrivate);
      node->writeCarrierContainer_.Call<void()>();
    }
    catch (...)
    {
      // swallow exception so they don't propagate to native library.
    }
  }
};
 
}
 
CVB_END_INLINE_NS
 
}