binary_view.cpp

Go to the documentation of this file.

#include "binary_serialization.h"

#include <opc/ua/protocol/view.h>
#include <opc/ua/protocol/binary/stream.h>
#include <opc/ua/protocol/types.h>
#include <opc/ua/protocol/extension_identifiers.h>

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

namespace OpcUa
{
  // NodesDescription

  NodesQuery::NodesQuery()
    : MaxReferenciesPerNode(0)
  {
  }

  // ViewDescription

  ViewDescription::ViewDescription()
    : Timestamp(0)
    , Version(0)
  {
  }

  BrowseDescription::BrowseDescription()
    : Direction(BrowseDirection::Both)
    , IncludeSubtypes(false)
    , NodeClasses(NodeClass::Unspecified)
    , ResultMask(BrowseResultMask::All)
  {
  }

  BrowseRequest::BrowseRequest()
    : TypeId(BROWSE_REQUEST)
  {
  }

  TranslateBrowsePathsToNodeIdsRequest::TranslateBrowsePathsToNodeIdsRequest()
    : TypeId(TRANSLATE_BROWSE_PATHS_TO_NODE_IdS_REQUEST)
  {
  }

  RegisterNodesRequest::RegisterNodesRequest()
          : TypeId(REGISTER_NODES_REQUEST)
  {
  }

  RegisterNodesResponse::RegisterNodesResponse()
          : TypeId(REGISTER_NODES_RESPONSE)
  {
  }

  UnregisterNodesRequest::UnregisterNodesRequest()
          : TypeId(UNREGISTER_NODES_REQUEST)
  {
  }

  UnregisterNodesResponse::UnregisterNodesResponse()
          : TypeId(UNREGISTER_NODES_RESPONSE)
  {
  }

  ReferenceDescription::ReferenceDescription()
    : IsForward(false)
    , TargetNodeClass(NodeClass::Unspecified)
  {
  }

  BrowseResult::BrowseResult()
    : Status(StatusCode::Good)
  {
  }

  BrowseResponse::BrowseResponse()
    : TypeId(BROWSE_RESPONSE)
  {
  }

  BrowseNextRequest::BrowseNextRequest()
    : TypeId(BROWSE_NEXT_REQUEST)
    , ReleaseContinuationPoints(false)
  {
  }

  BrowseNextResponse::BrowseNextResponse()
    : TypeId(BROWSE_NEXT_RESPONSE)
  {
  }

  BrowsePathTarget::BrowsePathTarget()
    : RemainingPathIndex(0)
  {
  }

  BrowsePathResult::BrowsePathResult()
    : Status(StatusCode::Good)
  {
  }

  TranslateBrowsePathsToNodeIdsResponse::TranslateBrowsePathsToNodeIdsResponse()
    : TypeId(TRANSLATE_BROWSE_PATHS_TO_NODE_IdS_RESPONSE)
  {
  }

  namespace Binary
  {

    //---------------------------------------------------
    // ViewDescription
    //---------------------------------------------------

    template<>
    std::size_t RawSize<ViewDescription>(const ViewDescription& desc)
    {
      return RawSize(desc.Id) + RawSize(desc.Timestamp) + RawSize(desc.Version);
    }

    template<>
    void DataSerializer::Serialize<ViewDescription>(const ViewDescription& desc)
    {
      *this << desc.Id;
      *this << desc.Timestamp;
      *this << desc.Version;
    }

    template<>
    void DataDeserializer::Deserialize<ViewDescription>(ViewDescription& desc)
    {
      *this >> desc.Id;
      *this >> desc.Timestamp;
      *this >> desc.Version;
    }


    //---------------------------------------------------
    // BrowseDescription
    //---------------------------------------------------

    template<>
    std::size_t RawSize<BrowseDescription>(const BrowseDescription& desc)
    {
      return RawSize(desc.NodeToBrowse) +
             RawSize(desc.Direction) +
             RawSize(desc.ReferenceTypeId) +
             RawSize(desc.IncludeSubtypes) +
             RawSize(desc.NodeClasses) +
             RawSize(desc.ResultMask);
    }

    template<>
    void DataSerializer::Serialize<BrowseDescription>(const BrowseDescription& desc)
    {
      *this << desc.NodeToBrowse;
      *this << desc.Direction;
      *this << desc.ReferenceTypeId;
      *this << desc.IncludeSubtypes;
      *this << desc.NodeClasses;
      *this << desc.ResultMask;
    }

    template<>
    void DataDeserializer::Deserialize<BrowseDescription>(BrowseDescription& desc)
    {
      *this >> desc.NodeToBrowse;
      *this >> desc.Direction;
      *this >> desc.ReferenceTypeId;
      *this >> desc.IncludeSubtypes;
      *this >> desc.NodeClasses;
      *this >> desc.ResultMask;
    }

