src/protocol/binary_node_management.cpp

Go to the documentation of this file.

#include "binary_serialization.h"

#include <opc/ua/protocol/attribute_ids.h>
#include <opc/ua/protocol/expanded_object_ids.h>
#include <opc/ua/protocol/binary/stream.h>
#include <opc/ua/protocol/types.h>
#include <opc/ua/protocol/node_management.h>
#include <opc/ua/protocol/string_utils.h>

#include <algorithm>
#include <memory>
#include <string>
#include <iostream>

namespace OpcUa
{


NodeAttributes::NodeAttributes(const ObjectAttributes & attr)
{
  Header.TypeId = ExpandedObjectId::ObjectAttribute;
  Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);

  std::bitset<32> specattr;
  specattr.set(SpecifiedAttributesEncoding::DisplayName);
  specattr.set(SpecifiedAttributesEncoding::Description);
  specattr.set(SpecifiedAttributesEncoding::EventNotifier);
  specattr.set(SpecifiedAttributesEncoding::WriteMask);
  specattr.set(SpecifiedAttributesEncoding::UserWriteMask);
  SpecifiedAttributes = (uint32_t) specattr.to_ulong();

  Attributes[AttributeId::DisplayName] = attr.DisplayName;
  Attributes[AttributeId::Description] = attr.Description;
  Attributes[AttributeId::EventNotifier] = attr.EventNotifier;
  Attributes[AttributeId::WriteMask] = attr.WriteMask;
  Attributes[AttributeId::UserWriteMask] = attr.UserWriteMask;
}

NodeAttributes::NodeAttributes(const VariableAttributes & attr)
{
  Header.TypeId = ExpandedObjectId::VariableAttribute;
  Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);

  std::bitset<32> specattr;
  specattr.set(SpecifiedAttributesEncoding::DisplayName);
  specattr.set(SpecifiedAttributesEncoding::Description);
  specattr.set(SpecifiedAttributesEncoding::Value);
  specattr.set(SpecifiedAttributesEncoding::DataType);
  specattr.set(SpecifiedAttributesEncoding::ValueRank);
  specattr.set(SpecifiedAttributesEncoding::ArrayDimensions);
  specattr.set(SpecifiedAttributesEncoding::AccessLevel);
  specattr.set(SpecifiedAttributesEncoding::UserAccessLevel);
  specattr.set(SpecifiedAttributesEncoding::MinimumSamplingInterval);
  specattr.set(SpecifiedAttributesEncoding::Historizing);
  specattr.set(SpecifiedAttributesEncoding::WriteMask);
  specattr.set(SpecifiedAttributesEncoding::UserWriteMask);
  SpecifiedAttributes = (uint32_t) specattr.to_ulong();

  Attributes[AttributeId::DisplayName] = attr.DisplayName;
  Attributes[AttributeId::Description] = attr.Description;
  Attributes[AttributeId::Value] = attr.Value;
  Attributes[AttributeId::DataType] = attr.Type;
  Attributes[AttributeId::ValueRank] = attr.Rank;
  Attributes[AttributeId::ArrayDimensions] = attr.Dimensions;
  Attributes[AttributeId::AccessLevel] = static_cast<uint8_t>(attr.AccessLevel);
  Attributes[AttributeId::UserAccessLevel] = static_cast<uint8_t>(attr.UserAccessLevel);
  Attributes[AttributeId::MinimumSamplingInterval] = attr.MinimumSamplingInterval;
  Attributes[AttributeId::Historizing] = attr.Historizing;
  Attributes[AttributeId::WriteMask] = attr.WriteMask;
  Attributes[AttributeId::UserWriteMask] = attr.UserWriteMask;
}

