node_id.hpp

#pragma once

#include <type_traits>

#include "../global.hpp" 

#include "opcua.hpp" 
#include "exception.hpp"

namespace Cvb
{

CVB_BEGIN_INLINE_NS

template <>
inline HandleGuard<OpcUa::NodeID>::HandleGuard(void * handle) noexcept
  : HandleGuard<OpcUa::NodeID>(handle, [](void* handle)
{
  CVB_CALL_CAPI(ReleaseObject(handle));
})
{
}

namespace OpcUa
{

class NodeID 
{
  friend class OpcUa::BaseNode;
  
public:

  static NodeIDPtr Create(Namespace0NodeID id)
  {
    return std::shared_ptr<NodeID>(new NodeID(id));
  }


  static NodeIDPtr Create(std::uint16_t namespaceIndex, std::uint32_t identifier)
  {
    return std::shared_ptr<NodeID>(new NodeID(namespaceIndex, identifier));
  }


  static NodeIDPtr Create(std::uint16_t namespaceIndex, const Cvb::String & identifier)
  {
    return std::shared_ptr<NodeID>(new NodeID(namespaceIndex, identifier));
  }


  std::uint16_t NamespaceIndex() const
  {
    CExports::cvbuint16_t namesapceIndex = 0;
    int ret = CVB_CALL_CAPI(CVOPCGetNamespaceIndex(Handle(), namesapceIndex));
    if (ret < 0)
      throw OpcUaException(ret);
    return static_cast<std::uint16_t>(namesapceIndex);
  }



  std::string ExpandedText() const
  {
    std::size_t bufferSize = 0;
    int ret = CVB_CALL_CAPI(CVOPCGetNodeIdExpandedText(Handle(), reinterpret_cast<char*>(0), bufferSize));
    if (ret < 0)
      throw OpcUaException(ret);

    std::vector<char> buffer(bufferSize);
    ret = CVB_CALL_CAPI(CVOPCGetNodeIdExpandedText(Handle(), buffer.data(), bufferSize));
    if (ret < 0)
      throw OpcUaException(ret);

    return std::string(buffer.data());
  }


  NodeIDType Type() const
  {
    CExports::TCVOPCNodeIdType type;
    int ret = CVB_CALL_CAPI(CVOPCIdType(Handle(), type));
    if (ret < 0)
      throw OpcUaException(ret);

    return static_cast<NodeIDType>(type);
  }

  template<typename T>
  T Identifier() const
  {
    T retVal;
    int ret = -1;
    if (Type() == NodeIDType::Numeric) // TODO expand types
    {
      ret = CVB_CALL_CAPI(CVOPCNodeIdAsInteger(Handle(), retVal));
    }
    else if (Type() == NodeIDType::String)
    {
      std::size_t size = 0;
      ret = CVB_CALL_CAPI(CVOPCNodeIdAsStringTyped(Handle(), reinterpret_cast<Cvb::Char*>(nullptr), size));
      if (ret < 0)
      {
        throw OpcUa::OpcUaException(ret);
      }
      std::vector<Char> data(size);
      ret = CVB_CALL_CAPI(CVOPCNodeIdAsStringTyped(Handle(), data.data(), size));
      retVal = T(data.data());
    }
    else
    {
      throw CvbException("Unsupported OPCUA identifier data type!", ErrorCodes::CVB_ERROR);
    }

    if (ret < 0)
    {
      throw OpcUa::OpcUaException(ret);
    }

    return retVal;
  }

  void * Handle() const noexcept
  {
    return handle_.Handle();
  }

protected:
  static NodeIDPtr FromHandle(void * handle)
  {
    return std::shared_ptr<NodeID>(new NodeID(HandleGuard<OpcUa::NodeID>(handle)));
  }

  explicit NodeID(Namespace0NodeID id)
    : NodeID([&]
  {
    HandleGuard<NodeID> guard(CExports::CreateCVOPCNodeId(static_cast<CExports::TCVOpc_NS0_NodeId>(id)));
    if (!guard.Handle())
      throw OpcUaException(ErrorCodes::CVB_ERROR);
    return guard;
  })
  {
  }

  explicit NodeID(std::uint16_t namespaceIndex, std::uint32_t identifier)
    : NodeID([&]
  {
    HandleGuard<NodeID> guard(CExports::CreateCVOPCNodeIdNumeric(namespaceIndex, identifier));
    if (!guard.Handle())
      throw OpcUaException(ErrorCodes::CVB_ERROR);
    return guard;
  })
  {
  }

  explicit NodeID(std::uint16_t namespaceIndex, const Cvb::String & identifier)
    : NodeID([&]
  {
    HandleGuard<NodeID> guard(CExports::CreateCVOPCNodeIdTyped(namespaceIndex, identifier.c_str()));
    if (!guard.Handle())
      throw OpcUaException(ErrorCodes::CVB_ERROR);
    return guard;
  })
  {
  }

  explicit NodeID(HandleGuard<NodeID> && guard) noexcept
    : handle_(std::move(guard))
  {
  }

private:

  explicit NodeID(std::function<HandleGuard<NodeID>()> creator)
    : NodeID(creator())
  {
  }

  void NativeCall(std::function<CExports::cvbres_t()> fn) const
  {
    auto result = fn();
    if (result < 0)
      throw OpcUaException(ErrorCodes::CVB_NOTSUPPORTED);
  }

  String StringIdentifier() const
  {
    std::size_t bufferSize = 0;
    int ret = CVB_CALL_CAPI(CVOPCNodeIdAsStringTyped(Handle(), reinterpret_cast<Char*>(0), bufferSize));
    if (ret < 0)
      throw OpcUaException(ret);

    std::vector<Char> buffer(bufferSize);
    ret = CVB_CALL_CAPI(CVOPCNodeIdAsStringTyped(Handle(), buffer.data(), bufferSize));
    if (ret < 0)
      throw OpcUaException(ret);

    return String(buffer.data());
  }

  std::uint32_t NumericIdentifier() const
  {
    CExports::cvbuint32_t tmpIdentifier = 0;
    int ret = CVB_CALL_CAPI(CVOPCNodeIdAsInteger(Handle(), tmpIdentifier));
    if (ret < 0)
      throw OpcUaException(ret);
    return tmpIdentifier;
  }

  HandleGuard<NodeID> handle_;
};

template<>
inline std::uint32_t NodeID::Identifier<std::uint32_t>() const
{
  return NumericIdentifier();
}

template<>
inline String NodeID::Identifier<String>() const
{
  return StringIdentifier();
}
}
CVB_END_INLINE_NS
}