nodeid.h

Go to the documentation of this file.

#pragma once

#include <opc/ua/protocol/message_identifiers.h>
#include <opc/ua/protocol/object_ids.h>
#include <opc/ua/protocol/expanded_object_ids.h>
#include <opc/ua/protocol/guid.h>
#include <opc/ua/protocol/reference_ids.h>

#include <sstream>
#include <stdint.h>
#include <string>
#include <vector>

namespace OpcUa
{

  enum NodeIdEncoding : uint8_t
  {
    EV_TWO_BYTE = 0,
    EV_FOUR_BYTE = 1,
    EV_NUMERIC = 2,
    EV_STRING = 3,
    EV_GUId = 4,
    EV_BYTE_STRING = 5,

    EV_Server_INDEX_FLAG = 0x40,
    EV_NAMESPACE_URI_FLAG = 0x80,

    EV_VALUE_MASK = 0x3f,
  };

  struct ExpandedNodeId;

  struct NodeId
  {
    NodeIdEncoding Encoding;
    std::string NamespaceURI;
    uint32_t ServerIndex;

    struct TwoByteDataType
    {
      uint8_t Identifier;

      TwoByteDataType()
        : Identifier(0)
      {
      }

    } TwoByteData;

    struct FourByteDataType
    {
      uint8_t NamespaceIndex;
      uint16_t Identifier;

      FourByteDataType()
        : NamespaceIndex(0)
        , Identifier(0)
      {
      }
    }FourByteData;

    struct NumericDataType
    {
      uint16_t NamespaceIndex;
      uint32_t Identifier;

      NumericDataType()
        : NamespaceIndex(0)
        , Identifier(0)
      {
      }
    }NumericData;


    struct StringDataType
    {
      uint16_t NamespaceIndex;
      std::string Identifier;

      StringDataType()
        : NamespaceIndex(0)
      {
      }

    }StringData;

    struct BinaryDataType
    {
      uint16_t NamespaceIndex;
      std::vector<uint8_t> Identifier;

      BinaryDataType()
        : NamespaceIndex(0)
      {
      }

    }BinaryData;

    struct GuidDataType
    {
      uint16_t NamespaceIndex;
      Guid Identifier;

      GuidDataType()
        : NamespaceIndex(0)
      {
      }

    }GuidData;

    NodeId();
    NodeId(const NodeId& node);
    NodeId(const ExpandedNodeId& node);
    NodeId(MessageId messageId);
    NodeId(ReferenceId referenceId);
    NodeId(ObjectId objectId);
    NodeId(ExpandedObjectId objectId);
    NodeId(uint32_t integerId, uint16_t index);
    NodeId(std::string stringId, uint16_t index);

    NodeId& operator= (const NodeId& node);
    NodeId& operator= (const ExpandedNodeId& node);

    explicit operator ExpandedNodeId();

    NodeId& operator= (MessageId messageId)
    {
      *this = NodeId(messageId);
      return *this;
    }

    NodeId& operator= (ReferenceId referenceId)
    {
      *this = NodeId(referenceId);
      return *this;
    }

    NodeId& operator= (ObjectId objectId)
    {
      *this = NodeId(objectId);
      return *this;
    }

    NodeId& operator= (ExpandedObjectId objectId)
    {
      *this = NodeId(objectId);
      return *this;
    }

    bool operator== (const NodeId& node) const;
    bool operator== (MessageId messageId) const;
    bool operator== (ReferenceId referenceId) const;
    bool operator== (ObjectId objectId) const;
    bool operator== (ExpandedObjectId objectId) const;

    bool operator!= (const NodeId& node) const;
    bool operator!= (MessageId messageId) const;
    bool operator!= (ReferenceId referenceId) const;
    bool operator!= (ObjectId objectId) const;
    bool operator!= (ExpandedObjectId objectId) const;

    bool operator< (const NodeId& node) const;

    NodeIdEncoding GetEncodingValue() const;
    bool IsNull() const;
    bool HasNullIdentifier() const;
    bool HasNamespaceURI() const;
    bool HasServerIndex() const;

    void SetNamespaceURI(const std::string& uri);
    void SetServerIndex(uint32_t index);
    void SetNamespaceIndex(uint32_t ns);

    bool IsInteger() const;
    bool IsString() const;
    bool IsBinary() const;
    bool IsGuid() const;

    uint32_t GetNamespaceIndex() const;

    uint32_t GetIntegerIdentifier() const;
    std::string GetStringIdentifier() const;
    std::vector<uint8_t> GetBinaryIdentifier() const;
    Guid GetGuidIdentifier() const;

    protected:
    void CopyNodeId(const NodeId& node);
  };

  inline NodeId TwoByteNodeId(uint8_t value)
  {
    NodeId id;
    id.Encoding = EV_TWO_BYTE;
    id.TwoByteData.Identifier = value;
    return id;
  }

  inline NodeId FourByteNodeId(uint16_t value, uint8_t namespaceIndex = 0)
  {
    NodeId id;
    id.Encoding = EV_FOUR_BYTE;
    id.FourByteData.Identifier = value;
    id.FourByteData.NamespaceIndex = namespaceIndex;
    return id;
  }

  inline NodeId NumericNodeId(uint32_t value, uint16_t namespaceIndex = 0)
  {
    NodeId id;
    id.Encoding = EV_NUMERIC;
    id.NumericData.Identifier = value;
    id.NumericData.NamespaceIndex = namespaceIndex;
    return id;
  }

  inline NodeId StringNodeId(std::string value, uint16_t namespaceIndex = 0)
  {
    NodeId id;
    id.Encoding = EV_STRING;
    id.StringData.Identifier = value;
    id.StringData.NamespaceIndex = namespaceIndex;
    return id;
  }

  inline NodeId BinaryNodeId(std::vector<uint8_t> value, uint16_t namespaceIndex = 0)
  {
    NodeId id;
    id.Encoding = EV_BYTE_STRING;
    id.BinaryData.Identifier = value;
    id.BinaryData.NamespaceIndex = namespaceIndex;
    return id;
  }

  inline NodeId GuidNodeId(Guid value, uint16_t namespaceIndex = 0)
  {
    NodeId id;
    id.Encoding = EV_GUId;
    id.GuidData.Identifier = value;
    id.GuidData.NamespaceIndex = namespaceIndex;
    return id;
  }

  struct ExpandedNodeId : public NodeId
  {
    ExpandedNodeId();
    ExpandedNodeId(const NodeId& node);
    ExpandedNodeId(const ExpandedNodeId& node);
    ExpandedNodeId(MessageId messageId);
    ExpandedNodeId(ReferenceId referenceId);
    ExpandedNodeId(ObjectId objectId);
    ExpandedNodeId(ExpandedObjectId objectId);
    ExpandedNodeId(uint32_t integerId, uint16_t index);
    ExpandedNodeId(std::string stringId, uint16_t index);

   //using NodeId::NodeId;
   //using base::base;
  };

} // namespace OpcUa