NodeAttributes::NodeAttributes(const MethodAttributes & attr)
{
  Header.TypeId = ExpandedObjectId::MethodAttribute;
  Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);

  std::bitset<32> specattr;
  specattr.set(SpecifiedAttributesEncoding::DisplayName);
  specattr.set(SpecifiedAttributesEncoding::Description);
  specattr.set(SpecifiedAttributesEncoding::Executable);
  specattr.set(SpecifiedAttributesEncoding::UserExecutable);
  specattr.set(SpecifiedAttributesEncoding::WriteMask);
  specattr.set(SpecifiedAttributesEncoding::UserWriteMask);
  SpecifiedAttributes = (uint32_t) specattr.to_ulong();

  Attributes[AttributeId::DisplayName] = attr.DisplayName;
  Attributes[AttributeId::Description] = attr.Description;
  Attributes[AttributeId::Executable] = attr.Executable;
  Attributes[AttributeId::UserExecutable] = attr.UserExecutable;
  Attributes[AttributeId::WriteMask] = attr.WriteMask;
  Attributes[AttributeId::UserWriteMask] = attr.UserWriteMask;
}
NodeAttributes::NodeAttributes(const ObjectTypeAttributes & attr)
{
  Header.TypeId = ExpandedObjectId::ObjectTypeAttribute;
  Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);

  std::bitset<32> specattr;
  specattr.set(SpecifiedAttributesEncoding::DisplayName);
  specattr.set(SpecifiedAttributesEncoding::Description);
  specattr.set(SpecifiedAttributesEncoding::IsAbstract);
  specattr.set(SpecifiedAttributesEncoding::WriteMask);
  specattr.set(SpecifiedAttributesEncoding::UserWriteMask);
  SpecifiedAttributes = (uint32_t) specattr.to_ulong();

  Attributes[AttributeId::DisplayName] = attr.DisplayName;
  Attributes[AttributeId::Description] = attr.Description;
  Attributes[AttributeId::IsAbstract] = attr.IsAbstract;
  Attributes[AttributeId::WriteMask] = attr.WriteMask;
  Attributes[AttributeId::UserWriteMask] = attr.UserWriteMask;
}

NodeAttributes::NodeAttributes(const VariableTypeAttributes & attr)
{
  Header.TypeId = ExpandedObjectId::VariableTypeAttribute;
  Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);

  std::bitset<32> specattr;
  specattr.set(SpecifiedAttributesEncoding::DisplayName);
  specattr.set(SpecifiedAttributesEncoding::Description);
  specattr.set(SpecifiedAttributesEncoding::Value);
  specattr.set(SpecifiedAttributesEncoding::DataType);
  specattr.set(SpecifiedAttributesEncoding::ValueRank);
  specattr.set(SpecifiedAttributesEncoding::ArrayDimensions);
  specattr.set(SpecifiedAttributesEncoding::IsAbstract);
  specattr.set(SpecifiedAttributesEncoding::WriteMask);
  specattr.set(SpecifiedAttributesEncoding::UserWriteMask);
  SpecifiedAttributes = (uint32_t) specattr.to_ulong();

  Attributes[AttributeId::DisplayName] = attr.DisplayName;
  Attributes[AttributeId::Description] = attr.Description;
  Attributes[AttributeId::Value] = attr.Value;
  Attributes[AttributeId::DataType] = attr.Type;
  Attributes[AttributeId::ValueRank] = attr.Rank;
  Attributes[AttributeId::IsAbstract] = attr.IsAbstract;
  Attributes[AttributeId::ArrayDimensions] = attr.Dimensions;
  Attributes[AttributeId::WriteMask] = attr.WriteMask;
  Attributes[AttributeId::UserWriteMask] = attr.UserWriteMask;
}

NodeAttributes::NodeAttributes(const ReferenceTypeAttributes & attr)
{
  Header.TypeId = ExpandedObjectId::ReferenceTypeAttribute;
  Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);

  std::bitset<32> specattr;
  specattr.set(SpecifiedAttributesEncoding::DisplayName);
  specattr.set(SpecifiedAttributesEncoding::Description);
  specattr.set(SpecifiedAttributesEncoding::IsAbstract);
  specattr.set(SpecifiedAttributesEncoding::Symmetric);
  specattr.set(SpecifiedAttributesEncoding::WriteMask);
  specattr.set(SpecifiedAttributesEncoding::UserWriteMask);

  if (!attr.IsAbstract)
    { specattr.set(SpecifiedAttributesEncoding::InverseName); }

  SpecifiedAttributes = (uint32_t) specattr.to_ulong();

  Attributes[AttributeId::DisplayName] = attr.DisplayName;
  Attributes[AttributeId::Description] = attr.Description;
  Attributes[AttributeId::IsAbstract] = attr.IsAbstract;
  Attributes[AttributeId::Symmetric] = attr.Symmetric;
  Attributes[AttributeId::WriteMask] = attr.WriteMask;
  Attributes[AttributeId::UserWriteMask] = attr.UserWriteMask;

  if (!attr.IsAbstract)
    { Attributes[AttributeId::InverseName] = attr.InverseName; }
}

NodeAttributes::NodeAttributes(const DataTypeAttributes & attr)
{
  Header.TypeId = ExpandedObjectId::DataTypeAttribute;
  Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);

  std::bitset<32> specattr;
  specattr.set(SpecifiedAttributesEncoding::DisplayName);
  specattr.set(SpecifiedAttributesEncoding::Description);
  specattr.set(SpecifiedAttributesEncoding::IsAbstract);
  specattr.set(SpecifiedAttributesEncoding::WriteMask);
  specattr.set(SpecifiedAttributesEncoding::UserWriteMask);
  SpecifiedAttributes = (uint32_t) specattr.to_ulong();

  Attributes[AttributeId::DisplayName] = attr.DisplayName;
  Attributes[AttributeId::Description] = attr.Description;
  Attributes[AttributeId::IsAbstract] = attr.IsAbstract;
  Attributes[AttributeId::WriteMask] = attr.WriteMask;
  Attributes[AttributeId::UserWriteMask] = attr.UserWriteMask;
}