    // NodesDescription

    template<>
    std::size_t RawSize<NodesQuery>(const NodesQuery& desc)
    {
      return RawSize(desc.View) + RawSize(desc.MaxReferenciesPerNode) + RawSizeContainer(desc.NodesToBrowse);
    }

    template<>
    void DataSerializer::Serialize<NodesQuery>(const NodesQuery& desc)
    {
      *this << desc.View;
      *this << desc.MaxReferenciesPerNode;
      SerializeContainer(*this, desc.NodesToBrowse);
    }

    template<>
    void DataDeserializer::Deserialize<NodesQuery>(NodesQuery& desc)
    {
      *this >> desc.View;
      *this >> desc.MaxReferenciesPerNode;
      DeserializeContainer(*this, desc.NodesToBrowse);
    }

    //---------------------------------------------------
    // BrowseRequest
    //---------------------------------------------------

    template<>
    std::size_t RawSize<BrowseRequest>(const BrowseRequest& request)
    {
      return RawSize(request.TypeId) + RawSize(request.Header) + RawSize(request.Query);
    }

    template<>
    void DataSerializer::Serialize<BrowseRequest>(const BrowseRequest& request)
    {
      *this << request.TypeId;
      *this << request.Header;
      *this << request.Query;
    }

    template<>
    void DataDeserializer::Deserialize<BrowseRequest>(BrowseRequest& request)
    {
      *this >> request.TypeId;
      *this >> request.Header;
      *this >> request.Query;
    }

    //---------------------------------------------------
    // ReferenceDescription
    //---------------------------------------------------

    template<>
    std::size_t RawSize<ReferenceDescription>(const ReferenceDescription& desc)
    {
      return RawSize(desc.ReferenceTypeId) +
             RawSize(desc.IsForward) +
             RawSize(desc.TargetNodeId) +
             RawSize(desc.BrowseName) +
             RawSize(desc.DisplayName) +
             RawSize(desc.TargetNodeClass) +
             RawSize(desc.TargetNodeTypeDefinition);
    }

    template<>
    void DataSerializer::Serialize<ReferenceDescription>(const ReferenceDescription& desc)
    {
      *this << desc.ReferenceTypeId;
      *this << desc.IsForward;
      *this << desc.TargetNodeId;
      *this << desc.BrowseName;
      *this << desc.DisplayName;
      *this << desc.TargetNodeClass;
      *this << desc.TargetNodeTypeDefinition;
    }

    template<>
    void DataDeserializer::Deserialize<ReferenceDescription>(ReferenceDescription& desc)
    {
      *this >> desc.ReferenceTypeId;
      *this >> desc.IsForward;
      *this >> desc.TargetNodeId;
      *this >> desc.BrowseName;
      *this >> desc.DisplayName;
      *this >> desc.TargetNodeClass;
      *this >> desc.TargetNodeTypeDefinition;
    }

    //---------------------------------------------------
    // BrowseResult
    //---------------------------------------------------

    template<>
    std::size_t RawSize<BrowseResult>(const BrowseResult& result)
    {
      return RawSize(result.Status) +
             RawSizeContainer(result.ContinuationPoint) +
             RawSizeContainer(result.Referencies);
    }

    template<>
    void DataSerializer::Serialize<BrowseResult>(const BrowseResult& result)
    {
      *this << result.Status;
      SerializeContainer(*this, result.ContinuationPoint);
      SerializeContainer(*this, result.Referencies);
    }

    template<>
    void DataDeserializer::Deserialize<BrowseResult>(BrowseResult& result)
    {
      *this >> result.Status;
      DeserializeContainer(*this, result.ContinuationPoint);
      DeserializeContainer(*this, result.Referencies);
    }

    //---------------------------------------------------
    // BrowseResponse
    //---------------------------------------------------

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

    template<>
    void DataSerializer::Serialize<BrowseResponse>(const BrowseResponse& response)
    {
      *this << response.TypeId;
      *this << response.Header;

      SerializeContainer(*this, response.Results, 0);
      SerializeContainer(*this, response.Diagnostics, 0);
    }

    template<>
    void DataDeserializer::Deserialize<BrowseResponse>(BrowseResponse& response)
    {
      *this >> response.TypeId;
      *this >> response.Header;

      DeserializeContainer(*this, response.Results);
      DeserializeContainer(*this, response.Diagnostics);
    }

    //---------------------------------------------------
    // BrowseNextRequest
    //---------------------------------------------------

    template<>
    std::size_t RawSize<BrowseNextRequest>(const BrowseNextRequest& request)
    {
      return RawSize(request.TypeId) + RawSize(request.Header) +
        RawSize(request.ReleaseContinuationPoints) +
        RawSize(request.ContinuationPoints);
    }

