xml_address_space_loader.cpp

Go to the documentation of this file.

// TODO Add EventNotifier Attribute to all requred nodes.

#include "xml_address_space_loader.h"
#include "xml_processor.h"

#include <opc/ua/server/address_space.h>

#include <libxml2/libxml/xmlmemory.h>
#include <libxml2/libxml/parser.h>

#include <iostream>
#include <map>
#include <stdexcept>
#include <sstream>
#include <string.h>

namespace
{
  using namespace OpcUa;

  ReferenceId GetReferenceId(const std::string& referenceName)
  {
    if (referenceName == "organizes")
      return ReferenceId::Organizes;
    if (referenceName == "references_to")
      return ReferenceId::References;
    if (referenceName == "has_child")
      return ReferenceId::HasChild;
    if (referenceName == "has_event_source")
      return ReferenceId::HasEventSource;
    if (referenceName == "has_modelling_rule")
      return ReferenceId::HasModellingRule;
    if (referenceName == "has_encoding")
      return ReferenceId::HasEncoding;
    if (referenceName == "has_description")
      return ReferenceId::HasDescription;
    if (referenceName == "has_type_definition")
      return ReferenceId::HasTypeDefinition;
    if (referenceName == "generates_event")
      return ReferenceId::GeneratesEvent;
    if (referenceName == "aggregates")
      return ReferenceId::Aggregates;
    if (referenceName == "has_subtype")
      return ReferenceId::HasSubtype;
    if (referenceName == "has_property")
      return ReferenceId::HasProperty;
    if (referenceName == "has_component")
      return ReferenceId::HasComponent;
    if (referenceName == "has_notifier")
      return ReferenceId::HasNotifier;
    if (referenceName == "has_ordered_component")
      return ReferenceId::HasOrderedComponent;
    if (referenceName == "has_model_parent")
      return ReferenceId::HasModelParent;
    if (referenceName == "from_state")
      return ReferenceId::FromState;
    if (referenceName == "to_state")
      return ReferenceId::ToState;
    if (referenceName == "has_clause")
      return ReferenceId::HasCause;
    if (referenceName == "has_effect")
      return ReferenceId::HasEffect;
    if (referenceName == "has_historical_configuration")
      return ReferenceId::HasHistoricalConfiguration;
    if (referenceName == "has_historical_event_configuration")
      return ReferenceId::HasHistoricalEventConfiguration;
    if (referenceName == "has_substate_machine")
      return ReferenceId::HasSubStateMachine;
    if (referenceName == "has_event_history")
      return ReferenceId::HasEventHistory;
    if (referenceName == "always_generates_event")
      return ReferenceId::AlwaysGeneratesEvent;
    if (referenceName == "has_true_substate")
      return ReferenceId::HasTrueSubState;
    if (referenceName == "has_false_substate")
      return ReferenceId::HasFalseSubState;
    if (referenceName == "has_condition")
      return ReferenceId::HasCondition;
    if (referenceName == "non_hierarchical_references")
      return ReferenceId::NonHierarchicalReferences;
    if (referenceName == "hierarchical_references")
      return ReferenceId::HierarchicalReferences;
    if (referenceName == "has_cause")
      return ReferenceId::HasCause;
    if (referenceName == "has_sub_state_machine")
      return ReferenceId::HasSubStateMachine;
    if (referenceName == "has_true_sub_state")
      return ReferenceId::HasTrueSubState;
    if (referenceName == "has_false_sub_state")
      return ReferenceId::HasFalseSubState;

    throw std::logic_error(std::string("Unknown reference name '") + referenceName + std::string(referenceName));
  }

  struct Reference
  {
    ReferenceId Id;
    NodeId TargetNode;
    bool IsForward;
    NodeClass TargetClass;
    QualifiedName TargetBrowseName;
    LocalizedText TargetDisplayName;
    NodeId TargetType;

    Reference()
      : Id(ReferenceId::Unknown)
      , IsForward(true)
      , TargetClass(NodeClass::Unspecified)
    {
    }
  };

  struct Attribute
  {
    AttributeId Id;
    Variant Value;
    Attribute()
      : Id(AttributeId::Unknown)
    {
    }

    Attribute(AttributeId id, Variant value)
      : Id(id)
      , Value(value)
    {
    }
  };