NodeAttributes::NodeAttributes(const ViewAttributes & attr)
{
  Header.TypeId = ExpandedObjectId::ViewAttribute;
  Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);

  std::bitset<32> specattr;
  specattr.set(SpecifiedAttributesEncoding::DisplayName);
  specattr.set(SpecifiedAttributesEncoding::Description);
  specattr.set(SpecifiedAttributesEncoding::ContainsNoLoops);
  specattr.set(SpecifiedAttributesEncoding::WriteMask);
  specattr.set(SpecifiedAttributesEncoding::UserWriteMask);
  SpecifiedAttributes = (uint32_t) specattr.to_ulong();

  Attributes[AttributeId::DisplayName] = attr.DisplayName;
  Attributes[AttributeId::Description] = attr.Description;
  Attributes[AttributeId::ContainsNoLoops] = attr.ContainsNoLoops;
  Attributes[AttributeId::WriteMask] = attr.WriteMask;
  Attributes[AttributeId::UserWriteMask] = attr.UserWriteMask;
}



AddNodesRequest::AddNodesRequest()
  : TypeId(ADD_NODES_REQUEST)
{
}

AddNodesResponse::AddNodesResponse()
  : TypeId(ADD_NODES_RESPONSE)
{
}

AddReferencesRequest::AddReferencesRequest()
  : TypeId(ADD_REFERENCES_REQUEST)
{
}

AddReferencesResponse::AddReferencesResponse()
  : TypeId(ADD_REFERENCES_RESPONSE)
{
}

