subscriptions.cpp

Go to the documentation of this file.

#include "binary_serialization.h"

#include <opc/ua/protocol/binary/stream.h>
#include <opc/ua/protocol/monitored_items.h>

namespace OpcUa
{

   // SubscriptionData

   SubscriptionData::SubscriptionData()
     : RevisedPublishingInterval(100)
     , RevisedLifetimeCount(30) //Should be 3 times keepalive
     , RevisedMaxKeepAliveCount(10)
   {
   }

  // SubscriptionParameters

  CreateSubscriptionParameters::CreateSubscriptionParameters()
    : RequestedPublishingInterval(500)
    , RequestedLifetimeCount(3000)
    , RequestedMaxKeepAliveCount(10000)
    , MaxNotificationsPerPublish(0)
    , PublishingEnabled(true)
    , Priority(0)
  {
  }

  // PublishResult

  PublishResult::PublishResult()
    : MoreNotifications(false)
  {
  }

  // NotificationData

    NotificationData::NotificationData(DataChangeNotification notification) : DataChange(notification)
    {
      //Header.TypeId  = ObjectId::DataChangeNotification; 
      Header.TypeId  = ExpandedObjectId::DataChangeNotification;
      Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);
    }

    NotificationData::NotificationData(EventNotificationList notification) : Events(notification)
    {
      Header.TypeId  = ExpandedObjectId::EventNotificationList; 
      Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);
    }

    NotificationData::NotificationData(StatusChangeNotification notification) : StatusChange(notification)
    {
      Header.TypeId  = ExpandedObjectId::StatusChangeNotification; 
      Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);
    }


  // NotificationMessage

  NotificationMessage::NotificationMessage()
    : SequenceNumber(0)
    , PublishTime(DateTime::Current())
  {
  }


  namespace Binary
  {
    // SubscriptionAcknowledgement -- to be removed

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

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

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


    // MonitoredItems

    template<>
    std::size_t RawSize(const MonitoredItems& request)
    {
      return RawSize(request.ClientHandle) + RawSize(request.Value);
    }

    template<>
    void DataDeserializer::Deserialize<MonitoredItems>(MonitoredItems& request)
    {
      *this >> request.ClientHandle;
      *this >> request.Value;
    }

    template<>
    void DataSerializer::Serialize<MonitoredItems>(const MonitoredItems& request)
    {
      *this << request.ClientHandle;
      *this << request.Value;
    }

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

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

    // StatusChangeNotification

    template<>
    std::size_t RawSize(const StatusChangeNotification& request)
    {
      return 4 + RawSize(request.Status) + RawSize(request.Diagnostic);
    }

    template<>
    void DataDeserializer::Deserialize<StatusChangeNotification>(StatusChangeNotification& request)
    {
      uint32_t tmp;
      *this >> tmp; //it seems we do not need the size
      *this >> request.Status;
      *this >> request.Diagnostic;
    }

    template<>
    void DataSerializer::Serialize<StatusChangeNotification>(const StatusChangeNotification& request)
    {
      *this << (uint32_t) RawSize(request);
      *this << request.Status;
      *this << request.Diagnostic;
    }


    // EventNotificationList

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

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

    template<>
    std::size_t RawSize(const EventFieldList& request)
    {
      return RawSize(request.ClientHandle) + RawSizeContainer(request.EventFields); 
    }

    template<>
    void DataDeserializer::Deserialize<EventFieldList>(EventFieldList& request)
    {
      *this >> request.ClientHandle; 
      *this >> request.EventFields;
    }

    template<>
    void DataSerializer::Serialize<EventFieldList>(const EventFieldList& request)
    {
      *this << request.ClientHandle;
      *this << request.EventFields;
    }

    template<>
    std::size_t RawSize(const EventNotificationList& request)
    {
      return 4 + RawSizeContainer(request.Events); 
    }

    template<>
    void DataDeserializer::Deserialize<EventNotificationList>(EventNotificationList& request)
    {
      uint32_t tmp;
      *this >> tmp; //it seems we do not need the size
      *this >> request.Events;
    }

    template<>
    void DataSerializer::Serialize<EventNotificationList>(const EventNotificationList& request)
    {
      *this << (uint32_t) RawSize(request);
      *this << request.Events;
    }



    // DataChangeNotification

    template<>
    std::size_t RawSize(const DataChangeNotification& request)
    {
      return 4 + RawSizeContainer(request.Notification) + RawSize(request.Diagnostic);
    }

    template<>
    void DataDeserializer::Deserialize<DataChangeNotification>(DataChangeNotification& request)
    {
      uint32_t tmp;
      *this >> tmp; //it seems we do not need the size
      *this >> request.Notification;
      *this >> request.Diagnostic;
    }

    template<>
    void DataSerializer::Serialize<DataChangeNotification>(const DataChangeNotification& request)
    {
      *this << (uint32_t) RawSize(request);
      *this << request.Notification;
      *this << request.Diagnostic;
    }


    // NotificationData


    template<>
    std::size_t RawSize(const NotificationData& data)
    {
      size_t total = 0;
      total += RawSize(data.Header);
      if ( data.Header.TypeId == ExpandedObjectId::DataChangeNotification) 
      {
        total += RawSize(data.DataChange);
      }
      else if ( data.Header.TypeId == ExpandedObjectId::EventNotificationList) 
      {
        total += RawSize(data.Events);
      }
      else if ( data.Header.TypeId == ExpandedObjectId::StatusChangeNotification) 
      {
        total += RawSize(data.StatusChange);
      }
      else
      {
        //Unknown type, we just ignore it
        //throw std::runtime_error("Uknown notificationData type" );
      }
      return total;
    }

    template<>
    void DataDeserializer::Deserialize<NotificationData>(NotificationData& data)
    {
      *this >> data.Header;
      if ( data.Header.TypeId == ExpandedObjectId::DataChangeNotification ) 
      {
          *this >> data.DataChange;
      }
      else if ( data.Header.TypeId == ExpandedObjectId::EventNotificationList ) 
      {
          *this >> data.Events;
      }
      else if ( data.Header.TypeId == ExpandedObjectId::StatusChangeNotification ) 
      {
          *this >> data.StatusChange;
      }
      else
      {
        //Unknown type, we just ignore it
        //throw std::runtime_error("Uknown notification data type found in NotificationData");
      }
    }

    template<>
    void DataSerializer::Serialize<NotificationData>(const NotificationData& data)
    {
      *this << data.Header;
      if ( data.Header.TypeId == ExpandedObjectId::DataChangeNotification ) 
      {
        *this << data.DataChange;
      }
      else if ( data.Header.TypeId == ExpandedObjectId::EventNotificationList ) 
      {
        *this << data.Events;
      }
      else if ( data.Header.TypeId == ExpandedObjectId::StatusChangeNotification ) 
      {
        *this << data.StatusChange;
      }
      else
      {
        //Unknown type, we just ignore it
        //throw std::runtime_error("Uknown notification data type found in NotificationData");// + itos(data.Header.TypeId.FourByteData.Identifier) );
      }
    }

  } // namespace Binary
} // namespace OpcUa