  struct INode
  {
    NodeId Id;
    std::map<AttributeId, Variant> Attributes;
    std::vector<Reference> References;
    bool IsExternal;

    INode()
      : IsExternal(false)
    {
    }
  };

  struct XmlDocDeleter
  {
    void operator() (xmlDocPtr doc)
    {
      xmlFreeDoc(doc);
    }
  };

  struct LibXmlFree
  {
    void operator() (void* ptr)
    {
      xmlFree(ptr);
    }
  };

  int xmlStrcmp(const xmlChar* xmlStr, const char* str)
  {
    return ::xmlStrcmp(xmlStr, (const xmlChar*)str);
  }

  bool IsXmlNode(const xmlNode& node)
  {
    return node.type == XML_ELEMENT_NODE;
  }

  bool IsXmlNode(const xmlNode& node, const char* name, bool debug = false)
  {
    if (node.type != XML_ELEMENT_NODE)
    {
      return false;
    }

    if (xmlStrcmp(node.name, name))
    {
      return false;
    }
    return true;
  }

  std::string GetNodeName(xmlNode& node)
  {
    if (!node.name)
    {
      return std::string();
    }
    return (const char*)node.name;
  }

  std::string GetProperty(xmlNode& node, const char* propName)
  {
    std::unique_ptr<xmlChar, LibXmlFree> attrValue(xmlGetProp(&node, (const xmlChar*)propName), LibXmlFree());
    const xmlChar* propValue = attrValue.get();
    if (propValue)
    {
      return (const char*)propValue;
    }
    return std::string();
  }

  std::string GetNodeValue(xmlNode& node)
  {
    const std::string nodeValue = GetProperty(node, "value");
    if (!nodeValue.empty())
    {
      return nodeValue;
    }

    std::unique_ptr<xmlChar, LibXmlFree> content(xmlNodeGetContent(&node));
    if (!content)
    {
      return std::string();
    }
    return (const char*)content.get();
  }

  ObjectId GetObjectIdOfType(const std::string& nodeValue)
  {
    if (nodeValue == "bool")
    {
      return ObjectId::Boolean;
    }
    if (nodeValue == "sbyte")
    {
      return ObjectId::SByte;
    }
    if (nodeValue == "byte")
    {
      return ObjectId::Byte;
    }
    if (nodeValue == "int16")
    {
      return ObjectId::Int16;
    }
    if (nodeValue == "uint16")
    {
      return ObjectId::UInt16;
    }
    if (nodeValue == "int32")
    {
      return ObjectId::Int32;
    }
    if (nodeValue == "uint32")
    {
      return ObjectId::UInt32;
    }
    if (nodeValue == "string")
    {
      return ObjectId::String;
    }
    if (nodeValue == "enum")
    {
      return ObjectId::Enumeration;
    }
    if (nodeValue == "int")
    {
      return ObjectId::Integer;
    }
    if (nodeValue == "byte_string")
    {
      return ObjectId::ByteString;
    }
    if (nodeValue == "guid")
    {
      return ObjectId::Guid;
    }
    if (nodeValue == "date_time")
    {
      return ObjectId::DateTime;
    }

    std::stringstream stream;
    stream << "Unknown data type '" << nodeValue << "'.";
    throw std::logic_error(stream.str());
  }

  inline ObjectId GetObjectIdOfType(xmlNode& node)
  {
    return GetObjectIdOfType(GetNodeValue(node));
  }

  inline VariantType ConvertToVariantType(ObjectId id)
  {
    switch (id)
    {
      case ObjectId::Null:        return VariantType::NUL;
      case ObjectId::Boolean:     return VariantType::BOOLEAN;
      case ObjectId::SByte:       return VariantType::SBYTE;
      case ObjectId::Byte:        return VariantType::BYTE;
      case ObjectId::Int16:       return VariantType::INT16;
      case ObjectId::UInt16:      return VariantType::UINT16;

      case ObjectId::Integer:
      case ObjectId::Enumeration:
      case ObjectId::Int32:       return VariantType::INT32;

      case ObjectId::UInt32:      return VariantType::UINT32;
      case ObjectId::Int64:       return VariantType::INT64;
      case ObjectId::UInt64:      return VariantType::UINT64;
      case ObjectId::Float:       return VariantType::FLOAT;
      case ObjectId::Double:      return VariantType::DOUBLE;
      case ObjectId::String:      return VariantType::STRING;
      case ObjectId::ByteString:  return VariantType::BYTE_STRING;
      case ObjectId::DateTime:    return VariantType::DATE_TIME;
      case ObjectId::Guid:        return VariantType::GUId;

      default:
        std::stringstream stream;
        stream << "Cannot convert ObjectId '" << (unsigned)id << "' to VariantType.";
        throw std::logic_error(stream.str());
    }
  }

