address_space_internal.h

Go to the documentation of this file.

#pragma once

#include "address_space_addon.h"

#include <opc/ua/protocol/strings.h>
#include <opc/ua/protocol/string_utils.h>
#include <opc/ua/protocol/view.h>
#include <opc/ua/services/attributes.h>
#include <opc/ua/services/node_management.h>

#include <boost/thread/locks.hpp>
#include <boost/thread/shared_mutex.hpp>
#include <ctime>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <deque>
#include <set>
#include <thread>



namespace OpcUa
{
namespace Internal
{

class InternalSubscription;

struct NodeAttribute
{
  NodeId Node;
  AttributeId Attribute;
  NodeAttribute(NodeId node, AttributeId attribute) : Node(node), Attribute(attribute) {}
  NodeAttribute() {} //seems compiler wants this one
};

typedef std::map<uint32_t, NodeAttribute> ClientIdToAttributeMapType;

struct DataChangeCallbackData
{
  std::function<Server::DataChangeCallback> Callback;
  IntegerId ClientHandle;
};

typedef std::map<uint32_t, DataChangeCallbackData> DataChangeCallbackMap;

//Store an attribute value together with a link to all its suscriptions
struct AttributeValue
{
  DataValue Value;
  DataChangeCallbackMap DataChangeCallbacks;
  std::function<DataValue(void)> GetValueCallback;
};

typedef std::map<AttributeId, AttributeValue> AttributesMap;

//Store all data related to a Node
struct NodeStruct
{
  AttributesMap Attributes;
  std::vector<ReferenceDescription> References;
  std::function<std::vector<OpcUa::Variant> (NodeId, std::vector<OpcUa::Variant>)> Method;
};

typedef std::map<NodeId, NodeStruct> NodesMap;

//In memory storage of server opc-ua data model
class AddressSpaceInMemory : public Server::AddressSpace
{
public:
  AddressSpaceInMemory(const Common::Logger::SharedPtr & logger);

  ~AddressSpaceInMemory();

  //Services implementation
  virtual std::vector<AddNodesResult> AddNodes(const std::vector<AddNodesItem> & items);
  virtual std::vector<StatusCode> AddReferences(const std::vector<AddReferencesItem> & items);
  virtual std::vector<BrowsePathResult> TranslateBrowsePathsToNodeIds(const TranslateBrowsePathsParameters & params) const;
  virtual std::vector<BrowseResult> Browse(const OpcUa::NodesQuery & query) const;
  virtual std::vector<BrowseResult> BrowseNext() const;
  virtual std::vector<NodeId> RegisterNodes(const std::vector<NodeId> & params) const;
  virtual void UnregisterNodes(const std::vector<NodeId> & params) const;
  virtual std::vector<DataValue> Read(const ReadParameters & params) const;
  virtual std::vector<StatusCode> Write(const std::vector<OpcUa::WriteValue> & values);
  virtual std::vector<OpcUa::CallMethodResult> Call(const std::vector<OpcUa::CallMethodRequest> & methodsToCall);

  //Server side methods

  uint32_t AddDataChangeCallback(const NodeId & node, AttributeId attribute, std::function<Server::DataChangeCallback> callback);

  void DeleteDataChangeCallback(uint32_t serverhandle);

  StatusCode SetValueCallback(const NodeId & node, AttributeId attribute, std::function<DataValue(void)> callback);

  void SetMethod(const NodeId & node, std::function<std::vector<OpcUa::Variant> (NodeId context, std::vector<OpcUa::Variant> arguments)> callback);

private:
  std::tuple<bool, NodeId> FindElementInNode(const NodeId & nodeid, const RelativePathElement & element) const;
  BrowsePathResult TranslateBrowsePath(const BrowsePath & browsepath) const;
  DataValue GetValue(const NodeId & node, AttributeId attribute) const;
  StatusCode SetValue(const NodeId & node, AttributeId attribute, const DataValue & data);
  bool IsSuitableReference(const BrowseDescription & desc, const ReferenceDescription & reference) const;
  bool IsSuitableReferenceType(const ReferenceDescription & reference, const NodeId & typeId, bool includeSubtypes) const;
  std::vector<NodeId> SelectNodesHierarchy(std::vector<NodeId> sourceNodes) const;
  AddNodesResult AddNode(const AddNodesItem & item);
  StatusCode AddReference(const AddReferencesItem & item);
  NodeId GetNewNodeId(const NodeId & id);
  CallMethodResult CallMethod(CallMethodRequest method);

private:
  Common::Logger::SharedPtr Logger;
  mutable boost::shared_mutex DbMutex;
  NodesMap Nodes;
  ClientIdToAttributeMapType ClientIdToAttributeMap; //Use to find callback using callback subcsriptionid
  uint32_t MaxNodeIdNum = 2000;
  uint32_t DefaultIdx = 2;
  std::atomic<uint32_t> DataChangeCallbackHandle;
};
}

namespace Server
{
AddressSpace::UniquePtr CreateAddressSpace(const Common::Logger::SharedPtr & logger);
}
}