namespace Binary
{

//
//AddNodeRequest
//
/*
    template<>
    std::size_t RawSize<ObjectAttributes>(const ObjectAttributes& val)
    {
      return RawSize(val.SpecifiedAttributes) +
        RawSize(val.DisplayName) +
        RawSize(val.Description) +
        RawSize(val.EventNotifier) +
        RawSize(val.WriteMask) +
        RawSize(val.UserWriteMask)
        ;
    }

    template<>
    void DataSerializer::Serialize<ObjectAttributes>(const ObjectAttributes& val)
    {
      *this << val.SpecifiedAttributes;
      *this << val.DisplayName;
      *this << val.Description;
      *this << val.EventNotifier;
      *this << val.WriteMask;
      *this << val.UserWriteMask;
    }

    template<>
    void DataDeserializer::Deserialize<ObjectAttributes>(ObjectAttributes& val)
    {
      *this >> val.SpecifiedAttributes;
      *this >> val.DisplayName;
      *this >> val.Description;
      *this >> val.EventNotifier;
      *this >> val.WriteMask;
      *this >> val.UserWriteMask;
    }

    template<>
    std::size_t RawSize<VariableAttributes>(const VariableAttributes& val)
    {
      return RawSize(val.SpecifiedAttributes) +
        RawSize(val.DisplayName) +
        RawSize(val.Description) +
        RawSize(val.Value) +
        RawSize(val.Type) +
        RawSize(val.Rank) +
        RawSizeContainer(val.Dimensions) +
        RawSize((uint8_t)val.AccessLevel) +
        RawSize((uint8_t)val.UserAccessLevel) +
        RawSize(val.MinimumSamplingInterval) +
        RawSize(val.Historizing) +
        RawSize(val.WriteMask) +
        RawSize(val.UserWriteMask)
        ;
    }

    template<>
    void DataSerializer::Serialize<VariableAttributes>(const VariableAttributes& val)
    {
      *this << val.SpecifiedAttributes;
      *this << val.DisplayName;
      *this << val.Description;
      *this << val.Value;
      *this << val.Type;
      *this << val.Rank;
      *this << val.Dimensions;
      *this << (uint8_t)val.AccessLevel; // TODO
      *this << (uint8_t)val.UserAccessLevel; //TODO
      *this << val.MinimumSamplingInterval;
      *this << val.Historizing;
      *this << val.WriteMask;
      *this << val.UserWriteMask;
    }

    template<>
    void DataDeserializer::Deserialize<VariableAttributes>(VariableAttributes& val)
    {
      *this >> val.SpecifiedAttributes;
      *this >> val.DisplayName;
      *this >> val.Description;
      *this >> val.Value;
      *this >> val.Type;
      *this >> val.Rank;
      *this >> val.Dimensions;
      uint8_t tmp = 0;
      *this >> tmp; val.AccessLevel = static_cast<VariableAccessLevel>(tmp);
      *this >> tmp; val.UserAccessLevel = static_cast<VariableAccessLevel>(tmp);
      *this >> val.MinimumSamplingInterval;
      *this >> val.Historizing;
      *this >> val.WriteMask;
      *this >> val.UserWriteMask;
    }


    template<>
    std::size_t RawSize<MethodAttributes>(const MethodAttributes& val)
    {
      return RawSize(val.SpecifiedAttributes) +
        RawSize(val.DisplayName) +
        RawSize(val.Description) +
        RawSize(val.Executable) +
        RawSize(val.UserExecutable) +
        RawSize(val.WriteMask) +
        RawSize(val.UserWriteMask)
        ;
    }

    template<>
    void DataSerializer::Serialize<MethodAttributes>(const MethodAttributes& val)
    {
      *this << val.SpecifiedAttributes;
      *this << val.DisplayName;
      *this << val.Description;
      *this << val.Executable;
      *this << val.UserExecutable;
      *this << val.WriteMask;
      *this << val.UserWriteMask;
    }

    template<>
    void DataDeserializer::Deserialize<MethodAttributes>(MethodAttributes& val)
    {
      *this >> val.SpecifiedAttributes;
      *this >> val.DisplayName;
      *this >> val.Description;
      *this >> val.Executable;
      *this >> val.UserExecutable;
      *this >> val.WriteMask;
      *this >> val.UserWriteMask;
    }

    template<>
    std::size_t RawSize<ObjectTypeAttributes>(const ObjectTypeAttributes& val)
    {
      return RawSize(val.SpecifiedAttributes) +
        RawSize(val.DisplayName) +
        RawSize(val.Description) +
        RawSize(val.IsAbstract) +
        RawSize(val.WriteMask) +
        RawSize(val.UserWriteMask)
        ;
    }

    template<>
    void DataSerializer::Serialize<ObjectTypeAttributes>(const ObjectTypeAttributes& val)
    {
      *this << val.SpecifiedAttributes;
      *this << val.DisplayName;
      *this << val.Description;
      *this << val.IsAbstract;
      *this << val.WriteMask;
      *this << val.UserWriteMask;
    }

    template<>
    void DataDeserializer::Deserialize<ObjectTypeAttributes>(ObjectTypeAttributes& val)
    {
      *this >> val.SpecifiedAttributes;
      *this >> val.DisplayName;
      *this >> val.Description;
      *this >> val.IsAbstract;
      *this >> val.WriteMask;
      *this >> val.UserWriteMask;
    }


    template<>
    std::size_t RawSize<VariableTypeAttributes>(const VariableTypeAttributes& val)
    {
      return RawSize(val.SpecifiedAttributes) +
        RawSize(val.DisplayName) +
        RawSize(val.Description) +
        RawSize(val.Value) +
        RawSize(val.Type) +
        RawSize(val.Rank) +
        RawSizeContainer(val.Dimensions) +
        RawSize(val.IsAbstract) +
        RawSize(val.WriteMask) +
        RawSize(val.UserWriteMask)
        ;
    }

    template<>
    void DataSerializer::Serialize<VariableTypeAttributes>(const VariableTypeAttributes& val)
    {
      *this << val.SpecifiedAttributes;
      *this << val.DisplayName;
      *this << val.Description;
      *this << val.Value;
      *this << val.Type;
      *this << val.Rank;
      *this << val.Dimensions;
      *this << val.IsAbstract;
      *this << val.WriteMask;
      *this << val.UserWriteMask;
    }

    template<>
    void DataDeserializer::Deserialize<VariableTypeAttributes>(VariableTypeAttributes& val)
    {
      *this >> val.SpecifiedAttributes;
      *this >> val.DisplayName;
      *this >> val.Description;
      *this >> val.Value;
      *this >> val.Type;
      *this >> val.Rank;
      *this >> val.Dimensions;
      *this >> val.IsAbstract;
      *this >> val.WriteMask;
      *this >> val.UserWriteMask;
    }


    template<>
    std::size_t RawSize<ReferenceTypeAttributes>(const ReferenceTypeAttributes& val)
    {
      return RawSize(val.SpecifiedAttributes) +
        RawSize(val.DisplayName) +
        RawSize(val.Description) +
        RawSize(val.IsAbstract) +
        RawSize(val.Symmetric) +
        RawSize(val.InverseName) +
        RawSize(val.WriteMask) +
        RawSize(val.UserWriteMask)
        ;
    }

    template<>
    void DataSerializer::Serialize<ReferenceTypeAttributes>(const ReferenceTypeAttributes& val)
    {
      *this << val.SpecifiedAttributes;
      *this << val.DisplayName;
      *this << val.Description;
      *this << val.IsAbstract;
      *this << val.Symmetric;
      *this << val.InverseName;
      *this << val.WriteMask;
      *this << val.UserWriteMask;
    }

    template<>
    void DataDeserializer::Deserialize<ReferenceTypeAttributes>(ReferenceTypeAttributes& val)
    {
      *this >> val.SpecifiedAttributes;
      *this >> val.DisplayName;
      *this >> val.Description;
      *this >> val.IsAbstract;
      *this >> val.Symmetric;
      *this >> val.InverseName;
      *this >> val.WriteMask;
      *this >> val.UserWriteMask;
    }


    template<>
    std::size_t RawSize<DataTypeAttributes>(const DataTypeAttributes& val)
    {
      return RawSize(val.SpecifiedAttributes) +
        RawSize(val.DisplayName) +
        RawSize(val.Description) +
        RawSize(val.IsAbstract) +
        RawSize(val.WriteMask) +
        RawSize(val.UserWriteMask)
        ;
    }

    template<>
    void DataSerializer::Serialize<DataTypeAttributes>(const DataTypeAttributes& val)
    {
      *this << val.SpecifiedAttributes;
      *this << val.DisplayName;
      *this << val.Description;
      *this << val.IsAbstract;
      *this << val.WriteMask;
      *this << val.UserWriteMask;
    }

    template<>
    void DataDeserializer::Deserialize<DataTypeAttributes>(DataTypeAttributes& val)
    {
      *this >> val.SpecifiedAttributes;
      *this >> val.DisplayName;
      *this >> val.Description;
      *this >> val.IsAbstract;
      *this >> val.WriteMask;
      *this >> val.UserWriteMask;
    }

    template<>
    std::size_t RawSize<ViewAttributes>(const ViewAttributes& val)
    {
      return RawSize(val.SpecifiedAttributes) +
        RawSize(val.DisplayName) +
        RawSize(val.Description) +
        RawSize(val.ContainsNoLoops) +
        RawSize(val.WriteMask) +
        RawSize(val.UserWriteMask)
        ;
    }

    template<>
    void DataSerializer::Serialize<ViewAttributes>(const ViewAttributes& val)
    {
      *this << val.SpecifiedAttributes;
      *this << val.DisplayName;
      *this << val.Description;
      *this << val.ContainsNoLoops;
      *this << val.WriteMask;
      *this << val.UserWriteMask;
    }

    // TODO Seems doesn't required because there is serialization of NodeAttributes
    // TODO Exact attributes have to be initialized from node attributes which will serialize.
    template<>
    void DataDeserializer::Deserialize<ViewAttributes>(ViewAttributes& val)
    {
      *this >> val.SpecifiedAttributes;
      *this >> val.DisplayName;
      *this >> val.Description;
      *this >> val.ContainsNoLoops;
      *this >> val.WriteMask;
      *this >> val.UserWriteMask;
    }
*/


std::size_t RawSizeBodyNodeAttributes(const NodeAttributes & val)
{
  size_t total = 0;
  total += RawSize(val.SpecifiedAttributes);

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::DisplayName))
    {
      total += RawSize(val.Attributes.find(AttributeId::DisplayName)->second.As<LocalizedText>()); //We assume the attr exists!!!
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Description))
    {
      total += RawSize(val.Attributes.find(AttributeId::Description)->second.As<LocalizedText>());
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::EventNotifier))
    {
      total += 1;//RawSize(val.Attributes.find(AttributeId::EventNotifier)->second.Value.U);
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Value))
    {
      total += RawSize(val.Attributes.find(AttributeId::Value)->second);
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::DataType))
    {
      total += RawSize(val.Attributes.find(AttributeId::DataType)->second.As<NodeId>());
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::ValueRank))
    {
      total += 4;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::ArrayDimensions))
    {
      total += RawSizeContainer(val.Attributes.find(AttributeId::ArrayDimensions)->second.As<std::vector<uint32_t>>());
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::AccessLevel))
    {
      total += 1;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::UserAccessLevel))
    {
      total += 1;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::MinimumSamplingInterval))
    {
      total += sizeof(double);
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Historizing))
    {
      total += sizeof(bool);
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Executable))
    {
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::UserExecutable))
    {
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::IsAbstract))
    {
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Symmetric))
    {
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::InverseName))
    {
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::ContainsNoLoops))
    {
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::WriteMask))
    {
      total += 4;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::UserWriteMask))
    {
      total += 4;
    }

  return total;

}