  inline ObjectId ConvertToObjectId(VariantType type)
  {
    switch (type)
    {
      case VariantType::NUL:         return ObjectId::Null;
      case VariantType::BOOLEAN:     return ObjectId::Boolean;
      case VariantType::SBYTE:       return ObjectId::SByte;
      case VariantType::BYTE:        return ObjectId::Byte;
      case VariantType::INT16:       return ObjectId::Int16;
      case VariantType::UINT16:      return ObjectId::UInt16;
      case VariantType::INT32:       return ObjectId::Int32;
      case VariantType::UINT32:      return ObjectId::UInt32;
      case VariantType::INT64:       return ObjectId::Int64;
      case VariantType::UINT64:      return ObjectId::UInt64;
      case VariantType::FLOAT:       return ObjectId::Float;
      case VariantType::DOUBLE:      return ObjectId::Double;
      case VariantType::STRING:      return ObjectId::String;
      case VariantType::BYTE_STRING: return ObjectId::ByteString;
      case VariantType::DATE_TIME:   return ObjectId::DateTime;
      case VariantType::GUId:        return ObjectId::Guid;

      default:
        std::stringstream stream;
        stream << "Cannot convert VariantType '"<< (unsigned)type << "' to ObjectId.";
        throw std::logic_error(stream.str());
    }
  }

  inline VariantType GetVariantType(xmlNode& node)
  {
    const ObjectId typeId = GetObjectIdOfType(GetProperty(node, "type"));
    return ConvertToVariantType(typeId);
  }

  NodeClass GetNodeClass(xmlNode& node)
  {
    const std::string nodeValue = GetNodeValue(node);
    if (nodeValue == "object")
    {
      return NodeClass::Object;
    }
    if (nodeValue == "variable")
    {
      return NodeClass::Variable;
    }
    if (nodeValue == "method")
    {
      return NodeClass::Method;
    }
    if (nodeValue == "object_type")
    {
      return NodeClass::ObjectType;
    }
    if (nodeValue == "variable_type")
    {
      return NodeClass::VariableType;
    }
    if (nodeValue == "reference_type")
    {
      return NodeClass::ReferenceType;
    }
    if (nodeValue == "data_type")
    {
      return NodeClass::DataType;
    }
    if (nodeValue == "data_type")
    {
      return NodeClass::View;
    }
    std::stringstream stream;
    stream << "Unknown node class '" << nodeValue << "'. Line " << node.line << ".";
    throw std::logic_error(stream.str());
  }

  bool IsNumericNodeType(xmlNode& node)
  {
    const std::string propValue = GetProperty(node, "type");
    return propValue == "numeric";
  }

  uint32_t GetNamespaceIndex(xmlNode& node)
  {
    const std::string propValue = GetProperty(node, "ns");
    return atoi(propValue.c_str());
  }

  NodeId GetNodeId(xmlNode& node)
  {
    std::string nodeValue = GetNodeValue(node);
    if (nodeValue.empty())
    {
      std::stringstream stream;
      stream << "Empty node id. Line " << node.line << ".";
      throw std::logic_error(stream.str());
    }
    uint32_t nsIndex = GetNamespaceIndex(node);
    if (IsNumericNodeType(node))
    {
      return NumericNodeId(atoi(nodeValue.c_str()), nsIndex);
    }
    return StringNodeId(nodeValue, nsIndex);
  }

  bool GetBool(std::string str)
  {
    if (!str.empty() && (str == "false" || str == "0"))
    {
      return false;
    }
    return !str.empty();
  }

  std::string GetText(xmlNode& node)
  {
    const std::string nodeValue = GetNodeValue(node);
    if (nodeValue.empty())
    {
      std::stringstream stream;
      stream << "Empty browse name. Line " << node.line << ".";
      throw std::logic_error(stream.str());
    }
    return nodeValue;
  }


