Ejemplo n.º 1
0
        /// <summary>
        ///  Decode field message data delta frame from decoder and using a DataSetReader
        /// </summary>
        /// <param name="binaryDecoder"></param>
        /// <param name="dataSetReader"></param>
        /// <returns></returns>
        private DataSet DecodeMessageDataDeltaFrame(BinaryDecoder binaryDecoder, DataSetReaderDataType dataSetReader)
        {
            DataSetMetaDataType dataSetMetaData = dataSetReader.DataSetMetaData;

            try
            {
                FieldTypeEncodingMask fieldType = (FieldTypeEncodingMask)(((byte)DataSetFlags1 & kFieldTypeUsedBits) >> 1);

                if (dataSetMetaData != null)
                {
                    TargetVariablesDataType targetVariablesData =
                        ExtensionObject.ToEncodeable(dataSetReader.SubscribedDataSet) as TargetVariablesDataType;

                    // create dataFields collection
                    List <Field> dataFields = new List <Field>();
                    for (int i = 0; i < dataSetMetaData.Fields.Count; i++)
                    {
                        Field dataField = new Field();
                        dataField.FieldMetaData = dataSetMetaData?.Fields[i];

                        if (targetVariablesData != null && targetVariablesData.TargetVariables != null &&
                            i < targetVariablesData.TargetVariables.Count)
                        {
                            // remember the target Attribute and target nodeId
                            dataField.TargetAttribute = targetVariablesData.TargetVariables[i].AttributeId;
                            dataField.TargetNodeId    = targetVariablesData.TargetVariables[i].TargetNodeId;
                        }
                        dataFields.Add(dataField);
                    }

                    // read number of fields encoded in this delta frame message
                    ushort fieldCount = fieldCount = binaryDecoder.ReadUInt16("FieldCount");

                    for (int i = 0; i < fieldCount; i++)
                    {
                        ushort fieldIndex = binaryDecoder.ReadUInt16("FieldIndex");
                        // update value in dataFields

                        switch (fieldType)
                        {
                        case FieldTypeEncodingMask.Variant:
                            dataFields[fieldIndex].Value = new DataValue(binaryDecoder.ReadVariant("FieldValue"));
                            break;

                        case FieldTypeEncodingMask.DataValue:
                            dataFields[fieldIndex].Value = binaryDecoder.ReadDataValue("FieldValue");
                            break;

                        case FieldTypeEncodingMask.RawData:
                            FieldMetaData fieldMetaData = dataSetMetaData.Fields[fieldIndex];
                            if (fieldMetaData != null)
                            {
                                var decodedValue = DecodeRawData(binaryDecoder, fieldMetaData);
                                dataFields[fieldIndex].Value = new DataValue(new Variant(decodedValue));
                            }
                            break;

                        case FieldTypeEncodingMask.Reserved:
                            // ignore
                            break;
                        }
                    }

                    DataSet dataSet = new DataSet(dataSetMetaData?.Name);
                    dataSet.DataSetMetaData = dataSetMetaData;
                    dataSet.Fields          = dataFields.ToArray();
                    dataSet.IsDeltaFrame    = true;
                    dataSet.DataSetWriterId = DataSetWriterId;
                    dataSet.SequenceNumber  = SequenceNumber;
                    return(dataSet);
                }
            }
            catch (Exception ex)
            {
                Utils.Trace(ex, "UadpDataSetMessage.DecodeMessageDataDeltaFrame");
            }
            return(null);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Decode a scalar type
        /// </summary>
        /// <param name="binaryDecoder"></param>
        /// <param name="builtInType"></param>
        /// <returns>The decoded object</returns>
        private object DecodeRawScalar(BinaryDecoder binaryDecoder, byte builtInType)
        {
            switch ((BuiltInType)builtInType)
            {
            case BuiltInType.Boolean:
                return(binaryDecoder.ReadBoolean(null));

            case BuiltInType.SByte:
                return(binaryDecoder.ReadSByte(null));

            case BuiltInType.Byte:
                return(binaryDecoder.ReadByte(null));

            case BuiltInType.Int16:
                return(binaryDecoder.ReadInt16(null));

            case BuiltInType.UInt16:
                return(binaryDecoder.ReadUInt16(null));

            case BuiltInType.Int32:
                return(binaryDecoder.ReadInt32(null));

            case BuiltInType.UInt32:
                return(binaryDecoder.ReadUInt32(null));

            case BuiltInType.Int64:
                return(binaryDecoder.ReadInt64(null));

            case BuiltInType.UInt64:
                return(binaryDecoder.ReadUInt64(null));

            case BuiltInType.Float:
                return(binaryDecoder.ReadFloat(null));

            case BuiltInType.Double:
                return(binaryDecoder.ReadDouble(null));

            case BuiltInType.String:
                return(binaryDecoder.ReadString(null));

            case BuiltInType.DateTime:
                return(binaryDecoder.ReadDateTime(null));

            case BuiltInType.Guid:
                return(binaryDecoder.ReadGuid(null));

            case BuiltInType.ByteString:
                return(binaryDecoder.ReadByteString(null));

            case BuiltInType.XmlElement:
                return(binaryDecoder.ReadXmlElement(null));

            case BuiltInType.NodeId:
                return(binaryDecoder.ReadNodeId(null));

            case BuiltInType.ExpandedNodeId:
                return(binaryDecoder.ReadExpandedNodeId(null));

            case BuiltInType.StatusCode:
                return(binaryDecoder.ReadStatusCode(null));

            case BuiltInType.QualifiedName:
                return(binaryDecoder.ReadQualifiedName(null));

            case BuiltInType.LocalizedText:
                return(binaryDecoder.ReadLocalizedText(null));

            case BuiltInType.DataValue:
                return(binaryDecoder.ReadDataValue(null));

            case BuiltInType.Enumeration:
                return(binaryDecoder.ReadInt32(null));

            case BuiltInType.Variant:
                return(binaryDecoder.ReadVariant(null));

            case BuiltInType.ExtensionObject:
                return(binaryDecoder.ReadExtensionObject(null));

            default:
                return(null);
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        ///  Decode field message data key frame from decoder and using a DataSetReader
        /// </summary>
        /// <param name="binaryDecoder"></param>
        /// <param name="dataSetReader"></param>
        /// <returns></returns>
        private DataSet DecodeMessageDataKeyFrame(BinaryDecoder binaryDecoder, DataSetReaderDataType dataSetReader)
        {
            DataSetMetaDataType dataSetMetaData = dataSetReader.DataSetMetaData;

            try
            {
                ushort fieldCount = 0;
                FieldTypeEncodingMask fieldType = (FieldTypeEncodingMask)(((byte)DataSetFlags1 & kFieldTypeUsedBits) >> 1);
                if (fieldType == FieldTypeEncodingMask.RawData)
                {
                    if (dataSetMetaData != null)
                    {
                        // metadata should provide field count
                        fieldCount = (ushort)dataSetMetaData.Fields.Count;
                    }
                }
                else
                {
                    fieldCount = binaryDecoder.ReadUInt16("DataSetFieldCount");
                }

                TargetVariablesDataType targetVariablesData =
                    ExtensionObject.ToEncodeable(dataSetReader.SubscribedDataSet) as TargetVariablesDataType;

                // check configuration version
                List <DataValue> dataValues = new List <DataValue>();
                switch (fieldType)
                {
                case FieldTypeEncodingMask.Variant:
                    for (int i = 0; i < fieldCount; i++)
                    {
                        dataValues.Add(new DataValue(binaryDecoder.ReadVariant("Variant")));
                    }
                    break;

                case FieldTypeEncodingMask.DataValue:
                    for (int i = 0; i < fieldCount; i++)
                    {
                        dataValues.Add(binaryDecoder.ReadDataValue("DataValue"));
                    }
                    break;

                case FieldTypeEncodingMask.RawData:
                    if (dataSetMetaData != null)
                    {
                        for (int i = 0; i < fieldCount; i++)
                        {
                            FieldMetaData fieldMetaData = dataSetMetaData.Fields[i];
                            if (fieldMetaData != null)
                            {
                                var decodedValue = DecodeRawData(binaryDecoder, fieldMetaData);
                                dataValues.Add(new DataValue(new Variant(decodedValue)));
                            }
                        }
                    }
                    // else the decoding is compromised for RawData type
                    break;

                case FieldTypeEncodingMask.Reserved:
                    // ignore
                    break;
                }

                List <Field> dataFields = new List <Field>();

                for (int i = 0; i < dataValues.Count; i++)
                {
                    Field dataField = new Field();
                    dataField.FieldMetaData = dataSetMetaData?.Fields[i];
                    dataField.Value         = dataValues[i];

                    if (targetVariablesData != null && targetVariablesData.TargetVariables != null &&
                        i < targetVariablesData.TargetVariables.Count)
                    {
                        // remember the target Attribute and target nodeId
                        dataField.TargetAttribute = targetVariablesData.TargetVariables[i].AttributeId;
                        dataField.TargetNodeId    = targetVariablesData.TargetVariables[i].TargetNodeId;
                    }
                    dataFields.Add(dataField);
                }

                if (dataFields.Count == 0)
                {
                    return(null); //the dataset cannot be decoded
                }

                DataSet dataSet = new DataSet(dataSetMetaData?.Name);
                dataSet.DataSetMetaData = dataSetMetaData;
                dataSet.Fields          = dataFields.ToArray();
                dataSet.DataSetWriterId = DataSetWriterId;
                dataSet.SequenceNumber  = SequenceNumber;
                return(dataSet);
            }
            catch (Exception ex)
            {
                Utils.Trace(ex, "UadpDataSetMessage.DecodeMessageDataKeyFrame");
                return(null);
            }
        }