template<>
std::size_t RawSize<NodeAttributes>(const NodeAttributes & val)
{
  size_t total = 0;
  total += RawSize(val.Header);
  total += 4 ; //uint32_t size body
  total += RawSizeBodyNodeAttributes(val) ;
  return total;
}



template<>
void DataSerializer::Serialize<NodeAttributes>(const NodeAttributes & val)
{
  *this << val.Header;
  *this << (int32_t) RawSizeBodyNodeAttributes(val); //debug
  *this << val.SpecifiedAttributes;

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::DisplayName))
    {
      *this << val.Attributes.find(AttributeId::DisplayName)->second.As<LocalizedText>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Description))
    {
      *this << val.Attributes.find(AttributeId::Description)->second.As<LocalizedText>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::WriteMask))
    {
      *this << val.Attributes.find(AttributeId::WriteMask)->second.As<uint32_t>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::UserWriteMask))
    {
      *this << val.Attributes.find(AttributeId::UserWriteMask)->second.As<uint32_t>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::EventNotifier))
    {
      *this << (uint8_t) val.Attributes.find(AttributeId::EventNotifier)->second.As<uint8_t>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Value))
    {
      *this << val.Attributes.find(AttributeId::Value)->second;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::DataType))
    {
      *this << val.Attributes.find(AttributeId::DataType)->second.As<NodeId>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::ValueRank))
    {
      *this << val.Attributes.find(AttributeId::ValueRank)->second.As<int32_t>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::ArrayDimensions))
    {
      *this << val.Attributes.find(AttributeId::ArrayDimensions)->second.As<std::vector<uint32_t>>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::AccessLevel))
    {
      *this << val.Attributes.find(AttributeId::AccessLevel)->second.As<uint8_t>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::UserAccessLevel))
    {
      *this << val.Attributes.find(AttributeId::UserAccessLevel)->second.As<uint8_t>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::MinimumSamplingInterval))
    {
      *this << val.Attributes.find(AttributeId::MinimumSamplingInterval)->second.As<double>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Historizing))
    {
      *this << val.Attributes.find(AttributeId::Historizing)->second.As<bool>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Executable))
    {
      *this << val.Attributes.find(AttributeId::Executable)->second.As<bool>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::UserExecutable))
    {
      *this << val.Attributes.find(AttributeId::UserExecutable)->second.As<bool>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::IsAbstract))
    {
      *this << val.Attributes.find(AttributeId::IsAbstract)->second.As<bool>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Symmetric))
    {
      *this << val.Attributes.find(AttributeId::Symmetric)->second.As<bool>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::InverseName))
    {
      *this << val.Attributes.find(AttributeId::InverseName)->second.As<LocalizedText>();
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::ContainsNoLoops))
    {
      *this << val.Attributes.find(AttributeId::ContainsNoLoops)->second.As<bool>();
    }

}