    template<>
    void DataSerializer::Serialize<BrowseNextRequest>(const BrowseNextRequest& request)
    {
      *this << request.TypeId;
      *this << request.Header;

      *this << request.ReleaseContinuationPoints;
      SerializeContainer(*this, request.ContinuationPoints);
    }

    template<>
    void DataDeserializer::Deserialize<BrowseNextRequest>(BrowseNextRequest& request)
    {
      *this >> request.TypeId;
      *this >> request.Header;

      *this >> request.ReleaseContinuationPoints;
      DeserializeContainer(*this, request.ContinuationPoints);
    }

    //---------------------------------------------------
    // BrowseNextResponse
    //---------------------------------------------------

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

    template<>
    void DataSerializer::Serialize<BrowseNextResponse>(const BrowseNextResponse& response)
    {
      *this << response.TypeId;
      *this << response.Header;

      SerializeContainer(*this, response.Results, 0);
      SerializeContainer(*this, response.Diagnostics, 0);
    }

    template<>
    void DataDeserializer::Deserialize<BrowseNextResponse>(BrowseNextResponse& response)
    {
      *this >> response.TypeId;
      *this >> response.Header;

      DeserializeContainer(*this, response.Results);
      DeserializeContainer(*this, response.Diagnostics);
    }

    // BrowsePathTarget

    template<>
    std::size_t RawSize<BrowsePathTarget>(const BrowsePathTarget& target)
    {
      return RawSize(target.Node) + RawSize(target.RemainingPathIndex);
    }

    template<>
    void DataSerializer::Serialize<BrowsePathTarget>(const BrowsePathTarget& target)
    {
      *this << target.Node;
      *this << target.RemainingPathIndex;
    }

    template<>
    void DataDeserializer::Deserialize<BrowsePathTarget>(BrowsePathTarget& target)
    {
      *this >> target.Node;
      *this >> target.RemainingPathIndex;
    }

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

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

    // BrowsePathResult

    template<>
    std::size_t RawSize<BrowsePathResult>(const BrowsePathResult& result)
    {
      return RawSize(result.Status) + RawSizeContainer(result.Targets);
    }

    template<>
    void DataSerializer::Serialize<BrowsePathResult>(const BrowsePathResult& result)
    {
      *this << result.Status;
      *this << result.Targets;
    }

    template<>
    void DataDeserializer::Deserialize<BrowsePathResult>(BrowsePathResult& result)
    {
      *this >> result.Status;
      *this >> result.Targets;
    }

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

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

    // TranslateBrowsePathsResult

    template<>
    std::size_t RawSize<TranslateBrowsePathsResult>(const TranslateBrowsePathsResult& result)
    {
      return RawSizeContainer(result.Paths) + RawSizeContainer(result.Diagnostics);
    }

    template<>
    void DataSerializer::Serialize<TranslateBrowsePathsResult>(const TranslateBrowsePathsResult& result)
    {
      *this << result.Paths;
      *this << result.Diagnostics;
    }

    template<>
    void DataDeserializer::Deserialize<TranslateBrowsePathsResult>(TranslateBrowsePathsResult& result)
    {
      *this >> result.Paths;
      *this >> result.Diagnostics;
    }

    // TranslateBrowsePathsToNodeIdsResponse

    template<>
    std::size_t RawSize<TranslateBrowsePathsToNodeIdsResponse>(const TranslateBrowsePathsToNodeIdsResponse& response)
    {
      return RawSize(response.TypeId) + RawSize(response.Header) + RawSize(response.Result);
    }

    template<>
    void DataSerializer::Serialize<TranslateBrowsePathsToNodeIdsResponse>(const TranslateBrowsePathsToNodeIdsResponse& response)
    {
      *this << response.TypeId;
      *this << response.Header;
      *this << response.Result;
    }

    template<>
    void DataDeserializer::Deserialize<TranslateBrowsePathsToNodeIdsResponse>(TranslateBrowsePathsToNodeIdsResponse& response)
    {
      *this >> response.TypeId;
      *this >> response.Header;
      *this >> response.Result;
    }

        // RegisterNodesRequest

        template<>
        std::size_t RawSize<RegisterNodesRequest>(const RegisterNodesRequest& request)
        {
                return RawSize(request.TypeId) + RawSize(request.Header) + RawSizeContainer(request.NodesToRegister);
        }

        template<>
        void DataSerializer::Serialize<RegisterNodesRequest>(const RegisterNodesRequest& request)
        {
                *this << request.TypeId;
                *this << request.Header;
                SerializeContainer(*this, request.NodesToRegister);
        }

        template<>
        void DataDeserializer::Deserialize<RegisterNodesRequest>(RegisterNodesRequest& request)
        {
                *this >> request.TypeId;
                *this >> request.Header;
                DeserializeContainer(*this, request.NodesToRegister);
        }

