monitored_items.cpp

Go to the documentation of this file.

#include "binary_serialization.h"

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

#include <iostream> //for debug
#include <opc/ua/protocol/string_utils.h> //for debug

namespace OpcUa
{

  MonitoringFilter::MonitoringFilter(DataChangeFilter filter) : DataChange(filter)
  {
    Header.TypeId  = ExpandedObjectId::DataChangeFilter;
    Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);
  }

  MonitoringFilter::MonitoringFilter(EventFilter filter) : Event(filter)
  {
    Header.TypeId  = ExpandedObjectId::EventFilter;
    Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);
  }

  MonitoringFilter:: MonitoringFilter(AggregateFilter filter) : Aggregate(filter)
  {
    Header.TypeId  = ExpandedObjectId::DataChangeFilter;
    Header.Encoding  = static_cast<ExtensionObjectEncoding>(Header.Encoding | ExtensionObjectEncoding::HAS_BINARY_BODY);
  }

  namespace Binary
  {

    // AttributeOperand

    template<>
    std::size_t RawSize<AttributeOperand>(const OpcUa::AttributeOperand& params)
    {
      return RawSize(params.Node) +
          RawSize(params.Alias) +
          RawSize(params.Path) +
          RawSize(params.AttributeId) +
          RawSizeContainer(params.IndexRange); 
    }

    template<>
    void DataDeserializer::Deserialize<AttributeOperand>(AttributeOperand& params)
    {
      *this >> params.Node;
      *this >> params.Alias;
      *this >> params.Path;
      *this >> params.AttributeId;
      *this >> params.IndexRange;
    }

    template<>
    void DataSerializer::Serialize<AttributeOperand>(const AttributeOperand& params)
    {
      *this << params.Node;
      *this << params.Alias;
      *this << params.Path;
      *this << params.AttributeId;
      *this << params.IndexRange;
    }

    // SimpleAttributeOperand

    template<>
    std::size_t RawSize<SimpleAttributeOperand>(const OpcUa::SimpleAttributeOperand& params)
    {
      return RawSize(params.TypeId) +
          RawSizeContainer(params.BrowsePath) +
          RawSize(params.Attribute) +
          RawSizeContainer(params.IndexRange); 
    }

    template<>
    void DataDeserializer::Deserialize<SimpleAttributeOperand>(SimpleAttributeOperand& params)
    {
      *this >> params.TypeId;
      *this >> params.BrowsePath;
      *this >> params.Attribute;
      *this >> params.IndexRange;
    }

    template<>
    void DataSerializer::Serialize<SimpleAttributeOperand>(const SimpleAttributeOperand& params)
    {
      *this << params.TypeId;
      *this << params.BrowsePath;
      *this << params.Attribute;
      *this << params.IndexRange;
    }

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

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


    // LiteralOperand

    template<>
    std::size_t RawSize<LiteralOperand>(const OpcUa::LiteralOperand& params)
    {
      return RawSize(params.Value);
    }

    template<>
    void DataDeserializer::Deserialize<LiteralOperand>(LiteralOperand& params)
    {
      *this >> params.Value;
    }

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



    // ElementOperand

    template<>
    std::size_t RawSize<ElementOperand>(const OpcUa::ElementOperand& params)
    {
      return RawSize(params.Index);
    }

    template<>
    void DataDeserializer::Deserialize<ElementOperand>(ElementOperand& params)
    {
      *this >> params.Index;
    }

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


    // FilterOperand

    template<>
    std::size_t RawSize<FilterOperand>(const OpcUa::FilterOperand& params)
    {
      size_t total = RawSize(params.Header);
      if (params.Header.TypeId == ExpandedObjectId::ElementOperand )
      {
        total += 4;
        total += RawSize(params.Element);
      }
      else if (params.Header.TypeId == ExpandedObjectId::LiteralOperand )
      {
        total += 4;
        total += RawSize(params.Literal);
      }
      else if (params.Header.TypeId == ExpandedObjectId::AttributeOperand )
      {
        total += 4;
        total += RawSize(params.Attribute);
      }
      else if (params.Header.TypeId == ExpandedObjectId::SimpleAttributeOperand )
      {
        total += 4;
        total += RawSize(params.SimpleAttribute);
      }

      return total;
    }

    template<>
    void DataDeserializer::Deserialize<FilterOperand>(FilterOperand& params)
    {
      *this >> params.Header;
      uint32_t size;
      *this >> size;
      if ( params.Header.TypeId == ExpandedObjectId::ElementOperand )
      {
        *this >> params.Element;
      }
      else if ( params.Header.TypeId == ExpandedObjectId::LiteralOperand )
      {
        *this >> params.Literal;
      }
      else if ( params.Header.TypeId == ExpandedObjectId::AttributeOperand )
      {
        *this >> params.Attribute;
      }
      else if ( params.Header.TypeId == ExpandedObjectId::SimpleAttributeOperand )
      {
        *this >> params.SimpleAttribute;
      }
    }

    template<>
    void DataSerializer::Serialize<FilterOperand>(const FilterOperand& params)
    {
      *this << params.Header;
      if ( params.Header.TypeId == ExpandedObjectId::ElementOperand )
      {
        uint32_t size = RawSize(params.Element);
        *this << size;
        *this << params.Element;
      }
      else if ( params.Header.TypeId == ExpandedObjectId::LiteralOperand )
      {
        uint32_t size = RawSize(params.Literal);
        *this << size;
        *this << params.Literal;
      }
      else if ( params.Header.TypeId == ExpandedObjectId::AttributeOperand )
      {
        uint32_t size = RawSize(params.Attribute);
        *this << size;
        *this << params.Attribute;
      }
      else if ( params.Header.TypeId == ExpandedObjectId::SimpleAttributeOperand )
      {
        uint32_t size = RawSize(params.SimpleAttribute);
        *this << size;
        *this << params.SimpleAttribute;
      }
    }
    
    template<>
    void DataSerializer::Serialize<std::vector<FilterOperand>>(const std::vector<FilterOperand>& targets)
    {
      SerializeContainer(*this, targets);
    }

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



    // ContentFilterElement

    template<>
    std::size_t RawSize<ContentFilterElement>(const OpcUa::ContentFilterElement& params)
    {
      return RawSize(params.Operator) +
          RawSizeContainer(params.FilterOperands); 
    }

    template<>
    void DataDeserializer::Deserialize<ContentFilterElement>(ContentFilterElement& params)
    {
      *this >> params.Operator;
      //*this >> params.FilterOperands;
      DeserializeContainer(*this, params.FilterOperands);
    }

    template<>
    void DataSerializer::Serialize<ContentFilterElement>(const ContentFilterElement& params)
    {
      *this << params.Operator;
      //*this << params.FilterOperands;
      SerializeContainer(*this, params.FilterOperands);
    }




    // AggregateFilter

    template<>
    std::size_t RawSize<AggregateFilter>(const OpcUa::AggregateFilter& params)
    {
      return RawSize(params.StartTime) +
          RawSize(params.AggregateType) +
          RawSize(params.ProcessingInterval) +
          RawSize(params.UseServerCapabilitiesDefaults) +
          RawSize(params.TreatUncertainAsBad) +
          RawSize(params.PercentDataBad) +
          RawSize(params.PercentDataGood) +
          RawSize(params.SteppedSlopedExtrapolation);
    }

    template<>
    void DataDeserializer::Deserialize<AggregateFilter>(AggregateFilter& params)
    {
      *this >> params.StartTime;
      *this >> params.AggregateType;
      *this >> params.ProcessingInterval;
      *this >> params.UseServerCapabilitiesDefaults;
      *this >> params.TreatUncertainAsBad;
      *this >> params.PercentDataBad;
      *this >> params.PercentDataGood;
      *this >> params.SteppedSlopedExtrapolation;
    }

    template<>
    void DataSerializer::Serialize<AggregateFilter>(const AggregateFilter& params)
    {
      *this << params.StartTime;
      *this << params.AggregateType;
      *this << params.ProcessingInterval;
      *this << params.UseServerCapabilitiesDefaults;
      *this << params.TreatUncertainAsBad;
      *this << params.PercentDataBad;
      *this << params.PercentDataGood;
      *this << params.SteppedSlopedExtrapolation;
    }



    // EventFilter

    template<>
    std::size_t RawSize<EventFilter>(const OpcUa::EventFilter& params)
    {
      return RawSizeContainer(params.SelectClauses) +
          RawSizeContainer(params.WhereClause);
    }

    template<>
    void DataDeserializer::Deserialize<EventFilter>(EventFilter& params)
    {
      *this >> params.SelectClauses;
      DeserializeContainer(*this, params.WhereClause);
    }

    template<>
    void DataSerializer::Serialize<EventFilter>(const EventFilter& params)
    {
      *this << params.SelectClauses;
      SerializeContainer(*this, params.WhereClause);
    }


    // DataChangeFilter

    template<>
    std::size_t RawSize<DataChangeFilter>(const OpcUa::DataChangeFilter& params)
    {
      return RawSize(params.Trigger) +
          RawSize(params.Deadband) +
          RawSize(params.DeadbandValue);
    }

    template<>
    void DataDeserializer::Deserialize<DataChangeFilter>(DataChangeFilter& params)
    {
      *this >> params.Trigger;
      *this >> params.Deadband;
      *this >> params.DeadbandValue;
    }

    template<>
    void DataSerializer::Serialize<DataChangeFilter>(const DataChangeFilter& params)
    {
      *this << params.Trigger;
      *this << params.Deadband;
      *this << params.DeadbandValue;
    }


    // MonitoringFilter

    template<>
    std::size_t RawSize<MonitoringFilter>(const MonitoringFilter& data)
    {
      size_t total = 0;
      total += RawSize(data.Header);
      if ( data.Header.TypeId == ExpandedObjectId::DataChangeFilter) 
      {
        total += 4;
        total += RawSize(data.DataChange);
      }
      else if ( data.Header.TypeId == ExpandedObjectId::EventFilter) 
      {
        total += 4;
        total += RawSize(data.Event);
      }
      else if ( data.Header.TypeId == ExpandedObjectId::AggregateFilter) 
      {
        total += 4;
        total += RawSize(data.Aggregate);
      }
      else if ( data.Header.TypeId == NodeId(0, 0) ) 
      {
        //No filter is used
      }
      else
      {
        throw std::runtime_error("MonitoringFilter type not implemented");
      }

      return total; 
    }
    

    template<>
    void DataDeserializer::Deserialize<MonitoringFilter>(MonitoringFilter& data)
    {
      *this >> data.Header;
      int32_t size;
      if ( data.Header.TypeId == ExpandedObjectId::DataChangeFilter ) 
      {
        *this >> size; //not used yet
        *this >> data.DataChange;
      }
      else if ( data.Header.TypeId == ExpandedObjectId::EventFilter ) 
      {
        *this >> size; //not used yet
        *this >> data.Event;
      }
      else if ( data.Header.TypeId == ExpandedObjectId::AggregateFilter ) 
      {
        *this >> size; //not used yet
        *this >> data.Aggregate;
      }
      else if ( data.Header.TypeId == NodeId(0, 0) ) 
      {
        //No filter is used
      }
      else
      {
        throw std::runtime_error("Filter data type not supported in deserialization");
      }
    }

    template<>
    void DataSerializer::Serialize<MonitoringFilter>(const MonitoringFilter& data)
    {
      *this << data.Header;
      if ( data.Header.TypeId == ExpandedObjectId::DataChangeFilter ) 
      {
        *this << (uint32_t) RawSize(data.DataChange);
        *this << data.DataChange;
      }
      else if ( data.Header.TypeId == ExpandedObjectId::EventFilter ) 
      {
        *this << (uint32_t) RawSize(data.Event);
        *this << data.Event;
      }
      else if ( data.Header.TypeId == ExpandedObjectId::AggregateFilter ) 
      {
        *this << (uint32_t) RawSize(data.Aggregate);
        *this << data.Aggregate;
      }
      else if ( data.Header.TypeId == NodeId(0, 0) ) 
      {
        //No filter is used
      }
      else
      {
        throw std::runtime_error("Filter data type not supported in serialization");
      }
    }

    // MonitoredItemCreateRequest

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

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

    // CreateMonitoredItemsRequest


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

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





  }
}