template<>
void DataDeserializer::Deserialize<NodeAttributes>(NodeAttributes & val)
{
  *this >> val.Header;
  int32_t size;
  *this >> size ; // not used yet
  *this >> val.SpecifiedAttributes;

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::DisplayName))
    {
      LocalizedText tmp;
      *this >> tmp;
      val.Attributes[AttributeId::DisplayName] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Description))
    {
      LocalizedText tmp;
      *this >> tmp;
      val.Attributes[AttributeId::Description] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::WriteMask))
    {
      uint32_t tmp;
      *this >> tmp;
      val.Attributes[AttributeId::WriteMask] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::UserWriteMask))
    {
      uint32_t tmp;
      *this >> tmp;
      val.Attributes[AttributeId::UserWriteMask] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::EventNotifier))
    {
      uint8_t tmp;
      *this >> tmp;
      val.Attributes[AttributeId::EventNotifier] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Value))
    {
      Variant tmp;
      *this >> tmp;
      val.Attributes[AttributeId::Value] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::DataType))
    {
      NodeId tmp;
      *this >> tmp;
      val.Attributes[AttributeId::DataType] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::ValueRank))
    {
      int32_t tmp;
      *this >> tmp;
      val.Attributes[AttributeId::ValueRank] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::ArrayDimensions))
    {
      std::vector<uint32_t> tmp;
      *this >> tmp;
      val.Attributes[AttributeId::ArrayDimensions] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::AccessLevel))
    {
      uint8_t tmp;
      *this >> tmp;
      val.Attributes[AttributeId::AccessLevel] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::UserAccessLevel))
    {
      uint8_t tmp;
      *this >> tmp;
      val.Attributes[AttributeId::UserAccessLevel] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::MinimumSamplingInterval))
    {
      Duration tmp;
      *this >> tmp;
      val.Attributes[AttributeId::MinimumSamplingInterval] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Historizing))
    {
      bool tmp;
      *this >> tmp;
      val.Attributes[AttributeId::Historizing] = tmp;
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Executable))
    {
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::UserExecutable))
    {
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::IsAbstract))
    {
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::Symmetric))
    {
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::InverseName))
    {
    }

  if (std::bitset<32>(val.SpecifiedAttributes).test(SpecifiedAttributesEncoding::ContainsNoLoops))
    {
    }

}

