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

}