  QualifiedName GetQualifiedName(xmlNode& node)
  {
    return QualifiedName(GetNamespaceIndex(node), GetText(node));
  }

  LocalizedText GetLocalizedText(xmlNode& node)
  {
    const std::string nodeValue = GetNodeValue(node);
    if (nodeValue.empty())
    {
      std::stringstream stream;
      stream << "Empty browse name. Line " << node.line << ".";
      throw std::logic_error(stream.str());
    }
    return LocalizedText(nodeValue);
  }

  uint32_t GetUInt32(xmlNode& node)
  {
    const std::string nodeValue = GetNodeValue(node);
    if (nodeValue.empty())
    {
      std::stringstream stream;
      stream << "Empty opcua attribute value. Line " << node.line << ".";
      throw std::logic_error(stream.str());
    }
    return atoi(nodeValue.c_str());
  }

  int32_t GetInt32(xmlNode& node)
  {
    const std::string nodeValue = GetNodeValue(node);
    if (nodeValue.empty())
    {
      std::stringstream stream;
      stream << "Empty opcua attribute value. Line " << node.line << ".";
      throw std::logic_error(stream.str());
    }
    return atoi(nodeValue.c_str());
  }


  bool GetBool(xmlNode& node)
  {
    const std::string nodeValue = GetNodeValue(node);
    return GetBool(nodeValue);
  }

  Variant GetVariantValue(OpcUa::VariantType type, xmlNode& node)
  {
    const std::string nodeValue = GetNodeValue(node);
    switch (type)
    {
      case VariantType::SBYTE:
        return Variant((int8_t)strtol(nodeValue.c_str(), nullptr, 0));
      case VariantType::BYTE:
        return Variant((uint8_t)strtol(nodeValue.c_str(), nullptr, 0));
      case VariantType::INT16:
        return Variant((int16_t)strtol(nodeValue.c_str(), nullptr, 0));
      case VariantType::UINT16:
        return Variant((uint16_t)strtol(nodeValue.c_str(), nullptr, 0));
      case VariantType::INT32:
        return Variant((int32_t)strtol(nodeValue.c_str(), nullptr, 0));
      case VariantType::UINT32:
        return Variant((uint32_t)strtol(nodeValue.c_str(), nullptr, 0));
      case VariantType::INT64:
        return Variant((int64_t)strtoll(nodeValue.c_str(), nullptr, 0));
      case VariantType::UINT64:
        return Variant((int64_t)strtoll(nodeValue.c_str(), nullptr, 0));
      case VariantType::FLOAT:
        return Variant(strtof(nodeValue.c_str(), nullptr));
      case VariantType::DOUBLE:
        return Variant(strtod(nodeValue.c_str(), nullptr));
      // TODO check for other types.
      case VariantType::NUL:
        return Variant();

      case VariantType::STRING:
      default:
        break;
    }
    return Variant(nodeValue);
  }

  OpcUa::AttributeId GetAttributeId(xmlNode& node)
  {
    if (IsXmlNode(node, "id"))
      return AttributeId::NodeId;
    else if (IsXmlNode(node, "class"))
      return AttributeId::NodeClass;
    else if (IsXmlNode(node, "browse_name"))
      return AttributeId::BrowseName;
    else if (IsXmlNode(node, "display_name"))
      return AttributeId::DisplayName;
    else if (IsXmlNode(node, "description"))
      return AttributeId::Description;
    else if (IsXmlNode(node, "write_mask"))
      return AttributeId::WriteMask;
    else if (IsXmlNode(node, "user_write_mask"))
      return AttributeId::UserWriteMask;
    else if (IsXmlNode(node, "is_abstract"))
      return AttributeId::IsAbstract;
    else if (IsXmlNode(node, "symmetric"))
      return AttributeId::Symmetric;
    else if (IsXmlNode(node, "inverse_name"))
      return AttributeId::InverseName;
    else if (IsXmlNode(node, "contains_no_loops"))
      return AttributeId::ContainsNoLoops;
    else if (IsXmlNode(node, "event_notifier"))
      return AttributeId::EventNotifier;
    else if (IsXmlNode(node, "value"))
      return AttributeId::Value;
    else if (IsXmlNode(node, "value_rank"))
      return AttributeId::ValueRank;
    else if (IsXmlNode(node, "data_type"))
      return AttributeId::DataType;
    else if (IsXmlNode(node, "array_dimensions"))
      return AttributeId::ArrayDimensions;
    else if (IsXmlNode(node, "access_level"))
      return AttributeId::AccessLevel;
    else if (IsXmlNode(node, "user_access_level"))
      return AttributeId::UserAccessLevel;
    else if (IsXmlNode(node, "minimum_sampling_interval"))
      return AttributeId::MinimumSamplingInterval;
    else if (IsXmlNode(node, "historizing"))
      return AttributeId::Historizing;
    else if (IsXmlNode(node, "executable"))
      return AttributeId::Executable;
    else if (IsXmlNode(node, "user_executable"))
      return AttributeId::UserExecutable;

    return AttributeId::Unknown;
  }