template<>
std::size_t RawSize<AddNodesItem>(const AddNodesItem & resp)
{
  return RawSize(resp.ParentNodeId) +
         RawSize(resp.ReferenceTypeId) +
         RawSize(resp.RequestedNewNodeId) +
         RawSize(resp.BrowseName) +
         RawSize(resp.Class) +
         RawSize(resp.Attributes) +
         RawSize(resp.TypeDefinition);
}

template<>
void DataSerializer::Serialize<AddNodesItem>(const AddNodesItem & resp)
{
  *this << resp.ParentNodeId;
  *this << resp.ReferenceTypeId;
  *this << resp.RequestedNewNodeId;
  *this << resp.BrowseName;
  *this << resp.Class;
  *this << resp.Attributes;
  *this << resp.TypeDefinition;
}

template<>
void DataDeserializer::Deserialize<AddNodesItem>(AddNodesItem & resp)
{
  *this >> resp.ParentNodeId;
  *this >> resp.ReferenceTypeId;
  *this >> resp.RequestedNewNodeId;
  *this >> resp.BrowseName;
  *this >> resp.Class;
  *this >> resp.Attributes;
  *this >> resp.TypeDefinition;
}

template<>
std::size_t RawSize(const std::vector<AddNodesItem> & ack)
{
  return RawSizeContainer(ack);
}


template<>
void DataDeserializer::Deserialize<std::vector<AddNodesItem>>(std::vector<AddNodesItem> & ack)
{
  DeserializeContainer(*this, ack);
}

template<>
void DataSerializer::Serialize<std::vector<AddNodesItem>>(const std::vector<AddNodesItem> & ack)
{
  SerializeContainer(*this, ack);
}

template<>
std::size_t RawSize<AddNodesParameters>(const AddNodesParameters & val)
{
  return RawSize(val.NodesToAdd);
}

template<>
void DataSerializer::Serialize<AddNodesParameters>(const AddNodesParameters & val)
{
  *this << val.NodesToAdd;
}

template<>
void DataDeserializer::Deserialize<AddNodesParameters>(AddNodesParameters & resp)
{
  *this >> resp.NodesToAdd;
}



template<>
std::size_t RawSize<AddNodesRequest>(const AddNodesRequest & resp)
{
  return RawSize(resp.TypeId) + RawSize(resp.Header) + RawSize(resp.Parameters);
}

template<>
void DataSerializer::Serialize<AddNodesRequest>(const AddNodesRequest & resp)
{
  *this << resp.TypeId;
  *this << resp.Header;
  *this << resp.Parameters;
}

template<>
void DataDeserializer::Deserialize<AddNodesRequest>(AddNodesRequest & resp)
{
  *this >> resp.TypeId;
  *this >> resp.Header;
  *this >> resp.Parameters;
}

template<>
std::size_t RawSize<AddNodesResult>(const AddNodesResult & resp)
{
  return RawSize(resp.Status) + RawSize(resp.AddedNodeId);
}

template<>
void DataSerializer::Serialize<AddNodesResult>(const AddNodesResult & resp)
{
  *this << resp.Status;
  *this << resp.AddedNodeId;
}

template<>
void DataDeserializer::Deserialize<AddNodesResult>(AddNodesResult & resp)
{
  *this >> resp.Status;
  *this >> resp.AddedNodeId;
}


template<>
void DataDeserializer::Deserialize<std::vector<AddNodesResult>>(std::vector<AddNodesResult> & ack)
{
  DeserializeContainer(*this, ack);
}

template<>
void DataSerializer::Serialize<std::vector<AddNodesResult>>(const std::vector<AddNodesResult> & ack)
{
  SerializeContainer(*this, ack);
}






template<>
std::size_t RawSize<AddNodesResponse>(const AddNodesResponse & resp)
{
  return RawSize(resp.TypeId) + RawSize(resp.Header) + RawSizeContainer(resp.results) + RawSize(resp.Diagnostics);
}

template<>
void DataSerializer::Serialize<AddNodesResponse>(const AddNodesResponse & resp)
{
  *this << resp.TypeId;
  *this << resp.Header;
  *this << resp.results;
  *this << resp.Diagnostics;
}