        // RegisterNodesResponse

        template<>
        std::size_t RawSize<RegisterNodesResponse>(const RegisterNodesResponse& response)
        {
                return RawSize(response.TypeId) + RawSize(response.Header) + RawSizeContainer(response.Result);
        }

        template<>
        void DataSerializer::Serialize<RegisterNodesResponse>(const RegisterNodesResponse& response)
        {
                *this << response.TypeId;
                *this << response.Header;
                SerializeContainer(*this, response.Result);
        }

        template<>
        void DataDeserializer::Deserialize<RegisterNodesResponse>(RegisterNodesResponse& response)
        {
                *this >> response.TypeId;
                *this >> response.Header;
                DeserializeContainer(*this, response.Result);
        }

        // UnregisterNodesRequest

        template<>
        std::size_t RawSize<UnregisterNodesRequest>(const UnregisterNodesRequest& request)
        {
                return RawSize(request.TypeId) + RawSize(request.Header) + RawSizeContainer(request.NodesToUnregister);
        }

        template<>
        void DataSerializer::Serialize<UnregisterNodesRequest>(const UnregisterNodesRequest& request)
        {
                *this << request.TypeId;
                *this << request.Header;
                SerializeContainer(*this, request.NodesToUnregister);
        }

        template<>
        void DataDeserializer::Deserialize<UnregisterNodesRequest>(UnregisterNodesRequest& request)
        {
                *this >> request.TypeId;
                *this >> request.Header;
                DeserializeContainer(*this, request.NodesToUnregister);
        }

        // UnregisterNodesResponse

        template<>
        std::size_t RawSize<UnregisterNodesResponse>(const UnregisterNodesResponse& response)
        {
                return RawSize(response.TypeId) + RawSize(response.Header);
        }

        template<>
        void DataSerializer::Serialize<UnregisterNodesResponse>(const UnregisterNodesResponse& response)
        {
                *this << response.TypeId;
                *this << response.Header;
        }

        template<>
        void DataDeserializer::Deserialize<UnregisterNodesResponse>(UnregisterNodesResponse& response)
        {
                *this >> response.TypeId;
                *this >> response.Header;
        }

    // RelativePathElement

    template<>
    std::size_t RawSize<RelativePathElement>(const RelativePathElement& element)
    {
      return RawSize(element.IncludeSubtypes) + RawSize(element.IsInverse) + RawSize(element.ReferenceTypeId) + RawSize(element.TargetName);
    }

    template<>
    void DataSerializer::Serialize<RelativePathElement>(const RelativePathElement& path)
    {
      *this << path.ReferenceTypeId;
      *this << path.IsInverse;
      *this << path.IncludeSubtypes;
      *this << path.TargetName;
    }

    template<>
    void DataDeserializer::Deserialize<RelativePathElement>(RelativePathElement& path)
    {
      *this >> path.ReferenceTypeId;
      *this >> path.IsInverse;
      *this >> path.IncludeSubtypes;
      *this >> path.TargetName;
    }

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

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

    // RelativePath

    template<>
    std::size_t RawSize<RelativePath>(const RelativePath& rpath)
    {
      return RawSizeContainer(rpath.Elements);
    }

    template<>
    void DataSerializer::Serialize<RelativePath>(const RelativePath& path)
    {
      *this << path.Elements;
    }

    template<>
    void DataDeserializer::Deserialize<RelativePath>(RelativePath& path)
    {
      *this >> path.Elements;
    }

    // BrowsePath

    template<>
    std::size_t RawSize<BrowsePath>(const BrowsePath& path)
    {
      return RawSize(path.StartingNode) + RawSize(path.Path);
    }

    template<>
    void DataDeserializer::Deserialize<BrowsePath>(BrowsePath& path)
    {
      *this >> path.StartingNode;
      *this >> path.Path;
    }

    template<>
    void DataSerializer::Serialize<BrowsePath>(const BrowsePath& path)
    {
      *this << path.StartingNode;
      *this << path.Path;
    }

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

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

    // TranslateBrowsePathsParameters

    template<>
    std::size_t RawSize<TranslateBrowsePathsParameters>(const TranslateBrowsePathsParameters& params)
    {
      return RawSizeContainer(params.BrowsePaths);
    }

    template<>
    void DataSerializer::Serialize<TranslateBrowsePathsParameters>(const TranslateBrowsePathsParameters& params)
    {
      *this << params.BrowsePaths;
    }

    template<>
    void DataDeserializer::Deserialize<TranslateBrowsePathsParameters>(TranslateBrowsePathsParameters& path)
    {
      *this >> path.BrowsePaths;
    }

    // TranslateBrowsePathsToNodeIdsRequest

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

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

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

  } // namespace Binary
} // namespace OpcUa