  Variant GetAttributeValue(OpcUa::AttributeId id, xmlNode& node)
  {
    switch (id)
    {
      case AttributeId::NodeId:
        return Variant(GetNodeId(node));

      case AttributeId::NodeClass:
        return Variant((int32_t)GetNodeClass(node));

      case AttributeId::DisplayName:
        return Variant(GetLocalizedText(node));

      case AttributeId::BrowseName:
        return Variant(GetQualifiedName(node));

      case AttributeId::Description:
      case AttributeId::InverseName:
        return Variant(GetText(node));

      case AttributeId::EventNotifier:
        return Variant(std::vector<uint8_t>{0});

      case AttributeId::ValueRank:
        return Variant(GetInt32(node));

      case AttributeId::WriteMask:
      case AttributeId::UserWriteMask:
      case AttributeId::ArrayDimensions:
      case AttributeId::AccessLevel:
      case AttributeId::UserAccessLevel:
      case AttributeId::MinimumSamplingInterval:
        return Variant(GetUInt32(node));

      case AttributeId::IsAbstract:
      case AttributeId::Symmetric:
      case AttributeId::ContainsNoLoops:
      case AttributeId::Historizing:
      case AttributeId::Executable:
      case AttributeId::UserExecutable:
        return Variant(GetBool(node));

      case AttributeId::Value:
        break;

      case AttributeId::DataType:
        return Variant(GetObjectIdOfType(node));

      default:
        return Variant(GetText(node));
    }
    const VariantType type = GetVariantType(node);
    return GetVariantValue(type, node);
  }

  class AttributesCollector : private Internal::XmlProcessor
  {
  public:
    AttributesCollector(INode& node, bool debug)
      : OpcUaNode(node)
      , Debug(debug)
    {
    }

    virtual void Process(xmlNode& node)
    {
      for (xmlNodePtr subNode = node.children; subNode; subNode = subNode->next)
      {
        if (!IsXmlNode(*subNode))
        {
          continue;
        }
        const AttributeId attribute = GetAttributeId(*subNode);
        if (attribute == AttributeId::NodeId)
        {
          OpcUaNode.Id = GetNodeId(*subNode);
          continue;
        }

        const Variant value = GetAttributeValue(attribute, *subNode);
        AddAttribute(attribute, value);
      }

      // If tag 'data_type' is absent in the xml then need to add data type which will be based on type of value.
      if (!HasAttribute(AttributeId::DataType) && HasAttribute(AttributeId::Value))
      {
        AddAttribute(AttributeId::DataType, GetDataType(AttributeId::Value));
      }
    }

  private:
    bool IsAttributes(const xmlNode& node) const
    {
      return IsXmlNode(node, "attributes");
    }

    template <typename T>
    void AddAttribute(AttributeId attr, const T& value)
    {
      OpcUaNode.Attributes.insert(std::make_pair(attr, Variant(value)));
    }

    bool HasAttribute(AttributeId attr) const
    {
      return OpcUaNode.Attributes.find(AttributeId::DataType) != OpcUaNode.Attributes.end();
    }

    ObjectId GetDataType(AttributeId attr) const
    {
      auto attrPos = OpcUaNode.Attributes.find(attr);
      if (attrPos == OpcUaNode.Attributes.end())
      {
        return ObjectId::Null;
      }
      return ConvertToObjectId(attrPos->second.Type());
    }

  private:
    INode& OpcUaNode;
    const bool Debug;
  };