template<>
void DataDeserializer::Deserialize<AddNodesResponse>(AddNodesResponse & resp)
{
  *this >> resp.TypeId;
  *this >> resp.Header;
  *this >> resp.results;
  *this >> resp.Diagnostics;
}


//
// AddReferences
//




template<>
std::size_t RawSize<AddReferencesResponse>(const AddReferencesResponse & resp)
{
  return RawSize(resp.TypeId) + RawSize(resp.Header) + RawSizeContainer(resp.Results) + RawSize(resp.Diagnostics);
}

template<>
void DataSerializer::Serialize<AddReferencesResponse>(const AddReferencesResponse & resp)
{
  *this << resp.TypeId;
  *this << resp.Header;
  *this << resp.Results;
  *this << resp.Diagnostics;
}

template<>
void DataDeserializer::Deserialize<AddReferencesResponse>(AddReferencesResponse & resp)
{
  *this >> resp.TypeId;
  *this >> resp.Header;
  *this >> resp.Results;
  *this >> resp.Diagnostics;
}

template<>
std::size_t RawSize<AddReferencesItem>(const AddReferencesItem & val)
{
  return RawSize(val.SourceNodeId) +
         RawSize(val.ReferenceTypeId) +
         RawSize(val.IsForward) +
         RawSize(val.TargetServerUri) +
         RawSize(val.TargetNodeId) +
         RawSize(val.TargetNodeClass)
         ;
}

template<>
void DataSerializer::Serialize<AddReferencesItem>(const AddReferencesItem & val)
{
  *this << val.SourceNodeId;
  *this << val.ReferenceTypeId;
  *this << val.IsForward;
  *this << val.TargetServerUri;
  *this << val.TargetNodeId;
  *this << val.TargetNodeClass;
}

template<>
void DataDeserializer::Deserialize<AddReferencesItem>(AddReferencesItem & val)
{
  *this >> val.SourceNodeId;
  *this >> val.ReferenceTypeId;
  *this >> val.IsForward;
  *this >> val.TargetServerUri;
  *this >> val.TargetNodeId;
  *this >> val.TargetNodeClass;
}

template<>
std::size_t RawSize(const std::vector<AddReferencesItem> & ack)
{
  return RawSizeContainer(ack);
}



template<>
void DataDeserializer::Deserialize<std::vector<AddReferencesItem>>(std::vector<AddReferencesItem> & ack)
{
  DeserializeContainer(*this, ack);
}

template<>
void DataSerializer::Serialize<std::vector<AddReferencesItem>>(const std::vector<AddReferencesItem> & ack)
{
  SerializeContainer(*this, ack);
}


template<>
std::size_t RawSize<AddReferencesParameters>(const AddReferencesParameters & val)
{
  return RawSizeContainer(val.ReferencesToAdd);
}

template<>
void DataSerializer::Serialize<AddReferencesParameters>(const AddReferencesParameters & val)
{
  *this << val.ReferencesToAdd;
}

template<>
void DataDeserializer::Deserialize<AddReferencesParameters>(AddReferencesParameters & val)
{
  *this >> val.ReferencesToAdd;
}




template<>
std::size_t RawSize<AddReferencesRequest>(const AddReferencesRequest & val)
{
  return RawSize(val.TypeId) +  RawSize(val.Header) +
         RawSize(val.Parameters)
         ;
}

template<>
void DataSerializer::Serialize<AddReferencesRequest>(const AddReferencesRequest & val)
{
  *this << val.TypeId;
  *this << val.Header;
  *this << val.Parameters;
}

template<>
void DataDeserializer::Deserialize<AddReferencesRequest>(AddReferencesRequest & val)
{
  *this >> val.TypeId;
  *this >> val.Header;
  *this >> val.Parameters;
}




} // namespace Binary

const char * GetObjectIdName(const NodeId & id)
{
  if (id == ObjectId::FolderType)
    {
      return Names::FolderType;
    }

  else if (id == ObjectId::BaseVariableType)
    {
      return Names::BaseVariableType;
    }

  else if (id == ObjectId::BaseDataVariableType)
    {
      return Names::BaseDataVariableType;
    }

  else if (id == ObjectId::PropertyType)
    {
      return Names::PropertyType;
    }

  else if (id == ObjectId::BaseObjectType)
    {
      return Names::BaseObjectType;
    }

  else if (id == ObjectId::ModellingRule_Mandatory)
    {
      return Names::ModellingRule_Mandatory;
    }

  else if (id == ObjectId::ServerType)
    {
      return Names::ServerType;
    }

  return "NoNameFound";
}

}