  class ReferencesCollector : private Internal::XmlProcessor
  {
  public:
    ReferencesCollector(INode& node, bool debug)
      : OpcUaNode(node)
      , Debug(debug)
    {
    }

    virtual void Process(xmlNode& node)
    {
      for (xmlNodePtr refNode = node.children; refNode; refNode = refNode->next)
      {
        if (!IsXmlNode(*refNode))
        {
          continue;
        }

        try
        {
          AddReferenceToNode(*refNode);
        }
        catch (const std::exception& exc)
        {
          std::cerr << exc.what() << std::endl;
        }
      }
    }

  private:
    void AddReferenceToNode(xmlNode& refNode)
    {
      const std::string refName = GetNodeName(refNode);
      const NodeId targetNode = GetNodeId(refNode);
      Reference reference;
      reference.Id = GetReferenceId(refName);

      for (xmlNodePtr subNode = refNode.children; subNode; subNode = subNode->next)
      {
        if (!IsXmlNode(*subNode))
        {
          continue;
        }

        const std::string& nodeName = GetNodeName(*subNode);
        if (nodeName == "id")
        {
          reference.TargetNode = GetNodeId(*subNode);
        }
        else if (nodeName == "class")
        {
          reference.TargetClass = GetNodeClass(*subNode);
        }
        else if (nodeName == "browse_name")
        {
          reference.TargetBrowseName = GetQualifiedName(*subNode);
        }
        else if (nodeName == "display_name")
        {
          reference.TargetDisplayName = GetLocalizedText(*subNode);
        }
        else if (nodeName == "is_forward")
        {
          reference.IsForward = GetBool(GetNodeValue(*subNode));
        }
        else if (nodeName == "type_definition")
        {
          reference.TargetType = GetNodeId(*subNode);
        }
      }

      EnsureValid(reference, refNode.line);
      OpcUaNode.References.push_back(reference);
    }

  private:
    void EnsureValid(const Reference& ref, int lineNum) const
    {
      std::stringstream stream;
      if (ref.Id == ReferenceId::Unknown)
      {
        stream << "Unknown reference type. line" << lineNum << ".";
        throw std::logic_error(stream.str());
      }
      if (ref.TargetNode == NodeId())
      {
        stream << "Empty target node Id. line" << lineNum << ".";
        throw std::logic_error(stream.str());
      }
    }

  private:
    INode& OpcUaNode;
    const bool Debug;
  };

  class NodesCollector : private Internal::XmlProcessor
  {
  public:
    NodesCollector(std::map<NodeId, INode>& nodes, bool debug)
      : Nodes(nodes)
      , Debug(debug)
    {
    }

    virtual void Process(xmlNode& node)
    {
      if (!IsXmlNode(node))
      {
        return;
      }

      INode opcuaNode;
      if (IsXmlNode(node, "node"))
      {
        opcuaNode.IsExternal = false;
      }
      else if (IsXmlNode(node, "external"))
      {
        opcuaNode.IsExternal = true;
      }
      else
      {
        if (Debug)
        {
          std::cerr << "Unknown node '" << node.name << "' at line " << node.line <<  "." << std::endl;
        }
        return;
      }

      FillNode(node, opcuaNode);
      EnsureNodeIsValid(opcuaNode, node);
      Nodes.insert(std::make_pair(opcuaNode.Id, opcuaNode));
    }

  private:
    void EnsureNodeIsValid(const INode& opcuaNode, const xmlNode& node) const
    {
      if (opcuaNode.Id == NodeId())
      {
        std::stringstream stream;
        stream << "INode at line '" << node.line << "' has no Id.";
        throw std::logic_error(stream.str());
      }
    }

    void FillNode(const xmlNode& node, INode& opcuaNode) const
    {
      AttributesCollector attributeCollector(opcuaNode, Debug);
      ReferencesCollector referencCollector(opcuaNode, Debug);

      for (xmlNodePtr subNode = node.children; subNode; subNode = subNode->next)
      {
        if (IsXmlNode(*subNode, "attributes"))
        {
          attributeCollector.Process(*subNode);
          continue;
        }
        else if (IsXmlNode(*subNode, "references"))
        {
          referencCollector.Process(*subNode);
        }
        else if (Debug)
        {
          std::cerr << "Unknown node '" << subNode->name << "' at line " << subNode->line <<  "." << std::endl;
        }
      }
    }

  private:
    std::map<NodeId, INode>& Nodes;
    const bool Debug;
  };


  class ConfigurationProcessor
  {
  public:
    ConfigurationProcessor(bool debug)
      : Debug(debug)
    {

    }

    std::map<NodeId, INode> Process(xmlDoc& doc)
    {
      xmlNodePtr rootNode = xmlDocGetRootElement(&doc);
      EnsureRootNodeValid(*rootNode);

      std::map<NodeId, INode> nodes;
      NodesCollector nodesBuilder(nodes, Debug);
      for (xmlNodePtr cur = rootNode->children; cur; cur = cur->next)
      {
        nodesBuilder.Process(*cur);
      }

      return nodes;
    }

  private:
    void EnsureRootNodeValid(xmlNode& rootNode)
    {
      if (rootNode.type != XML_ELEMENT_NODE)
      {
        throw std::logic_error("Root element is not a node.'");
      }
      if (xmlStrcmp(rootNode.name, "address_space"))
      {
        throw std::logic_error(std::string("Invalid root element '") + (const char*)rootNode.name + std::string("'."));
      }
      std::unique_ptr<xmlChar, LibXmlFree> versionBuf(xmlGetProp(&rootNode, (const xmlChar*)"version"), LibXmlFree());
      const xmlChar* version = versionBuf.get();
      if (!version)
      {
        throw std::logic_error("Address space element has no 'version' attribute.");
      }
      if (xmlStrcmp(version, "1"))
      {
        throw std::logic_error(std::string("Unknown version '") + (const char*)version + std::string("'of address space."));
      }
    }

  private:
    const bool Debug;
  };

  std::map<NodeId, INode> ParseConfig(const char* configPath, bool debug)
  {
    std::unique_ptr<xmlDoc, XmlDocDeleter> doc(xmlParseFile(configPath), XmlDocDeleter());
    if (!doc)
    {
      throw std::logic_error(std::string("Cannot load file '") + std::string(configPath) + std::string("'"));
    }
    ConfigurationProcessor xmlConfiguration(debug);
    return xmlConfiguration.Process(*doc);
  }


  class NodesRegistrator
  {
  public:
    NodesRegistrator(OpcUa::NodeManagementServices& registry, bool debug)
      : Registry(registry)
      , Debug(debug)
    {
    }

    void RegisterNodes(const std::map<NodeId, INode>& nodes)
    {
      for (const auto& node : nodes)
      {
        if (!node.second.IsExternal)
        {
          RegisterNode(node.second);
        }
        AddReferences(node.second);
      }
    }

  private:
    void RegisterNode(const INode& node)
    {
      //Registry.AddAttribute(node.Id, AttributeId::NodeId, Variant(node.Id));
      for (const std::pair<AttributeId, Variant>& attr : node.Attributes)
      {
        //Registry.AddAttribute(node.Id, attr.first, attr.second);
      }
    }

    void AddReferences(const INode& node)
    {
      for (const Reference& ref : node.References)
      {
        ReferenceDescription desc;
        desc.BrowseName = ref.TargetBrowseName;
        desc.DisplayName = ref.TargetDisplayName;
        desc.IsForward = ref.IsForward;
        desc.ReferenceTypeId = ref.Id;
        desc.TargetNodeClass = ref.TargetClass;
        desc.TargetNodeId = ref.TargetNode;
        desc.TargetNodeTypeDefinition = ref.TargetType;
        //Registry.AddReference(node.Id, desc);
      }
    }

  private:
    OpcUa::NodeManagementServices& Registry;
    const bool Debug;
  };
} // namespace

namespace OpcUa
{
  namespace Internal
  {

    XmlAddressSpaceLoader::XmlAddressSpaceLoader(OpcUa::NodeManagementServices& registry, bool debug)
      : Registry(registry)
      , Debug(debug)
    {
    }

    void XmlAddressSpaceLoader::Load(const char* fileName)
    {
      std::map<NodeId, INode> nodes = ParseConfig(fileName, Debug);
      NodesRegistrator reg(Registry, Debug);
      reg.RegisterNodes(nodes);
    }

  } // namespace Internal
} // namespace OpcUa