serialize_auto.cpp
Go to the documentation of this file.
1 // DO NOT EDIT THIS FILE!
2 // It is automatically generated from opcfoundation.org schemas.
3 //
4 
14 
15 #include "binary_serialization.h"
16 #include <opc/ua/protocol/protocol.h>
17 
18 #include <opc/ua/protocol/binary/stream.h>
19 
20 namespace OpcUa
21 {
22 namespace Binary
23 {
24 
25 template<>
26 void DataSerializer::Serialize<OpenFileMode>(const OpenFileMode & data)
27 {
28  *this << static_cast<uint32_t>(data);
29 }
30 
31 
32 template<>
33 void DataSerializer::Serialize<NodeClass>(const NodeClass & data)
34 {
35  *this << static_cast<uint32_t>(data);
36 }
37 
38 
39 template<>
40 void DataSerializer::Serialize<ApplicationType>(const ApplicationType & data)
41 {
42  *this << static_cast<uint32_t>(data);
43 }
44 
45 
46 template<>
47 void DataSerializer::Serialize<MessageSecurityMode>(const MessageSecurityMode & data)
48 {
49  *this << static_cast<uint32_t>(data);
50 }
51 
52 
53 template<>
54 void DataSerializer::Serialize<UserTokenType>(const UserTokenType & data)
55 {
56  *this << static_cast<uint32_t>(data);
57 }
58 
59 
60 template<>
61 void DataSerializer::Serialize<SecurityTokenRequestType>(const SecurityTokenRequestType & data)
62 {
63  *this << static_cast<uint32_t>(data);
64 }
65 
66 
67 template<>
68 void DataSerializer::Serialize<NodeAttributesMask>(const NodeAttributesMask & data)
69 {
70  *this << static_cast<uint32_t>(data);
71 }
72 
73 
74 template<>
75 void DataSerializer::Serialize<AttributeWriteMask>(const AttributeWriteMask & data)
76 {
77  *this << static_cast<uint32_t>(data);
78 }
79 
80 
81 template<>
82 void DataSerializer::Serialize<BrowseDirection>(const BrowseDirection & data)
83 {
84  *this << static_cast<uint32_t>(data);
85 }
86 
87 
88 template<>
89 void DataSerializer::Serialize<BrowseResultMask>(const BrowseResultMask & data)
90 {
91  *this << static_cast<uint32_t>(data);
92 }
93 
94 
95 template<>
96 void DataSerializer::Serialize<ComplianceLevel>(const ComplianceLevel & data)
97 {
98  *this << static_cast<uint32_t>(data);
99 }
100 
101 
102 template<>
103 void DataSerializer::Serialize<FilterOperator>(const FilterOperator & data)
104 {
105  *this << static_cast<uint32_t>(data);
106 }
107 
108 
109 template<>
110 void DataSerializer::Serialize<TimestampsToReturn>(const TimestampsToReturn & data)
111 {
112  *this << static_cast<uint32_t>(data);
113 }
114 
115 
116 template<>
117 void DataSerializer::Serialize<HistoryUpdateType>(const HistoryUpdateType & data)
118 {
119  *this << static_cast<uint32_t>(data);
120 }
121 
122 
123 template<>
124 void DataSerializer::Serialize<PerformUpdateType>(const PerformUpdateType & data)
125 {
126  *this << static_cast<uint32_t>(data);
127 }
128 
129 
130 template<>
131 void DataSerializer::Serialize<MonitoringMode>(const MonitoringMode & data)
132 {
133  *this << static_cast<uint32_t>(data);
134 }
135 
136 
137 template<>
138 void DataSerializer::Serialize<DataChangeTrigger>(const DataChangeTrigger & data)
139 {
140  *this << static_cast<uint32_t>(data);
141 }
142 
143 
144 template<>
145 void DataSerializer::Serialize<DeadbandType>(const DeadbandType & data)
146 {
147  *this << static_cast<uint32_t>(data);
148 }
149 
150 
151 template<>
152 void DataSerializer::Serialize<EnumeratedTestType>(const EnumeratedTestType & data)
153 {
154  *this << static_cast<uint32_t>(data);
155 }
156 
157 
158 template<>
159 void DataSerializer::Serialize<RedundancySupport>(const RedundancySupport & data)
160 {
161  *this << static_cast<uint32_t>(data);
162 }
163 
164 
165 template<>
166 void DataSerializer::Serialize<ServerState>(const ServerState & data)
167 {
168  *this << static_cast<uint32_t>(data);
169 }
170 
171 
172 template<>
173 void DataSerializer::Serialize<ModelChangeStructureVerbMask>(const ModelChangeStructureVerbMask & data)
174 {
175  *this << static_cast<uint32_t>(data);
176 }
177 
178 
179 template<>
180 void DataSerializer::Serialize<AxisScaleEnumeration>(const AxisScaleEnumeration & data)
181 {
182  *this << static_cast<uint32_t>(data);
183 }
184 
185 
186 template<>
187 void DataSerializer::Serialize<ExceptionDeviationFormat>(const ExceptionDeviationFormat & data)
188 {
189  *this << static_cast<uint32_t>(data);
190 }
191 
192 
193 template<>
194 void DataSerializer::Serialize<XmlElement>(const XmlElement & data)
195 {
196  *this << data.Length;
197  SerializeContainer(*this, data.Value);
198 }
199 
200 
201 /* DISABLED
202 
203  template<>
204  void DataSerializer::Serialize<TwoByteNodeId>(const TwoByteNodeId& data)
205  {
206  *this << data.Identifier;
207  }
208 
209 */
210 
211 /* DISABLED
212 
213  template<>
214  void DataSerializer::Serialize<FourByteNodeId>(const FourByteNodeId& data)
215  {
216  *this << data.NamespaceIndex;
217  *this << data.Identifier;
218  }
219 
220 */
221 
222 /* DISABLED
223 
224  template<>
225  void DataSerializer::Serialize<NumericNodeId>(const NumericNodeId& data)
226  {
227  *this << data.NamespaceIndex;
228  *this << data.Identifier;
229  }
230 
231 */
232 
233 /* DISABLED
234 
235  template<>
236  void DataSerializer::Serialize<StringNodeId>(const StringNodeId& data)
237  {
238  *this << data.NamespaceIndex;
239  *this << data.Identifier;
240  }
241 
242 */
243 
244 /* DISABLED
245 
246  template<>
247  void DataSerializer::Serialize<GuidNodeId>(const GuidNodeId& data)
248  {
249  *this << data.NamespaceIndex;
250  *this << data.Identifier;
251  }
252 
253 */
254 
255 /* DISABLED
256 
257  template<>
258  void DataSerializer::Serialize<ByteStringNodeId>(const ByteStringNodeId& data)
259  {
260  *this << data.NamespaceIndex;
261  *this << data.Identifier;
262  }
263 
264 */
265 
266 /* DISABLED
267 
268  template<>
269  void DataSerializer::Serialize<NodeId>(const NodeId& data)
270  {
271  *this << data.NodeIdType;
272  if ((data.NodeIdType) & (1<<(0))) *this << data.TwoByte;
273  if ((data.NodeIdType) & (1<<(1))) *this << data.FourByte;
274  if ((data.NodeIdType) & (1<<(2))) *this << data.Numeric;
275  if ((data.NodeIdType) & (1<<(3))) *this << data.String;
276  if ((data.NodeIdType) & (1<<(4))) *this << data.Guid;
277  if ((data.NodeIdType) & (1<<(5))) *this << data.ByteString;
278  }
279 
280 */
281 
282 template<>
283 void DataSerializer::Serialize<ExtensionObject>(const ExtensionObject & data)
284 {
285  *this << data.TypeId;
286  *this << data.Encoding;
287 
288  if ((data.Encoding) & (1 << (0))) { *this << data.Body; }
289 }
290 
291 
292 /* DISABLED
293 
294  template<>
295  void DataSerializer::Serialize<ExpandedNodeId>(const ExpandedNodeId& data)
296  {
297  *this << data.NodeIdType;
298  if ((data.NodeIdType) & (1<<(0))) *this << data.TwoByte;
299  if ((data.NodeIdType) & (1<<(1))) *this << data.FourByte;
300  if ((data.NodeIdType) & (1<<(2))) *this << data.Numeric;
301  if ((data.NodeIdType) & (1<<(3))) *this << data.String;
302  if ((data.NodeIdType) & (1<<(4))) *this << data.Guid;
303  if ((data.NodeIdType) & (1<<(5))) *this << data.ByteString;
304  if ((data.NodeIdType) & (1<<(7))) *this << data.NamespaceURI;
305  if ((data.NodeIdType) & (1<<(6))) *this << data.ServerIndex;
306  }
307 
308 */
309 
310 /* DISABLED
311 
312  template<>
313  void DataSerializer::Serialize<DiagnosticInfo>(const DiagnosticInfo& data)
314  {
315  *this << data.Encoding;
316  if ((data.Encoding) & (1<<(0))) *this << data.SymbolicId;
317  if ((data.Encoding) & (1<<(1))) *this << data.NamespaceURI;
318  if ((data.Encoding) & (1<<(2))) *this << data.LocalizedText;
319  if ((data.Encoding) & (1<<(4))) *this << data.AdditionalInfo;
320  if ((data.Encoding) & (1<<(5))) *this << data.InnerStatusCode;
321  if ((data.Encoding) & (1<<(6))) *this << data.InnerDiagnosticInfo;
322  }
323 
324 */
325 
326 /* DISABLED
327 
328  template<>
329  void DataSerializer::Serialize<QualifiedName>(const QualifiedName& data)
330  {
331  *this << data.NamespaceIndex;
332  *this << data.Name;
333  }
334 
335 */
336 
337 /* DISABLED
338 
339  template<>
340  void DataSerializer::Serialize<LocalizedText>(const LocalizedText& data)
341  {
342  *this << data.Encoding;
343  if ((data.Encoding) & (1<<(0))) *this << data.Locale;
344  if ((data.Encoding) & (1<<(1))) *this << data.Text;
345  }
346 
347 */
348 
349 /* DISABLED
350 
351  template<>
352  void DataSerializer::Serialize<Variant>(const Variant& data)
353  {
354  *this << data.Encoding;
355  if ((data.Encoding) & (1<<(7))) *this << data.ArrayLength;
356  if ((data.VariantType) & (1<<(1))) SerializeContainer(*this, data.Boolean);
357  if ((data.VariantType) & (1<<(2))) SerializeContainer(*this, data.SByte);
358  if ((data.VariantType) & (1<<(3))) SerializeContainer(*this, data.Byte);
359  if ((data.VariantType) & (1<<(4))) SerializeContainer(*this, data.Int16);
360  if ((data.VariantType) & (1<<(5))) SerializeContainer(*this, data.UInt16);
361  if ((data.VariantType) & (1<<(6))) SerializeContainer(*this, data.Int32);
362  if ((data.VariantType) & (1<<(7))) SerializeContainer(*this, data.UInt32);
363  if ((data.VariantType) & (1<<(8))) SerializeContainer(*this, data.Int64);
364  if ((data.VariantType) & (1<<(9))) SerializeContainer(*this, data.UInt64);
365  if ((data.VariantType) & (1<<(10))) SerializeContainer(*this, data.Float);
366  if ((data.VariantType) & (1<<(11))) SerializeContainer(*this, data.Double);
367  if ((data.VariantType) & (1<<(12))) SerializeContainer(*this, data.String);
368  if ((data.VariantType) & (1<<(13))) SerializeContainer(*this, data.DateTime);
369  if ((data.VariantType) & (1<<(14))) SerializeContainer(*this, data.Guid);
370  if ((data.VariantType) & (1<<(15))) SerializeContainer(*this, data.ByteString);
371  if ((data.VariantType) & (1<<(16))) SerializeContainer(*this, data.XmlElement);
372  if ((data.VariantType) & (1<<(17))) SerializeContainer(*this, data.NodeId);
373  if ((data.VariantType) & (1<<(18))) SerializeContainer(*this, data.ExpandedNodeId);
374  if ((data.VariantType) & (1<<(19))) SerializeContainer(*this, data.Status);
375  if ((data.VariantType) & (1<<(20))) SerializeContainer(*this, data.DiagnosticInfo);
376  if ((data.VariantType) & (1<<(21))) SerializeContainer(*this, data.QualifiedName);
377  if ((data.VariantType) & (1<<(22))) SerializeContainer(*this, data.LocalizedText);
378  if ((data.VariantType) & (1<<(23))) SerializeContainer(*this, data.ExtensionObject);
379  if ((data.VariantType) & (1<<(24))) SerializeContainer(*this, data.DataValue);
380  if ((data.VariantType) & (1<<(25))) SerializeContainer(*this, data.Variant);
381  }
382 
383 */
384 
385 /* DISABLED
386 
387  template<>
388  void DataSerializer::Serialize<DataValue>(const DataValue& data)
389  {
390  *this << data.Encoding;
391  if ((data.Encoding) & (1<<(0))) *this << data.Value;
392  if ((data.Encoding) & (1<<(1))) *this << data.Status;
393  if ((data.Encoding) & (1<<(2))) *this << data.SourceTimestamp;
394  if ((data.Encoding) & (1<<(3))) *this << data.SourcePicoseconds;
395  if ((data.Encoding) & (1<<(4))) *this << data.ServerTimestamp;
396  if ((data.Encoding) & (1<<(5))) *this << data.ServerPicoseconds;
397  }
398 
399 */
400 
401 /* DISABLED
402 
403  template<>
404  void DataSerializer::Serialize<ReferenceNode>(const ReferenceNode& data)
405  {
406  *this << data.ReferenceTypeId;
407  *this << data.IsInverse;
408  *this << data.TargetId;
409  }
410 
411 */
412 
413 /* DISABLED
414 
415  template<>
416  void DataSerializer::Serialize<Node>(const Node& data)
417  {
418  *this << data.NodeId;
419  *this << data.NodeClass;
420  *this << data.BrowseName;
421  *this << data.DisplayName;
422  *this << data.Description;
423  *this << data.WriteMask;
424  *this << data.UserWriteMask;
425  SerializeContainer(*this, data.References);
426  }
427 
428 */
429 
430 /* DISABLED
431 
432  template<>
433  void DataSerializer::Serialize<InstanceNode>(const InstanceNode& data)
434  {
435  *this << data.NodeId;
436  *this << data.NodeClass;
437  *this << data.BrowseName;
438  *this << data.DisplayName;
439  *this << data.Description;
440  *this << data.WriteMask;
441  *this << data.UserWriteMask;
442  SerializeContainer(*this, data.References);
443  }
444 
445 */
446 
447 /* DISABLED
448 
449  template<>
450  void DataSerializer::Serialize<TypeNode>(const TypeNode& data)
451  {
452  *this << data.NodeId;
453  *this << data.NodeClass;
454  *this << data.BrowseName;
455  *this << data.DisplayName;
456  *this << data.Description;
457  *this << data.WriteMask;
458  *this << data.UserWriteMask;
459  SerializeContainer(*this, data.References);
460  }
461 
462 */
463 
464 /* DISABLED
465 
466  template<>
467  void DataSerializer::Serialize<ObjectNode>(const ObjectNode& data)
468  {
469  *this << data.NodeId;
470  *this << data.NodeClass;
471  *this << data.BrowseName;
472  *this << data.DisplayName;
473  *this << data.Description;
474  *this << data.WriteMask;
475  *this << data.UserWriteMask;
476  SerializeContainer(*this, data.References);
477  *this << data.EventNotifier;
478  }
479 
480 */
481 
482 /* DISABLED
483 
484  template<>
485  void DataSerializer::Serialize<ObjectTypeNode>(const ObjectTypeNode& data)
486  {
487  *this << data.NodeId;
488  *this << data.NodeClass;
489  *this << data.BrowseName;
490  *this << data.DisplayName;
491  *this << data.Description;
492  *this << data.WriteMask;
493  *this << data.UserWriteMask;
494  SerializeContainer(*this, data.References);
495  *this << data.IsAbstract;
496  }
497 
498 */
499 
500 /* DISABLED
501 
502  template<>
503  void DataSerializer::Serialize<VariableNode>(const VariableNode& data)
504  {
505  *this << data.NodeId;
506  *this << data.NodeClass;
507  *this << data.BrowseName;
508  *this << data.DisplayName;
509  *this << data.Description;
510  *this << data.WriteMask;
511  *this << data.UserWriteMask;
512  SerializeContainer(*this, data.References);
513  *this << data.Value;
514  *this << data.DataType;
515  *this << data.ValueRank;
516  SerializeContainer(*this, data.ArrayDimensions);
517  *this << data.AccessLevel;
518  *this << data.UserAccessLevel;
519  *this << data.MinimumSamplingInterval;
520  *this << data.Historizing;
521  }
522 
523 */
524 
525 /* DISABLED
526 
527  template<>
528  void DataSerializer::Serialize<VariableTypeNode>(const VariableTypeNode& data)
529  {
530  *this << data.NodeId;
531  *this << data.NodeClass;
532  *this << data.BrowseName;
533  *this << data.DisplayName;
534  *this << data.Description;
535  *this << data.WriteMask;
536  *this << data.UserWriteMask;
537  SerializeContainer(*this, data.References);
538  *this << data.Value;
539  *this << data.DataType;
540  *this << data.ValueRank;
541  SerializeContainer(*this, data.ArrayDimensions);
542  *this << data.IsAbstract;
543  }
544 
545 */
546 
547 /* DISABLED
548 
549  template<>
550  void DataSerializer::Serialize<ReferenceTypeNode>(const ReferenceTypeNode& data)
551  {
552  *this << data.NodeId;
553  *this << data.NodeClass;
554  *this << data.BrowseName;
555  *this << data.DisplayName;
556  *this << data.Description;
557  *this << data.WriteMask;
558  *this << data.UserWriteMask;
559  SerializeContainer(*this, data.References);
560  *this << data.IsAbstract;
561  *this << data.Symmetric;
562  *this << data.InverseName;
563  }
564 
565 */
566 
567 /* DISABLED
568 
569  template<>
570  void DataSerializer::Serialize<MethodNode>(const MethodNode& data)
571  {
572  *this << data.NodeId;
573  *this << data.NodeClass;
574  *this << data.BrowseName;
575  *this << data.DisplayName;
576  *this << data.Description;
577  *this << data.WriteMask;
578  *this << data.UserWriteMask;
579  SerializeContainer(*this, data.References);
580  *this << data.Executable;
581  *this << data.UserExecutable;
582  }
583 
584 */
585 
586 /* DISABLED
587 
588  template<>
589  void DataSerializer::Serialize<ViewNode>(const ViewNode& data)
590  {
591  *this << data.NodeId;
592  *this << data.NodeClass;
593  *this << data.BrowseName;
594  *this << data.DisplayName;
595  *this << data.Description;
596  *this << data.WriteMask;
597  *this << data.UserWriteMask;
598  SerializeContainer(*this, data.References);
599  *this << data.ContainsNoLoops;
600  *this << data.EventNotifier;
601  }
602 
603 */
604 
605 /* DISABLED
606 
607  template<>
608  void DataSerializer::Serialize<DataTypeNode>(const DataTypeNode& data)
609  {
610  *this << data.NodeId;
611  *this << data.NodeClass;
612  *this << data.BrowseName;
613  *this << data.DisplayName;
614  *this << data.Description;
615  *this << data.WriteMask;
616  *this << data.UserWriteMask;
617  SerializeContainer(*this, data.References);
618  *this << data.IsAbstract;
619  }
620 
621 */
622 
623 /* DISABLED
624 
625  template<>
626  void DataSerializer::Serialize<Argument>(const Argument& data)
627  {
628  *this << data.Name;
629  *this << data.DataType;
630  *this << data.ValueRank;
631  SerializeContainer(*this, data.ArrayDimensions);
632  *this << data.Description;
633  }
634 
635 */
636 
637 /* DISABLED
638 
639  template<>
640  void DataSerializer::Serialize<EnumValueType>(const EnumValueType& data)
641  {
642  *this << data.Value;
643  *this << data.DisplayName;
644  *this << data.Description;
645  }
646 
647 */
648 
649 /* DISABLED
650 
651  template<>
652  void DataSerializer::Serialize<TimeZoneDataType>(const TimeZoneDataType& data)
653  {
654  *this << data.Offset;
655  *this << data.DaylightSavingInOffset;
656  }
657 
658 */
659 
660 template<>
661 void DataSerializer::Serialize<ApplicationDescription>(const ApplicationDescription & data)
662 {
663  *this << data.ApplicationUri;
664  *this << data.ProductUri;
665  *this << data.ApplicationName;
666  *this << data.ApplicationType;
667  *this << data.GatewayServerUri;
668  *this << data.DiscoveryProfileUri;
669  SerializeContainer(*this, data.DiscoveryUrls);
670 }
671 
672 
673 /* DISABLED
674 
675  template<>
676  void DataSerializer::Serialize<RequestHeader>(const RequestHeader& data)
677  {
678  *this << data.AuthenticationToken;
679  *this << data.Timestamp;
680  *this << data.RequestHandle;
681  *this << data.ReturnDiagnostics;
682  *this << data.AuditEntryId;
683  *this << data.TimeoutHint;
684  *this << data.AdditionalHeader;
685  }
686 
687 */
688 
689 /* DISABLED
690 
691  template<>
692  void DataSerializer::Serialize<ResponseHeader>(const ResponseHeader& data)
693  {
694  *this << data.Timestamp;
695  *this << data.RequestHandle;
696  *this << data.ServiceResult;
697  *this << data.ServiceDiagnostics;
698  SerializeContainer(*this, data.StringTable);
699  *this << data.AdditionalHeader;
700  }
701 
702 */
703 
704 /* DISABLED
705 
706  template<>
707  void DataSerializer::Serialize<ServiceFault>(const ServiceFault& data)
708  {
709  *this << data.TypeId;
710  *this << data.Header;
711  }
712 
713 */
714 
715 /* DISABLED
716 
717  template<>
718  void DataSerializer::Serialize<FindServersParameters>(const FindServersParameters& data)
719  {
720  *this << data.EndpointUrl;
721  SerializeContainer(*this, data.LocaleIds);
722  SerializeContainer(*this, data.ServerUris);
723  }
724 
725 */
726 
727 /* DISABLED
728 
729  template<>
730  void DataSerializer::Serialize<FindServersRequest>(const FindServersRequest& data)
731  {
732  *this << data.TypeId;
733  *this << data.Header;
734  *this << data.Parameters;
735  }
736 
737 */
738 
739 /* DISABLED
740 
741  template<>
742  void DataSerializer::Serialize<FindServersResult>(const FindServersResult& data)
743  {
744  SerializeContainer(*this, data.Servers);
745  }
746 
747 */
748 
749 /* DISABLED
750 
751  template<>
752  void DataSerializer::Serialize<FindServersResponse>(const FindServersResponse& data)
753  {
754  *this << data.TypeId;
755  *this << data.Header;
756  *this << data.Parameters;
757  }
758 
759 */
760 
761 template<>
762 void DataSerializer::Serialize<UserTokenPolicy>(const UserTokenPolicy & data)
763 {
764  *this << data.PolicyId;
765  *this << data.TokenType;
766  *this << data.IssuedTokenType;
767  *this << data.IssuerEndpointUrl;
768  *this << data.SecurityPolicyUri;
769 }
770 
771 
772 template<>
773 void DataSerializer::Serialize<EndpointDescription>(const EndpointDescription & data)
774 {
775  *this << data.EndpointUrl;
776  *this << data.Server;
777  *this << data.ServerCertificate;
778  *this << data.SecurityMode;
779  *this << data.SecurityPolicyUri;
780  SerializeContainer(*this, data.UserIdentityTokens);
781  *this << data.TransportProfileUri;
782  *this << data.SecurityLevel;
783 }
784 
785 
786 template<>
787 void DataSerializer::Serialize<GetEndpointsParameters>(const GetEndpointsParameters & data)
788 {
789  *this << data.EndpointUrl;
790  SerializeContainer(*this, data.LocaleIds);
791  SerializeContainer(*this, data.ProfileUris);
792 }
793 
794 
795 template<>
796 void DataSerializer::Serialize<GetEndpointsRequest>(const GetEndpointsRequest & data)
797 {
798  *this << data.TypeId;
799  *this << data.Header;
800  *this << data.Parameters;
801 }
802 
803 
804 template<>
805 void DataSerializer::Serialize<GetEndpointsResponse>(const GetEndpointsResponse & data)
806 {
807  *this << data.TypeId;
808  *this << data.Header;
809  SerializeContainer(*this, data.Endpoints);
810 }
811 
812 
813 /* DISABLED
814 
815  template<>
816  void DataSerializer::Serialize<RegisteredServer>(const RegisteredServer& data)
817  {
818  *this << data.ServerUri;
819  *this << data.ProductUri;
820  SerializeContainer(*this, data.ServerNames);
821  *this << data.ServerType;
822  *this << data.GatewayServerUri;
823  SerializeContainer(*this, data.DiscoveryUrls);
824  *this << data.SemaphoreFilePath;
825  *this << data.IsOnline;
826  }
827 
828 */
829 
830 /* DISABLED
831 
832  template<>
833  void DataSerializer::Serialize<RegisterServerParameters>(const RegisterServerParameters& data)
834  {
835  *this << data.Server;
836  }
837 
838 */
839 
840 /* DISABLED
841 
842  template<>
843  void DataSerializer::Serialize<RegisterServerRequest>(const RegisterServerRequest& data)
844  {
845  *this << data.TypeId;
846  *this << data.Header;
847  *this << data.Parameters;
848  }
849 
850 */
851 
852 /* DISABLED
853 
854  template<>
855  void DataSerializer::Serialize<RegisterServerResponse>(const RegisterServerResponse& data)
856  {
857  *this << data.TypeId;
858  *this << data.Header;
859  }
860 
861 */
862 
863 /* DISABLED
864 
865  template<>
866  void DataSerializer::Serialize<ChannelSecurityToken>(const ChannelSecurityToken& data)
867  {
868  *this << data.ChannelId;
869  *this << data.TokenId;
870  *this << data.CreatedAt;
871  *this << data.RevisedLifetime;
872  }
873 
874 */
875 
876 /* DISABLED
877 
878  template<>
879  void DataSerializer::Serialize<OpenSecureChannelParameters>(const OpenSecureChannelParameters& data)
880  {
881  *this << data.ClientProtocolVersion;
882  *this << data.RequestType;
883  *this << data.SecurityMode;
884  *this << data.ClientNonce;
885  *this << data.RequestedLifetime;
886  }
887 
888 */
889 
890 /* DISABLED
891 
892  template<>
893  void DataSerializer::Serialize<OpenSecureChannelRequest>(const OpenSecureChannelRequest& data)
894  {
895  *this << data.TypeId;
896  *this << data.Header;
897  *this << data.Parameters;
898  }
899 
900 */
901 
902 /* DISABLED
903 
904  template<>
905  void DataSerializer::Serialize<OpenSecureChannelResult>(const OpenSecureChannelResult& data)
906  {
907  *this << data.ServerProtocolVersion;
908  *this << data.SecurityToken;
909  *this << data.ServerNonce;
910  }
911 
912 */
913 
914 /* DISABLED
915 
916  template<>
917  void DataSerializer::Serialize<OpenSecureChannelResponse>(const OpenSecureChannelResponse& data)
918  {
919  *this << data.TypeId;
920  *this << data.Header;
921  *this << data.Parameters;
922  }
923 
924 */
925 
926 /* DISABLED
927 
928  template<>
929  void DataSerializer::Serialize<CloseSecureChannelRequest>(const CloseSecureChannelRequest& data)
930  {
931  *this << data.TypeId;
932  *this << data.Header;
933  }
934 
935 */
936 
937 /* DISABLED
938 
939  template<>
940  void DataSerializer::Serialize<CloseSecureChannelResponse>(const CloseSecureChannelResponse& data)
941  {
942  *this << data.TypeId;
943  *this << data.Header;
944  }
945 
946 */
947 
948 template<>
949 void DataSerializer::Serialize<SignedSoftwareCertificate>(const SignedSoftwareCertificate & data)
950 {
951  *this << data.CertificateData;
952  *this << data.Signature;
953 }
954 
955 
956 template<>
957 void DataSerializer::Serialize<SignatureData>(const SignatureData & data)
958 {
959  *this << data.Algorithm;
960  *this << data.Signature;
961 }
962 
963 
964 template<>
965 void DataSerializer::Serialize<CreateSessionParameters>(const CreateSessionParameters & data)
966 {
967  *this << data.ClientDescription;
968  *this << data.ServerUri;
969  *this << data.EndpointUrl;
970  *this << data.SessionName;
971  *this << data.ClientNonce;
972  *this << data.ClientCertificate;
973  *this << data.RequestedSessionTimeout;
974  *this << data.MaxResponseMessageSize;
975 }
976 
977 
978 template<>
979 void DataSerializer::Serialize<CreateSessionRequest>(const CreateSessionRequest & data)
980 {
981  *this << data.TypeId;
982  *this << data.Header;
983  *this << data.Parameters;
984 }
985 
986 
987 template<>
988 void DataSerializer::Serialize<CreateSessionResult>(const CreateSessionResult & data)
989 {
990  *this << data.SessionId;
991  *this << data.AuthenticationToken;
992  *this << data.RevisedSessionTimeout;
993  *this << data.ServerNonce;
994  *this << data.ServerCertificate;
995  SerializeContainer(*this, data.ServerEndpoints);
996  SerializeContainer(*this, data.ServerSoftwareCertificates);
997  *this << data.ServerSignature;
998  *this << data.MaxRequestMessageSize;
999 }
1000 
1001 
1002 template<>
1003 void DataSerializer::Serialize<CreateSessionResponse>(const CreateSessionResponse & data)
1004 {
1005  *this << data.TypeId;
1006  *this << data.Header;
1007  *this << data.Parameters;
1008 }
1009 
1010 
1011 /* DISABLED
1012 
1013  template<>
1014  void DataSerializer::Serialize<UserIdentityToken>(const UserIdentityToken& data)
1015  {
1016  *this << data.TypeId;
1017  *this << data.Encoding;
1018  *this << data.BodyLength;
1019  *this << data.PolicyId;
1020  }
1021 
1022 */
1023 
1024 /* DISABLED
1025 
1026  template<>
1027  void DataSerializer::Serialize<AnonymousIdentityToken>(const AnonymousIdentityToken& data)
1028  {
1029  *this << data.TypeId;
1030  *this << data.Encoding;
1031  *this << data.BodyLength;
1032  *this << data.PolicyId;
1033  }
1034 
1035 */
1036 
1037 /* DISABLED
1038 
1039  template<>
1040  void DataSerializer::Serialize<UserNameIdentityToken>(const UserNameIdentityToken& data)
1041  {
1042  *this << data.TypeId;
1043  *this << data.Encoding;
1044  *this << data.BodyLength;
1045  *this << data.PolicyId;
1046  *this << data.UserName;
1047  *this << data.Password;
1048  *this << data.EncryptionAlgorithm;
1049  }
1050 
1051 */
1052 
1053 /* DISABLED
1054 
1055  template<>
1056  void DataSerializer::Serialize<X509IdentityToken>(const X509IdentityToken& data)
1057  {
1058  *this << data.TypeId;
1059  *this << data.Encoding;
1060  *this << data.BodyLength;
1061  *this << data.PolicyId;
1062  *this << data.CertificateData;
1063  }
1064 
1065 */
1066 
1067 /* DISABLED
1068 
1069  template<>
1070  void DataSerializer::Serialize<IssuedIdentityToken>(const IssuedIdentityToken& data)
1071  {
1072  *this << data.TypeId;
1073  *this << data.Encoding;
1074  *this << data.BodyLength;
1075  *this << data.PolicyId;
1076  *this << data.TokenData;
1077  *this << data.EncryptionAlgorithm;
1078  }
1079 
1080 */
1081 
1082 template<>
1083 void DataSerializer::Serialize<ActivateSessionParameters>(const ActivateSessionParameters & data)
1084 {
1085  *this << data.ClientSignature;
1086  SerializeContainer(*this, data.ClientSoftwareCertificates);
1087  SerializeContainer(*this, data.LocaleIds);
1088  *this << data.UserIdentityToken;
1089  *this << data.UserTokenSignature;
1090 }
1091 
1092 
1093 template<>
1094 void DataSerializer::Serialize<ActivateSessionRequest>(const ActivateSessionRequest & data)
1095 {
1096  *this << data.TypeId;
1097  *this << data.Header;
1098  *this << data.Parameters;
1099 }
1100 
1101 
1102 template<>
1103 void DataSerializer::Serialize<ActivateSessionResult>(const ActivateSessionResult & data)
1104 {
1105  *this << data.ServerNonce;
1106  SerializeContainer(*this, data.Results);
1107  SerializeContainer(*this, data.DiagnosticInfos);
1108 }
1109 
1110 
1111 template<>
1112 void DataSerializer::Serialize<ActivateSessionResponse>(const ActivateSessionResponse & data)
1113 {
1114  *this << data.TypeId;
1115  *this << data.Header;
1116  *this << data.Parameters;
1117 }
1118 
1119 
1120 /* DISABLED
1121 
1122  template<>
1123  void DataSerializer::Serialize<CloseSessionRequest>(const CloseSessionRequest& data)
1124  {
1125  *this << data.TypeId;
1126  *this << data.Header;
1127  *this << data.DeleteSubscriptions;
1128  }
1129 
1130 */
1131 
1132 /* DISABLED
1133 
1134  template<>
1135  void DataSerializer::Serialize<CloseSessionResponse>(const CloseSessionResponse& data)
1136  {
1137  *this << data.TypeId;
1138  *this << data.Header;
1139  }
1140 
1141 */
1142 
1143 /* DISABLED
1144 
1145  template<>
1146  void DataSerializer::Serialize<CancelParameters>(const CancelParameters& data)
1147  {
1148  *this << data.RequestHandle;
1149  }
1150 
1151 */
1152 
1153 /* DISABLED
1154 
1155  template<>
1156  void DataSerializer::Serialize<CancelRequest>(const CancelRequest& data)
1157  {
1158  *this << data.TypeId;
1159  *this << data.Header;
1160  *this << data.Parameters;
1161  }
1162 
1163 */
1164 
1165 /* DISABLED
1166 
1167  template<>
1168  void DataSerializer::Serialize<CancelResult>(const CancelResult& data)
1169  {
1170  *this << data.CancelCount;
1171  }
1172 
1173 */
1174 
1175 /* DISABLED
1176 
1177  template<>
1178  void DataSerializer::Serialize<CancelResponse>(const CancelResponse& data)
1179  {
1180  *this << data.TypeId;
1181  *this << data.Header;
1182  *this << data.Parameters;
1183  }
1184 
1185 */
1186 
1187 /* DISABLED
1188 
1189  template<>
1190  void DataSerializer::Serialize<NodeAttributes>(const NodeAttributes& data)
1191  {
1192  *this << data.TypeId;
1193  *this << data.Encoding;
1194  *this << data.BodyLength;
1195  *this << data.SpecifiedAttributes;
1196  *this << data.DisplayName;
1197  *this << data.Description;
1198  *this << data.WriteMask;
1199  *this << data.UserWriteMask;
1200  }
1201 
1202 */
1203 
1204 /* DISABLED
1205 
1206  template<>
1207  void DataSerializer::Serialize<ObjectAttributes>(const ObjectAttributes& data)
1208  {
1209  *this << data.TypeId;
1210  *this << data.Encoding;
1211  *this << data.BodyLength;
1212  *this << data.SpecifiedAttributes;
1213  *this << data.DisplayName;
1214  *this << data.Description;
1215  *this << data.WriteMask;
1216  *this << data.UserWriteMask;
1217  *this << data.EventNotifier;
1218  }
1219 
1220 */
1221 
1222 /* DISABLED
1223 
1224  template<>
1225  void DataSerializer::Serialize<VariableAttributes>(const VariableAttributes& data)
1226  {
1227  *this << data.TypeId;
1228  *this << data.Encoding;
1229  *this << data.BodyLength;
1230  *this << data.SpecifiedAttributes;
1231  *this << data.DisplayName;
1232  *this << data.Description;
1233  *this << data.WriteMask;
1234  *this << data.UserWriteMask;
1235  *this << data.Value;
1236  *this << data.DataType;
1237  *this << data.ValueRank;
1238  SerializeContainer(*this, data.ArrayDimensions);
1239  *this << data.AccessLevel;
1240  *this << data.UserAccessLevel;
1241  *this << data.MinimumSamplingInterval;
1242  *this << data.Historizing;
1243  }
1244 
1245 */
1246 
1247 /* DISABLED
1248 
1249  template<>
1250  void DataSerializer::Serialize<MethodAttributes>(const MethodAttributes& data)
1251  {
1252  *this << data.TypeId;
1253  *this << data.Encoding;
1254  *this << data.BodyLength;
1255  *this << data.SpecifiedAttributes;
1256  *this << data.DisplayName;
1257  *this << data.Description;
1258  *this << data.WriteMask;
1259  *this << data.UserWriteMask;
1260  *this << data.Executable;
1261  *this << data.UserExecutable;
1262  }
1263 
1264 */
1265 
1266 /* DISABLED
1267 
1268  template<>
1269  void DataSerializer::Serialize<ObjectTypeAttributes>(const ObjectTypeAttributes& data)
1270  {
1271  *this << data.TypeId;
1272  *this << data.Encoding;
1273  *this << data.BodyLength;
1274  *this << data.SpecifiedAttributes;
1275  *this << data.DisplayName;
1276  *this << data.Description;
1277  *this << data.WriteMask;
1278  *this << data.UserWriteMask;
1279  *this << data.IsAbstract;
1280  }
1281 
1282 */
1283 
1284 /* DISABLED
1285 
1286  template<>
1287  void DataSerializer::Serialize<VariableTypeAttributes>(const VariableTypeAttributes& data)
1288  {
1289  *this << data.TypeId;
1290  *this << data.Encoding;
1291  *this << data.BodyLength;
1292  *this << data.SpecifiedAttributes;
1293  *this << data.DisplayName;
1294  *this << data.Description;
1295  *this << data.WriteMask;
1296  *this << data.UserWriteMask;
1297  *this << data.Value;
1298  *this << data.DataType;
1299  *this << data.ValueRank;
1300  SerializeContainer(*this, data.ArrayDimensions);
1301  *this << data.IsAbstract;
1302  }
1303 
1304 */
1305 
1306 /* DISABLED
1307 
1308  template<>
1309  void DataSerializer::Serialize<ReferenceTypeAttributes>(const ReferenceTypeAttributes& data)
1310  {
1311  *this << data.TypeId;
1312  *this << data.Encoding;
1313  *this << data.BodyLength;
1314  *this << data.SpecifiedAttributes;
1315  *this << data.DisplayName;
1316  *this << data.Description;
1317  *this << data.WriteMask;
1318  *this << data.UserWriteMask;
1319  *this << data.IsAbstract;
1320  *this << data.Symmetric;
1321  *this << data.InverseName;
1322  }
1323 
1324 */
1325 
1326 /* DISABLED
1327 
1328  template<>
1329  void DataSerializer::Serialize<DataTypeAttributes>(const DataTypeAttributes& data)
1330  {
1331  *this << data.TypeId;
1332  *this << data.Encoding;
1333  *this << data.BodyLength;
1334  *this << data.SpecifiedAttributes;
1335  *this << data.DisplayName;
1336  *this << data.Description;
1337  *this << data.WriteMask;
1338  *this << data.UserWriteMask;
1339  *this << data.IsAbstract;
1340  }
1341 
1342 */
1343 
1344 /* DISABLED
1345 
1346  template<>
1347  void DataSerializer::Serialize<ViewAttributes>(const ViewAttributes& data)
1348  {
1349  *this << data.TypeId;
1350  *this << data.Encoding;
1351  *this << data.BodyLength;
1352  *this << data.SpecifiedAttributes;
1353  *this << data.DisplayName;
1354  *this << data.Description;
1355  *this << data.WriteMask;
1356  *this << data.UserWriteMask;
1357  *this << data.ContainsNoLoops;
1358  *this << data.EventNotifier;
1359  }
1360 
1361 */
1362 
1363 /* DISABLED
1364 
1365  template<>
1366  void DataSerializer::Serialize<AddNodesItem>(const AddNodesItem& data)
1367  {
1368  *this << data.ParentNodeId;
1369  *this << data.ReferenceTypeId;
1370  *this << data.RequestedNewNodeId;
1371  *this << data.BrowseName;
1372  *this << data.NodeClass;
1373  *this << data.NodeAttributes;
1374  *this << data.TypeDefinition;
1375  }
1376 
1377 */
1378 
1379 /* DISABLED
1380 
1381  template<>
1382  void DataSerializer::Serialize<AddNodesResult>(const AddNodesResult& data)
1383  {
1384  *this << data.Status;
1385  *this << data.AddedNodeId;
1386  }
1387 
1388 */
1389 
1390 /* DISABLED
1391 
1392  template<>
1393  void DataSerializer::Serialize<AddNodesParameters>(const AddNodesParameters& data)
1394  {
1395  SerializeContainer(*this, data.NodesToAdd);
1396  }
1397 
1398 */
1399 
1400 /* DISABLED
1401 
1402  template<>
1403  void DataSerializer::Serialize<AddNodesRequest>(const AddNodesRequest& data)
1404  {
1405  *this << data.TypeId;
1406  *this << data.Header;
1407  *this << data.Parameters;
1408  }
1409 
1410 */
1411 
1412 /* DISABLED
1413 
1414  template<>
1415  void DataSerializer::Serialize<AddNodesResponse>(const AddNodesResponse& data)
1416  {
1417  *this << data.TypeId;
1418  *this << data.Header;
1419  SerializeContainer(*this, data.Results);
1420  SerializeContainer(*this, data.DiagnosticInfos);
1421  }
1422 
1423 */
1424 
1425 /* DISABLED
1426 
1427  template<>
1428  void DataSerializer::Serialize<AddReferencesItem>(const AddReferencesItem& data)
1429  {
1430  *this << data.SourceNodeId;
1431  *this << data.ReferenceTypeId;
1432  *this << data.IsForward;
1433  *this << data.TargetServerUri;
1434  *this << data.TargetNodeId;
1435  *this << data.TargetNodeClass;
1436  }
1437 
1438 */
1439 
1440 /* DISABLED
1441 
1442  template<>
1443  void DataSerializer::Serialize<AddReferencesRequest>(const AddReferencesRequest& data)
1444  {
1445  *this << data.TypeId;
1446  *this << data.Header;
1447  SerializeContainer(*this, data.ReferencesToAdd);
1448  }
1449 
1450 */
1451 
1452 /* DISABLED
1453 
1454  template<>
1455  void DataSerializer::Serialize<AddReferencesResponse>(const AddReferencesResponse& data)
1456  {
1457  *this << data.TypeId;
1458  *this << data.Header;
1459  SerializeContainer(*this, data.Results);
1460  SerializeContainer(*this, data.DiagnosticInfos);
1461  }
1462 
1463 */
1464 
1465 template<>
1466 void DataSerializer::Serialize<DeleteNodesItem>(const DeleteNodesItem & data)
1467 {
1468  *this << data.NodeId;
1469  *this << data.DeleteTargetReferences;
1470 }
1471 
1472 
1473 template<>
1474 void DataSerializer::Serialize<DeleteNodesRequest>(const DeleteNodesRequest & data)
1475 {
1476  *this << data.TypeId;
1477  *this << data.Header;
1478  SerializeContainer(*this, data.NodesToDelete);
1479 }
1480 
1481 
1482 template<>
1483 void DataSerializer::Serialize<DeleteNodesResponse>(const DeleteNodesResponse & data)
1484 {
1485  *this << data.TypeId;
1486  *this << data.Header;
1487  SerializeContainer(*this, data.Results);
1488  SerializeContainer(*this, data.DiagnosticInfos);
1489 }
1490 
1491 
1492 /* DISABLED
1493 
1494  template<>
1495  void DataSerializer::Serialize<DeleteReferencesItem>(const DeleteReferencesItem& data)
1496  {
1497  *this << data.SourceNodeId;
1498  *this << data.ReferenceTypeId;
1499  *this << data.IsForward;
1500  *this << data.TargetNodeId;
1501  *this << data.DeleteBidirectional;
1502  }
1503 
1504 */
1505 
1506 /* DISABLED
1507 
1508  template<>
1509  void DataSerializer::Serialize<DeleteReferencesParameters>(const DeleteReferencesParameters& data)
1510  {
1511  SerializeContainer(*this, data.ReferencesToDelete);
1512  }
1513 
1514 */
1515 
1516 /* DISABLED
1517 
1518  template<>
1519  void DataSerializer::Serialize<DeleteReferencesRequest>(const DeleteReferencesRequest& data)
1520  {
1521  *this << data.TypeId;
1522  *this << data.Header;
1523  *this << data.Parameters;
1524  }
1525 
1526 */
1527 
1528 /* DISABLED
1529 
1530  template<>
1531  void DataSerializer::Serialize<DeleteReferencesResult>(const DeleteReferencesResult& data)
1532  {
1533  SerializeContainer(*this, data.Results);
1534  SerializeContainer(*this, data.DiagnosticInfos);
1535  }
1536 
1537 */
1538 
1539 /* DISABLED
1540 
1541  template<>
1542  void DataSerializer::Serialize<DeleteReferencesResponse>(const DeleteReferencesResponse& data)
1543  {
1544  *this << data.TypeId;
1545  *this << data.Header;
1546  *this << data.Parameters;
1547  }
1548 
1549 */
1550 
1551 /* DISABLED
1552 
1553  template<>
1554  void DataSerializer::Serialize<ViewDescription>(const ViewDescription& data)
1555  {
1556  *this << data.ViewId;
1557  *this << data.Timestamp;
1558  *this << data.ViewVersion;
1559  }
1560 
1561 */
1562 
1563 /* DISABLED
1564 
1565  template<>
1566  void DataSerializer::Serialize<BrowseDescription>(const BrowseDescription& data)
1567  {
1568  *this << data.NodeId;
1569  *this << data.BrowseDirection;
1570  *this << data.ReferenceTypeId;
1571  *this << data.IncludeSubtypes;
1572  *this << data.NodeClassMask;
1573  *this << data.ResultMask;
1574  }
1575 
1576 */
1577 
1578 /* DISABLED
1579 
1580  template<>
1581  void DataSerializer::Serialize<ReferenceDescription>(const ReferenceDescription& data)
1582  {
1583  *this << data.ReferenceTypeId;
1584  *this << data.IsForward;
1585  *this << data.NodeId;
1586  *this << data.BrowseName;
1587  *this << data.DisplayName;
1588  *this << data.NodeClass;
1589  *this << data.TypeDefinition;
1590  }
1591 
1592 */
1593 
1594 /* DISABLED
1595 
1596  template<>
1597  void DataSerializer::Serialize<BrowseResult>(const BrowseResult& data)
1598  {
1599  *this << data.Status;
1600  *this << data.ContinuationPoint;
1601  SerializeContainer(*this, data.References);
1602  }
1603 
1604 */
1605 
1606 /* DISABLED
1607 
1608  template<>
1609  void DataSerializer::Serialize<BrowseParameters>(const BrowseParameters& data)
1610  {
1611  *this << data.View;
1612  *this << data.RequestedMaxReferencesPerNode;
1613  SerializeContainer(*this, data.NodesToBrowse);
1614  }
1615 
1616 */
1617 
1618 /* DISABLED
1619 
1620  template<>
1621  void DataSerializer::Serialize<BrowseRequest>(const BrowseRequest& data)
1622  {
1623  *this << data.TypeId;
1624  *this << data.Header;
1625  *this << data.Parameters;
1626  }
1627 
1628 */
1629 
1630 /* DISABLED
1631 
1632  template<>
1633  void DataSerializer::Serialize<BrowseResponse>(const BrowseResponse& data)
1634  {
1635  *this << data.TypeId;
1636  *this << data.Header;
1637  SerializeContainer(*this, data.Results);
1638  SerializeContainer(*this, data.DiagnosticInfos);
1639  }
1640 
1641 */
1642 
1643 /* DISABLED
1644 
1645  template<>
1646  void DataSerializer::Serialize<BrowseNextParameters>(const BrowseNextParameters& data)
1647  {
1648  *this << data.ReleaseContinuationPoints;
1649  SerializeContainer(*this, data.ContinuationPoints);
1650  }
1651 
1652 */
1653 
1654 /* DISABLED
1655 
1656  template<>
1657  void DataSerializer::Serialize<BrowseNextRequest>(const BrowseNextRequest& data)
1658  {
1659  *this << data.TypeId;
1660  *this << data.Header;
1661  *this << data.Parameters;
1662  }
1663 
1664 */
1665 
1666 /* DISABLED
1667 
1668  template<>
1669  void DataSerializer::Serialize<BrowseNextResult>(const BrowseNextResult& data)
1670  {
1671  SerializeContainer(*this, data.Results);
1672  SerializeContainer(*this, data.DiagnosticInfos);
1673  }
1674 
1675 */
1676 
1677 /* DISABLED
1678 
1679  template<>
1680  void DataSerializer::Serialize<BrowseNextResponse>(const BrowseNextResponse& data)
1681  {
1682  *this << data.TypeId;
1683  *this << data.Header;
1684  *this << data.Parameters;
1685  }
1686 
1687 */
1688 
1689 /* DISABLED
1690 
1691  template<>
1692  void DataSerializer::Serialize<RelativePathElement>(const RelativePathElement& data)
1693  {
1694  *this << data.ReferenceTypeId;
1695  *this << data.IsInverse;
1696  *this << data.IncludeSubtypes;
1697  *this << data.TargetName;
1698  }
1699 
1700 */
1701 
1702 /* DISABLED
1703 
1704  template<>
1705  void DataSerializer::Serialize<RelativePath>(const RelativePath& data)
1706  {
1707  SerializeContainer(*this, data.Elements);
1708  }
1709 
1710 */
1711 
1712 /* DISABLED
1713 
1714  template<>
1715  void DataSerializer::Serialize<BrowsePath>(const BrowsePath& data)
1716  {
1717  *this << data.StartingNode;
1718  *this << data.RelativePath;
1719  }
1720 
1721 */
1722 
1723 /* DISABLED
1724 
1725  template<>
1726  void DataSerializer::Serialize<BrowsePathTarget>(const BrowsePathTarget& data)
1727  {
1728  *this << data.TargetId;
1729  *this << data.RemainingPathIndex;
1730  }
1731 
1732 */
1733 
1734 /* DISABLED
1735 
1736  template<>
1737  void DataSerializer::Serialize<BrowsePathResult>(const BrowsePathResult& data)
1738  {
1739  *this << data.Status;
1740  SerializeContainer(*this, data.Targets);
1741  }
1742 
1743 */
1744 
1745 /* DISABLED
1746 
1747  template<>
1748  void DataSerializer::Serialize<TranslateBrowsePathsToNodeIdsParameters>(const TranslateBrowsePathsToNodeIdsParameters& data)
1749  {
1750  SerializeContainer(*this, data.BrowsePaths);
1751  }
1752 
1753 */
1754 
1755 /* DISABLED
1756 
1757  template<>
1758  void DataSerializer::Serialize<TranslateBrowsePathsToNodeIdsRequest>(const TranslateBrowsePathsToNodeIdsRequest& data)
1759  {
1760  *this << data.TypeId;
1761  *this << data.Header;
1762  *this << data.Parameters;
1763  }
1764 
1765 */
1766 
1767 /* DISABLED
1768 
1769  template<>
1770  void DataSerializer::Serialize<TranslateBrowsePathsToNodeIdsResponse>(const TranslateBrowsePathsToNodeIdsResponse& data)
1771  {
1772  *this << data.TypeId;
1773  *this << data.Header;
1774  SerializeContainer(*this, data.Results);
1775  SerializeContainer(*this, data.DiagnosticInfos);
1776  }
1777 
1778 */
1779 
1780 /* DISABLED
1781 
1782  template<>
1783  void DataSerializer::Serialize<RegisterNodesParameters>(const RegisterNodesParameters& data)
1784  {
1785  SerializeContainer(*this, data.NodesToRegister);
1786  }
1787 
1788 */
1789 
1790 /* DISABLED
1791 
1792  template<>
1793  void DataSerializer::Serialize<RegisterNodesRequest>(const RegisterNodesRequest& data)
1794  {
1795  *this << data.TypeId;
1796  *this << data.Header;
1797  *this << data.Parameters;
1798  }
1799 
1800 */
1801 
1802 /* DISABLED
1803 
1804  template<>
1805  void DataSerializer::Serialize<RegisterNodesResult>(const RegisterNodesResult& data)
1806  {
1807  SerializeContainer(*this, data.RegisteredNodeIds);
1808  }
1809 
1810 */
1811 
1812 /* DISABLED
1813 
1814  template<>
1815  void DataSerializer::Serialize<RegisterNodesResponse>(const RegisterNodesResponse& data)
1816  {
1817  *this << data.TypeId;
1818  *this << data.Header;
1819  *this << data.Parameters;
1820  }
1821 
1822 */
1823 
1824 /* DISABLED
1825 
1826  template<>
1827  void DataSerializer::Serialize<UnregisterNodesParameters>(const UnregisterNodesParameters& data)
1828  {
1829  SerializeContainer(*this, data.NodesToUnregister);
1830  }
1831 
1832 */
1833 
1834 /* DISABLED
1835 
1836  template<>
1837  void DataSerializer::Serialize<UnregisterNodesRequest>(const UnregisterNodesRequest& data)
1838  {
1839  *this << data.TypeId;
1840  *this << data.Header;
1841  *this << data.Parameters;
1842  }
1843 
1844 */
1845 
1846 /* DISABLED
1847 
1848  template<>
1849  void DataSerializer::Serialize<UnregisterNodesResponse>(const UnregisterNodesResponse& data)
1850  {
1851  *this << data.TypeId;
1852  *this << data.Header;
1853  }
1854 
1855 */
1856 
1857 /* DISABLED
1858 
1859  template<>
1860  void DataSerializer::Serialize<EndpointConfiguration>(const EndpointConfiguration& data)
1861  {
1862  *this << data.OperationTimeout;
1863  *this << data.UseBinaryEncoding;
1864  *this << data.MaxStringLength;
1865  *this << data.MaxByteStringLength;
1866  *this << data.MaxArrayLength;
1867  *this << data.MaxMessageSize;
1868  *this << data.MaxBufferSize;
1869  *this << data.ChannelLifetime;
1870  *this << data.SecurityTokenLifetime;
1871  }
1872 
1873 */
1874 
1875 /* DISABLED
1876 
1877  template<>
1878  void DataSerializer::Serialize<SupportedProfile>(const SupportedProfile& data)
1879  {
1880  *this << data.OrganizationUri;
1881  *this << data.ProfileId;
1882  *this << data.ComplianceTool;
1883  *this << data.ComplianceDate;
1884  *this << data.ComplianceLevel;
1885  SerializeContainer(*this, data.UnsupportedUnitIds);
1886  }
1887 
1888 */
1889 
1890 /* DISABLED
1891 
1892  template<>
1893  void DataSerializer::Serialize<SoftwareCertificate>(const SoftwareCertificate& data)
1894  {
1895  *this << data.ProductName;
1896  *this << data.ProductUri;
1897  *this << data.VendorName;
1898  *this << data.VendorProductCertificate;
1899  *this << data.SoftwareVersion;
1900  *this << data.BuildNumber;
1901  *this << data.BuildDate;
1902  *this << data.IssuedBy;
1903  *this << data.IssueDate;
1904  SerializeContainer(*this, data.SupportedProfiles);
1905  }
1906 
1907 */
1908 
1909 /* DISABLED
1910 
1911  template<>
1912  void DataSerializer::Serialize<QueryDataDescription>(const QueryDataDescription& data)
1913  {
1914  *this << data.RelativePath;
1915  *this << data.AttributeId;
1916  *this << data.IndexRange;
1917  }
1918 
1919 */
1920 
1921 /* DISABLED
1922 
1923  template<>
1924  void DataSerializer::Serialize<NodeTypeDescription>(const NodeTypeDescription& data)
1925  {
1926  *this << data.TypeDefinitionNode;
1927  *this << data.IncludeSubTypes;
1928  SerializeContainer(*this, data.DataToReturn);
1929  }
1930 
1931 */
1932 
1933 /* DISABLED
1934 
1935  template<>
1936  void DataSerializer::Serialize<QueryDataSet>(const QueryDataSet& data)
1937  {
1938  *this << data.NodeId;
1939  *this << data.TypeDefinitionNode;
1940  SerializeContainer(*this, data.Values);
1941  }
1942 
1943 */
1944 
1945 /* DISABLED
1946 
1947  template<>
1948  void DataSerializer::Serialize<NodeReference>(const NodeReference& data)
1949  {
1950  *this << data.NodeId;
1951  *this << data.ReferenceTypeId;
1952  *this << data.IsForward;
1953  SerializeContainer(*this, data.ReferencedNodeIds);
1954  }
1955 
1956 */
1957 
1958 /* DISABLED
1959 
1960  template<>
1961  void DataSerializer::Serialize<ContentFilterElement>(const ContentFilterElement& data)
1962  {
1963  *this << data.FilterOperator;
1964  SerializeContainer(*this, data.FilterOperands);
1965  }
1966 
1967 */
1968 
1969 /* DISABLED
1970 
1971  template<>
1972  void DataSerializer::Serialize<ContentFilter>(const ContentFilter& data)
1973  {
1974  SerializeContainer(*this, data.Elements);
1975  }
1976 
1977 */
1978 
1979 /* DISABLED
1980 
1981  template<>
1982  void DataSerializer::Serialize<FilterOperand>(const FilterOperand& data)
1983  {
1984  *this << data.TypeId;
1985  *this << data.Encoding;
1986  if ((data.Encoding) & (1<<(0))) *this << data.Body;
1987  }
1988 
1989 */
1990 
1991 /* DISABLED
1992 
1993  template<>
1994  void DataSerializer::Serialize<ElementOperand>(const ElementOperand& data)
1995  {
1996  *this << data.TypeId;
1997  *this << data.Encoding;
1998  *this << data.BodyLength;
1999  *this << data.Index;
2000  }
2001 
2002 */
2003 
2004 /* DISABLED
2005 
2006  template<>
2007  void DataSerializer::Serialize<LiteralOperand>(const LiteralOperand& data)
2008  {
2009  *this << data.TypeId;
2010  *this << data.Encoding;
2011  *this << data.BodyLength;
2012  *this << data.Value;
2013  }
2014 
2015 */
2016 
2017 /* DISABLED
2018 
2019  template<>
2020  void DataSerializer::Serialize<AttributeOperand>(const AttributeOperand& data)
2021  {
2022  *this << data.TypeId;
2023  *this << data.Encoding;
2024  *this << data.BodyLength;
2025  *this << data.NodeId;
2026  *this << data.Alias;
2027  *this << data.BrowsePath;
2028  *this << data.AttributeId;
2029  *this << data.IndexRange;
2030  }
2031 
2032 */
2033 
2034 /* DISABLED
2035 
2036  template<>
2037  void DataSerializer::Serialize<SimpleAttributeOperand>(const SimpleAttributeOperand& data)
2038  {
2039  *this << data.TypeId;
2040  *this << data.Encoding;
2041  *this << data.BodyLength;
2042  *this << data.TypeDefinitionId;
2043  SerializeContainer(*this, data.BrowsePath);
2044  *this << data.AttributeId;
2045  *this << data.IndexRange;
2046  }
2047 
2048 */
2049 
2050 /* DISABLED
2051 
2052  template<>
2053  void DataSerializer::Serialize<ContentFilterElementResult>(const ContentFilterElementResult& data)
2054  {
2055  *this << data.Status;
2056  SerializeContainer(*this, data.OperandStatusCodes);
2057  SerializeContainer(*this, data.OperandDiagnosticInfos);
2058  }
2059 
2060 */
2061 
2062 /* DISABLED
2063 
2064  template<>
2065  void DataSerializer::Serialize<ContentFilterResult>(const ContentFilterResult& data)
2066  {
2067  SerializeContainer(*this, data.ElementResults);
2068  SerializeContainer(*this, data.ElementDiagnosticInfos);
2069  }
2070 
2071 */
2072 
2073 /* DISABLED
2074 
2075  template<>
2076  void DataSerializer::Serialize<ParsingResult>(const ParsingResult& data)
2077  {
2078  *this << data.Status;
2079  SerializeContainer(*this, data.DataStatusCodes);
2080  SerializeContainer(*this, data.DataDiagnosticInfos);
2081  }
2082 
2083 */
2084 
2085 /* DISABLED
2086 
2087  template<>
2088  void DataSerializer::Serialize<QueryFirstParameters>(const QueryFirstParameters& data)
2089  {
2090  *this << data.View;
2091  SerializeContainer(*this, data.NodeTypes);
2092  *this << data.Filter;
2093  *this << data.MaxDataSetsToReturn;
2094  *this << data.MaxReferencesToReturn;
2095  }
2096 
2097 */
2098 
2099 /* DISABLED
2100 
2101  template<>
2102  void DataSerializer::Serialize<QueryFirstRequest>(const QueryFirstRequest& data)
2103  {
2104  *this << data.TypeId;
2105  *this << data.Header;
2106  *this << data.Parameters;
2107  }
2108 
2109 */
2110 
2111 /* DISABLED
2112 
2113  template<>
2114  void DataSerializer::Serialize<QueryFirstResult>(const QueryFirstResult& data)
2115  {
2116  SerializeContainer(*this, data.QueryDataSets);
2117  *this << data.ContinuationPoint;
2118  SerializeContainer(*this, data.ParsingResults);
2119  SerializeContainer(*this, data.DiagnosticInfos);
2120  *this << data.FilterResult;
2121  }
2122 
2123 */
2124 
2125 /* DISABLED
2126 
2127  template<>
2128  void DataSerializer::Serialize<QueryFirstResponse>(const QueryFirstResponse& data)
2129  {
2130  *this << data.TypeId;
2131  *this << data.Header;
2132  *this << data.Parameters;
2133  }
2134 
2135 */
2136 
2137 /* DISABLED
2138 
2139  template<>
2140  void DataSerializer::Serialize<QueryNextParameters>(const QueryNextParameters& data)
2141  {
2142  *this << data.ReleaseContinuationPoint;
2143  *this << data.ContinuationPoint;
2144  }
2145 
2146 */
2147 
2148 /* DISABLED
2149 
2150  template<>
2151  void DataSerializer::Serialize<QueryNextRequest>(const QueryNextRequest& data)
2152  {
2153  *this << data.TypeId;
2154  *this << data.Header;
2155  *this << data.Parameters;
2156  }
2157 
2158 */
2159 
2160 /* DISABLED
2161 
2162  template<>
2163  void DataSerializer::Serialize<QueryNextResult>(const QueryNextResult& data)
2164  {
2165  SerializeContainer(*this, data.QueryDataSets);
2166  *this << data.RevisedContinuationPoint;
2167  }
2168 
2169 */
2170 
2171 /* DISABLED
2172 
2173  template<>
2174  void DataSerializer::Serialize<QueryNextResponse>(const QueryNextResponse& data)
2175  {
2176  *this << data.TypeId;
2177  *this << data.Header;
2178  *this << data.Parameters;
2179  }
2180 
2181 */
2182 
2183 template<>
2184 void DataSerializer::Serialize<ReadValueId>(const ReadValueId & data)
2185 {
2186  *this << data.NodeId;
2187  *this << data.AttributeId;
2188  *this << data.IndexRange;
2189  *this << data.DataEncoding;
2190 }
2191 
2192 
2193 template<>
2194 void DataSerializer::Serialize<ReadParameters>(const ReadParameters & data)
2195 {
2196  *this << data.MaxAge;
2197  *this << data.TimestampsToReturn;
2198  SerializeContainer(*this, data.AttributesToRead);
2199 }
2200 
2201 
2202 template<>
2203 void DataSerializer::Serialize<ReadRequest>(const ReadRequest & data)
2204 {
2205  *this << data.TypeId;
2206  *this << data.Header;
2207  *this << data.Parameters;
2208 }
2209 
2210 
2211 template<>
2212 void DataSerializer::Serialize<ReadResponse>(const ReadResponse & data)
2213 {
2214  *this << data.TypeId;
2215  *this << data.Header;
2216  SerializeContainer(*this, data.Results);
2217  SerializeContainer(*this, data.DiagnosticInfos);
2218 }
2219 
2220 
2221 /* DISABLED
2222 
2223  template<>
2224  void DataSerializer::Serialize<HistoryReadValueId>(const HistoryReadValueId& data)
2225  {
2226  *this << data.NodeId;
2227  *this << data.IndexRange;
2228  *this << data.DataEncoding;
2229  *this << data.ContinuationPoint;
2230  }
2231 
2232 */
2233 
2234 /* DISABLED
2235 
2236  template<>
2237  void DataSerializer::Serialize<HistoryReadResult>(const HistoryReadResult& data)
2238  {
2239  *this << data.Status;
2240  *this << data.ContinuationPoint;
2241  *this << data.HistoryData;
2242  }
2243 
2244 */
2245 
2246 /* DISABLED
2247 
2248  template<>
2249  void DataSerializer::Serialize<HistoryReadDetails>(const HistoryReadDetails& data)
2250  {
2251  *this << data.TypeId;
2252  *this << data.Encoding;
2253  if ((data.Encoding) & (1<<(0))) *this << data.Body;
2254  }
2255 
2256 */
2257 
2258 /* DISABLED
2259 
2260  template<>
2261  void DataSerializer::Serialize<ReadRawModifiedDetails>(const ReadRawModifiedDetails& data)
2262  {
2263  *this << data.TypeId;
2264  *this << data.Encoding;
2265  *this << data.BodyLength;
2266  *this << data.IsReadModified;
2267  *this << data.StartTime;
2268  *this << data.EndTime;
2269  *this << data.NumValuesPerNode;
2270  *this << data.ReturnBounds;
2271  }
2272 
2273 */
2274 
2275 /* DISABLED
2276 
2277  template<>
2278  void DataSerializer::Serialize<ReadAtTimeDetails>(const ReadAtTimeDetails& data)
2279  {
2280  *this << data.TypeId;
2281  *this << data.Encoding;
2282  *this << data.BodyLength;
2283  SerializeContainer(*this, data.ReqTimes);
2284  *this << data.UseSimpleBounds;
2285  }
2286 
2287 */
2288 
2289 /* DISABLED
2290 
2291  template<>
2292  void DataSerializer::Serialize<HistoryData>(const HistoryData& data)
2293  {
2294  SerializeContainer(*this, data.DataValues);
2295  }
2296 
2297 */
2298 
2299 /* DISABLED
2300 
2301  template<>
2302  void DataSerializer::Serialize<ModificationInfo>(const ModificationInfo& data)
2303  {
2304  *this << data.ModificationTime;
2305  *this << data.UpdateType;
2306  *this << data.UserName;
2307  }
2308 
2309 */
2310 
2311 /* DISABLED
2312 
2313  template<>
2314  void DataSerializer::Serialize<HistoryModifiedData>(const HistoryModifiedData& data)
2315  {
2316  SerializeContainer(*this, data.DataValues);
2317  SerializeContainer(*this, data.ModificationInfos);
2318  }
2319 
2320 */
2321 
2322 /* DISABLED
2323 
2324  template<>
2325  void DataSerializer::Serialize<HistoryReadParameters>(const HistoryReadParameters& data)
2326  {
2327  *this << data.HistoryReadDetails;
2328  *this << data.TimestampsToReturn;
2329  *this << data.ReleaseContinuationPoints;
2330  SerializeContainer(*this, data.AttributesToRead);
2331  }
2332 
2333 */
2334 
2335 /* DISABLED
2336 
2337  template<>
2338  void DataSerializer::Serialize<HistoryReadRequest>(const HistoryReadRequest& data)
2339  {
2340  *this << data.TypeId;
2341  *this << data.Header;
2342  *this << data.Parameters;
2343  }
2344 
2345 */
2346 
2347 /* DISABLED
2348 
2349  template<>
2350  void DataSerializer::Serialize<HistoryReadResponse>(const HistoryReadResponse& data)
2351  {
2352  *this << data.TypeId;
2353  *this << data.Header;
2354  SerializeContainer(*this, data.Results);
2355  SerializeContainer(*this, data.DiagnosticInfos);
2356  }
2357 
2358 */
2359 
2360 template<>
2361 void DataSerializer::Serialize<WriteValue>(const WriteValue & data)
2362 {
2363  *this << data.NodeId;
2364  *this << data.AttributeId;
2365  *this << data.IndexRange;
2366  *this << data.Value;
2367 }
2368 
2369 
2370 template<>
2371 void DataSerializer::Serialize<WriteParameters>(const WriteParameters & data)
2372 {
2373  SerializeContainer(*this, data.NodesToWrite);
2374 }
2375 
2376 
2377 template<>
2378 void DataSerializer::Serialize<WriteRequest>(const WriteRequest & data)
2379 {
2380  *this << data.TypeId;
2381  *this << data.Header;
2382  *this << data.Parameters;
2383 }
2384 
2385 
2386 template<>
2387 void DataSerializer::Serialize<WriteResponse>(const WriteResponse & data)
2388 {
2389  *this << data.TypeId;
2390  *this << data.Header;
2391  SerializeContainer(*this, data.Results);
2392  SerializeContainer(*this, data.DiagnosticInfos);
2393 }
2394 
2395 
2396 /* DISABLED
2397 
2398  template<>
2399  void DataSerializer::Serialize<HistoryUpdateDetails>(const HistoryUpdateDetails& data)
2400  {
2401  *this << data.NodeId;
2402  }
2403 
2404 */
2405 
2406 /* DISABLED
2407 
2408  template<>
2409  void DataSerializer::Serialize<UpdateDataDetails>(const UpdateDataDetails& data)
2410  {
2411  *this << data.NodeId;
2412  *this << data.PerformInsertReplace;
2413  SerializeContainer(*this, data.UpdateValues);
2414  }
2415 
2416 */
2417 
2418 /* DISABLED
2419 
2420  template<>
2421  void DataSerializer::Serialize<UpdateStructureDataDetails>(const UpdateStructureDataDetails& data)
2422  {
2423  *this << data.NodeId;
2424  *this << data.PerformInsertReplace;
2425  SerializeContainer(*this, data.UpdateValues);
2426  }
2427 
2428 */
2429 
2430 /* DISABLED
2431 
2432  template<>
2433  void DataSerializer::Serialize<DeleteRawModifiedDetails>(const DeleteRawModifiedDetails& data)
2434  {
2435  *this << data.NodeId;
2436  *this << data.IsDeleteModified;
2437  *this << data.StartTime;
2438  *this << data.EndTime;
2439  }
2440 
2441 */
2442 
2443 /* DISABLED
2444 
2445  template<>
2446  void DataSerializer::Serialize<DeleteAtTimeDetails>(const DeleteAtTimeDetails& data)
2447  {
2448  *this << data.NodeId;
2449  SerializeContainer(*this, data.ReqTimes);
2450  }
2451 
2452 */
2453 
2454 /* DISABLED
2455 
2456  template<>
2457  void DataSerializer::Serialize<DeleteEventDetails>(const DeleteEventDetails& data)
2458  {
2459  *this << data.NodeId;
2460  SerializeContainer(*this, data.EventIds);
2461  }
2462 
2463 */
2464 
2465 /* DISABLED
2466 
2467  template<>
2468  void DataSerializer::Serialize<HistoryUpdateResult>(const HistoryUpdateResult& data)
2469  {
2470  *this << data.Status;
2471  SerializeContainer(*this, data.OperationResults);
2472  SerializeContainer(*this, data.DiagnosticInfos);
2473  }
2474 
2475 */
2476 
2477 /* DISABLED
2478 
2479  template<>
2480  void DataSerializer::Serialize<HistoryUpdateParameters>(const HistoryUpdateParameters& data)
2481  {
2482  SerializeContainer(*this, data.HistoryUpdateDetails);
2483  }
2484 
2485 */
2486 
2487 /* DISABLED
2488 
2489  template<>
2490  void DataSerializer::Serialize<HistoryUpdateRequest>(const HistoryUpdateRequest& data)
2491  {
2492  *this << data.TypeId;
2493  *this << data.Header;
2494  *this << data.Parameters;
2495  }
2496 
2497 */
2498 
2499 /* DISABLED
2500 
2501  template<>
2502  void DataSerializer::Serialize<HistoryUpdateResponse>(const HistoryUpdateResponse& data)
2503  {
2504  *this << data.TypeId;
2505  *this << data.Header;
2506  SerializeContainer(*this, data.Results);
2507  SerializeContainer(*this, data.DiagnosticInfos);
2508  }
2509 
2510 */
2511 
2512 template<>
2513 void DataSerializer::Serialize<CallMethodRequest>(const CallMethodRequest & data)
2514 {
2515  *this << data.ObjectId;
2516  *this << data.MethodId;
2517  SerializeContainer(*this, data.InputArguments);
2518 }
2519 
2520 
2521 template<>
2522 void DataSerializer::Serialize<CallMethodResult>(const CallMethodResult & data)
2523 {
2524  *this << data.Status;
2525  SerializeContainer(*this, data.InputArgumentResults);
2526  SerializeContainer(*this, data.InputArgumentDiagnosticInfos);
2527  SerializeContainer(*this, data.OutputArguments);
2528 }
2529 
2530 
2531 template<>
2532 void DataSerializer::Serialize<CallParameters>(const CallParameters & data)
2533 {
2534  SerializeContainer(*this, data.MethodsToCall);
2535 }
2536 
2537 
2538 template<>
2539 void DataSerializer::Serialize<CallRequest>(const CallRequest & data)
2540 {
2541  *this << data.TypeId;
2542  *this << data.Header;
2543  *this << data.Parameters;
2544 }
2545 
2546 
2547 template<>
2548 void DataSerializer::Serialize<CallResponse>(const CallResponse & data)
2549 {
2550  *this << data.TypeId;
2551  *this << data.Header;
2552  SerializeContainer(*this, data.Results);
2553  SerializeContainer(*this, data.DiagnosticInfos);
2554 }
2555 
2556 
2557 /* DISABLED
2558 
2559  template<>
2560  void DataSerializer::Serialize<MonitoringFilter>(const MonitoringFilter& data)
2561  {
2562  *this << data.TypeId;
2563  *this << data.Encoding;
2564  if ((data.Encoding) & (1<<(0))) *this << data.Body;
2565  }
2566 
2567 */
2568 
2569 /* DISABLED
2570 
2571  template<>
2572  void DataSerializer::Serialize<DataChangeFilter>(const DataChangeFilter& data)
2573  {
2574  *this << data.TypeId;
2575  *this << data.Encoding;
2576  *this << data.BodyLength;
2577  *this << data.Trigger;
2578  *this << data.DeadbandType;
2579  *this << data.DeadbandValue;
2580  }
2581 
2582 */
2583 
2584 /* DISABLED
2585 
2586  template<>
2587  void DataSerializer::Serialize<EventFilter>(const EventFilter& data)
2588  {
2589  *this << data.TypeId;
2590  *this << data.Encoding;
2591  *this << data.BodyLength;
2592  SerializeContainer(*this, data.SelectClauses);
2593  *this << data.WhereClause;
2594  }
2595 
2596 */
2597 
2598 /* DISABLED
2599 
2600  template<>
2601  void DataSerializer::Serialize<ReadEventDetails>(const ReadEventDetails& data)
2602  {
2603  *this << data.TypeId;
2604  *this << data.Encoding;
2605  *this << data.BodyLength;
2606  *this << data.NumValuesPerNode;
2607  *this << data.StartTime;
2608  *this << data.EndTime;
2609  *this << data.Filter;
2610  }
2611 
2612 */
2613 
2614 /* DISABLED
2615 
2616  template<>
2617  void DataSerializer::Serialize<AggregateConfiguration>(const AggregateConfiguration& data)
2618  {
2619  *this << data.UseServerCapabilitiesDefaults;
2620  *this << data.TreatUncertainAsBad;
2621  *this << data.PercentDataBad;
2622  *this << data.PercentDataGood;
2623  *this << data.UseSlopedExtrapolation;
2624  }
2625 
2626 */
2627 
2628 /* DISABLED
2629 
2630  template<>
2631  void DataSerializer::Serialize<ReadProcessedDetails>(const ReadProcessedDetails& data)
2632  {
2633  *this << data.TypeId;
2634  *this << data.Encoding;
2635  *this << data.BodyLength;
2636  *this << data.StartTime;
2637  *this << data.EndTime;
2638  *this << data.ProcessingInterval;
2639  SerializeContainer(*this, data.AggregateType);
2640  *this << data.AggregateConfiguration;
2641  }
2642 
2643 */
2644 
2645 /* DISABLED
2646 
2647  template<>
2648  void DataSerializer::Serialize<AggregateFilter>(const AggregateFilter& data)
2649  {
2650  *this << data.TypeId;
2651  *this << data.Encoding;
2652  *this << data.BodyLength;
2653  *this << data.StartTime;
2654  *this << data.AggregateType;
2655  *this << data.ProcessingInterval;
2656  *this << data.AggregateConfiguration;
2657  }
2658 
2659 */
2660 
2661 /* DISABLED
2662 
2663  template<>
2664  void DataSerializer::Serialize<MonitoringFilterResult>(const MonitoringFilterResult& data)
2665  {
2666  *this << data.TypeId;
2667  *this << data.Encoding;
2668  if ((data.Encoding) & (1<<(0))) *this << data.Body;
2669  }
2670 
2671 */
2672 
2673 /* DISABLED
2674 
2675  template<>
2676  void DataSerializer::Serialize<EventFilterResult>(const EventFilterResult& data)
2677  {
2678  *this << data.TypeId;
2679  *this << data.Encoding;
2680  *this << data.BodyLength;
2681  SerializeContainer(*this, data.SelectClauseResults);
2682  SerializeContainer(*this, data.SelectClauseDiagnosticInfos);
2683  *this << data.WhereClauseResult;
2684  }
2685 
2686 */
2687 
2688 /* DISABLED
2689 
2690  template<>
2691  void DataSerializer::Serialize<HistoryUpdateEventResult>(const HistoryUpdateEventResult& data)
2692  {
2693  *this << data.Status;
2694  *this << data.EventFilterResult;
2695  }
2696 
2697 */
2698 
2699 /* DISABLED
2700 
2701  template<>
2702  void DataSerializer::Serialize<AggregateFilterResult>(const AggregateFilterResult& data)
2703  {
2704  *this << data.TypeId;
2705  *this << data.Encoding;
2706  *this << data.BodyLength;
2707  *this << data.RevisedStartTime;
2708  *this << data.RevisedProcessingInterval;
2709  *this << data.RevisedAggregateConfiguration;
2710  }
2711 
2712 */
2713 
2714 template<>
2715 void DataSerializer::Serialize<MonitoringParameters>(const MonitoringParameters & data)
2716 {
2717  *this << data.ClientHandle;
2718  *this << data.SamplingInterval;
2719  *this << data.Filter;
2720  *this << data.QueueSize;
2721  *this << data.DiscardOldest;
2722 }
2723 
2724 
2725 template<>
2726 void DataSerializer::Serialize<MonitoredItemCreateRequest>(const MonitoredItemCreateRequest & data)
2727 {
2728  *this << data.ItemToMonitor;
2729  *this << data.MonitoringMode;
2730  *this << data.RequestedParameters;
2731 }
2732 
2733 
2734 template<>
2735 void DataSerializer::Serialize<MonitoredItemCreateResult>(const MonitoredItemCreateResult & data)
2736 {
2737  *this << data.Status;
2738  *this << data.MonitoredItemId;
2739  *this << data.RevisedSamplingInterval;
2740  *this << data.RevisedQueueSize;
2741  *this << data.FilterResult;
2742 }
2743 
2744 
2745 template<>
2746 void DataSerializer::Serialize<MonitoredItemsParameters>(const MonitoredItemsParameters & data)
2747 {
2748  *this << data.SubscriptionId;
2749  *this << data.TimestampsToReturn;
2750  SerializeContainer(*this, data.ItemsToCreate);
2751 }
2752 
2753 
2754 template<>
2755 void DataSerializer::Serialize<CreateMonitoredItemsRequest>(const CreateMonitoredItemsRequest & data)
2756 {
2757  *this << data.TypeId;
2758  *this << data.Header;
2759  *this << data.Parameters;
2760 }
2761 
2762 
2763 template<>
2764 void DataSerializer::Serialize<CreateMonitoredItemsResponse>(const CreateMonitoredItemsResponse & data)
2765 {
2766  *this << data.TypeId;
2767  *this << data.Header;
2768  SerializeContainer(*this, data.Results);
2769  SerializeContainer(*this, data.DiagnosticInfos);
2770 }
2771 
2772 
2773 /* DISABLED
2774 
2775  template<>
2776  void DataSerializer::Serialize<MonitoredItemModifyRequest>(const MonitoredItemModifyRequest& data)
2777  {
2778  *this << data.MonitoredItemId;
2779  *this << data.RequestedParameters;
2780  }
2781 
2782 */
2783 
2784 /* DISABLED
2785 
2786  template<>
2787  void DataSerializer::Serialize<MonitoredItemModifyResult>(const MonitoredItemModifyResult& data)
2788  {
2789  *this << data.Status;
2790  *this << data.RevisedSamplingInterval;
2791  *this << data.RevisedQueueSize;
2792  *this << data.FilterResult;
2793  }
2794 
2795 */
2796 
2797 /* DISABLED
2798 
2799  template<>
2800  void DataSerializer::Serialize<ModifyMonitoredItemsParameters>(const ModifyMonitoredItemsParameters& data)
2801  {
2802  *this << data.SubscriptionId;
2803  *this << data.TimestampsToReturn;
2804  SerializeContainer(*this, data.ItemsToModify);
2805  }
2806 
2807 */
2808 
2809 /* DISABLED
2810 
2811  template<>
2812  void DataSerializer::Serialize<ModifyMonitoredItemsRequest>(const ModifyMonitoredItemsRequest& data)
2813  {
2814  *this << data.TypeId;
2815  *this << data.Header;
2816  *this << data.Parameters;
2817  }
2818 
2819 */
2820 
2821 /* DISABLED
2822 
2823  template<>
2824  void DataSerializer::Serialize<ModifyMonitoredItemsResponse>(const ModifyMonitoredItemsResponse& data)
2825  {
2826  *this << data.TypeId;
2827  *this << data.Header;
2828  SerializeContainer(*this, data.Results);
2829  SerializeContainer(*this, data.DiagnosticInfos);
2830  }
2831 
2832 */
2833 
2834 /* DISABLED
2835 
2836  template<>
2837  void DataSerializer::Serialize<SetMonitoringModeParameters>(const SetMonitoringModeParameters& data)
2838  {
2839  *this << data.SubscriptionId;
2840  *this << data.MonitoringMode;
2841  SerializeContainer(*this, data.MonitoredItemIds);
2842  }
2843 
2844 */
2845 
2846 /* DISABLED
2847 
2848  template<>
2849  void DataSerializer::Serialize<SetMonitoringModeRequest>(const SetMonitoringModeRequest& data)
2850  {
2851  *this << data.TypeId;
2852  *this << data.Header;
2853  *this << data.Parameters;
2854  }
2855 
2856 */
2857 
2858 /* DISABLED
2859 
2860  template<>
2861  void DataSerializer::Serialize<SetMonitoringModeResult>(const SetMonitoringModeResult& data)
2862  {
2863  SerializeContainer(*this, data.Results);
2864  SerializeContainer(*this, data.DiagnosticInfos);
2865  }
2866 
2867 */
2868 
2869 /* DISABLED
2870 
2871  template<>
2872  void DataSerializer::Serialize<SetMonitoringModeResponse>(const SetMonitoringModeResponse& data)
2873  {
2874  *this << data.TypeId;
2875  *this << data.Header;
2876  *this << data.Parameters;
2877  }
2878 
2879 */
2880 
2881 /* DISABLED
2882 
2883  template<>
2884  void DataSerializer::Serialize<SetTriggeringParameters>(const SetTriggeringParameters& data)
2885  {
2886  *this << data.SubscriptionId;
2887  *this << data.TriggeringItemId;
2888  SerializeContainer(*this, data.LinksToAdd);
2889  SerializeContainer(*this, data.LinksToRemove);
2890  }
2891 
2892 */
2893 
2894 /* DISABLED
2895 
2896  template<>
2897  void DataSerializer::Serialize<SetTriggeringRequest>(const SetTriggeringRequest& data)
2898  {
2899  *this << data.TypeId;
2900  *this << data.Header;
2901  *this << data.Parameters;
2902  }
2903 
2904 */
2905 
2906 /* DISABLED
2907 
2908  template<>
2909  void DataSerializer::Serialize<SetTriggeringResult>(const SetTriggeringResult& data)
2910  {
2911  SerializeContainer(*this, data.AddResults);
2912  SerializeContainer(*this, data.AddDiagnosticInfos);
2913  SerializeContainer(*this, data.RemoveResults);
2914  SerializeContainer(*this, data.RemoveDiagnosticInfos);
2915  }
2916 
2917 */
2918 
2919 /* DISABLED
2920 
2921  template<>
2922  void DataSerializer::Serialize<SetTriggeringResponse>(const SetTriggeringResponse& data)
2923  {
2924  *this << data.TypeId;
2925  *this << data.Header;
2926  *this << data.Parameters;
2927  }
2928 
2929 */
2930 
2931 template<>
2932 void DataSerializer::Serialize<DeleteMonitoredItemsParameters>(const DeleteMonitoredItemsParameters & data)
2933 {
2934  *this << data.SubscriptionId;
2935  SerializeContainer(*this, data.MonitoredItemIds);
2936 }
2937 
2938 
2939 template<>
2940 void DataSerializer::Serialize<DeleteMonitoredItemsRequest>(const DeleteMonitoredItemsRequest & data)
2941 {
2942  *this << data.TypeId;
2943  *this << data.Header;
2944  *this << data.Parameters;
2945 }
2946 
2947 
2948 template<>
2949 void DataSerializer::Serialize<DeleteMonitoredItemsResponse>(const DeleteMonitoredItemsResponse & data)
2950 {
2951  *this << data.TypeId;
2952  *this << data.Header;
2953  SerializeContainer(*this, data.Results);
2954  SerializeContainer(*this, data.DiagnosticInfos);
2955 }
2956 
2957 
2958 template<>
2959 void DataSerializer::Serialize<CreateSubscriptionParameters>(const CreateSubscriptionParameters & data)
2960 {
2961  *this << data.RequestedPublishingInterval;
2962  *this << data.RequestedLifetimeCount;
2963  *this << data.RequestedMaxKeepAliveCount;
2964  *this << data.MaxNotificationsPerPublish;
2965  *this << data.PublishingEnabled;
2966  *this << data.Priority;
2967 }
2968 
2969 
2970 template<>
2971 void DataSerializer::Serialize<CreateSubscriptionRequest>(const CreateSubscriptionRequest & data)
2972 {
2973  *this << data.TypeId;
2974  *this << data.Header;
2975  *this << data.Parameters;
2976 }
2977 
2978 
2979 template<>
2980 void DataSerializer::Serialize<SubscriptionData>(const SubscriptionData & data)
2981 {
2982  *this << data.SubscriptionId;
2983  *this << data.RevisedPublishingInterval;
2984  *this << data.RevisedLifetimeCount;
2985  *this << data.RevisedMaxKeepAliveCount;
2986 }
2987 
2988 
2989 template<>
2990 void DataSerializer::Serialize<CreateSubscriptionResponse>(const CreateSubscriptionResponse & data)
2991 {
2992  *this << data.TypeId;
2993  *this << data.Header;
2994  *this << data.Data;
2995 }
2996 
2997 
2998 template<>
2999 void DataSerializer::Serialize<ModifySubscriptionParameters>(const ModifySubscriptionParameters & data)
3000 {
3001  *this << data.SubscriptionId;
3002  *this << data.RequestedPublishingInterval;
3003  *this << data.RequestedLifetimeCount;
3004  *this << data.RequestedMaxKeepAliveCount;
3005  *this << data.MaxNotificationsPerPublish;
3006  *this << data.Priority;
3007 }
3008 
3009 
3010 template<>
3011 void DataSerializer::Serialize<ModifySubscriptionRequest>(const ModifySubscriptionRequest & data)
3012 {
3013  *this << data.TypeId;
3014  *this << data.Header;
3015  *this << data.Parameters;
3016 }
3017 
3018 
3019 template<>
3020 void DataSerializer::Serialize<ModifySubscriptionResult>(const ModifySubscriptionResult & data)
3021 {
3022  *this << data.RevisedPublishingInterval;
3023  *this << data.RevisedLifetimeCount;
3024  *this << data.RevisedMaxKeepAliveCount;
3025 }
3026 
3027 
3028 template<>
3029 void DataSerializer::Serialize<ModifySubscriptionResponse>(const ModifySubscriptionResponse & data)
3030 {
3031  *this << data.TypeId;
3032  *this << data.Header;
3033  *this << data.Parameters;
3034 }
3035 
3036 
3037 template<>
3038 void DataSerializer::Serialize<PublishingModeParameters>(const PublishingModeParameters & data)
3039 {
3040  *this << data.PublishingEnabled;
3041  SerializeContainer(*this, data.SubscriptionIds);
3042 }
3043 
3044 
3045 template<>
3046 void DataSerializer::Serialize<SetPublishingModeRequest>(const SetPublishingModeRequest & data)
3047 {
3048  *this << data.TypeId;
3049  *this << data.Header;
3050  *this << data.Parameters;
3051 }
3052 
3053 
3054 template<>
3055 void DataSerializer::Serialize<PublishingModeResult>(const PublishingModeResult & data)
3056 {
3057  SerializeContainer(*this, data.Results);
3058  SerializeContainer(*this, data.DiagnosticInfos);
3059 }
3060 
3061 
3062 template<>
3063 void DataSerializer::Serialize<SetPublishingModeResponse>(const SetPublishingModeResponse & data)
3064 {
3065  *this << data.TypeId;
3066  *this << data.Header;
3067  *this << data.Result;
3068 }
3069 
3070 
3071 template<>
3072 void DataSerializer::Serialize<NotificationMessage>(const NotificationMessage & data)
3073 {
3074  *this << data.SequenceNumber;
3075  *this << data.PublishTime;
3076  SerializeContainer(*this, data.NotificationData);
3077 }
3078 
3079 
3080 /* DISABLED
3081 
3082  template<>
3083  void DataSerializer::Serialize<NotificationData>(const NotificationData& data)
3084  {
3085  *this << data.TypeId;
3086  *this << data.Encoding;
3087  if ((data.Encoding) & (1<<(0))) *this << data.Body;
3088  }
3089 
3090 */
3091 
3092 /* DISABLED
3093 
3094  template<>
3095  void DataSerializer::Serialize<MonitoredItemNotification>(const MonitoredItemNotification& data)
3096  {
3097  *this << data.ClientHandle;
3098  *this << data.Value;
3099  }
3100 
3101 */
3102 
3103 /* DISABLED
3104 
3105  template<>
3106  void DataSerializer::Serialize<DataChangeNotification>(const DataChangeNotification& data)
3107  {
3108  *this << data.TypeId;
3109  *this << data.Encoding;
3110  *this << data.BodyLength;
3111  SerializeContainer(*this, data.MonitoredItems);
3112  SerializeContainer(*this, data.DiagnosticInfos);
3113  }
3114 
3115 */
3116 
3117 /* DISABLED
3118 
3119  template<>
3120  void DataSerializer::Serialize<EventFieldList>(const EventFieldList& data)
3121  {
3122  *this << data.ClientHandle;
3123  SerializeContainer(*this, data.EventFields);
3124  }
3125 
3126 */
3127 
3128 /* DISABLED
3129 
3130  template<>
3131  void DataSerializer::Serialize<EventNotificationList>(const EventNotificationList& data)
3132  {
3133  *this << data.TypeId;
3134  *this << data.Encoding;
3135  *this << data.BodyLength;
3136  SerializeContainer(*this, data.Events);
3137  }
3138 
3139 */
3140 
3141 /* DISABLED
3142 
3143  template<>
3144  void DataSerializer::Serialize<HistoryEventFieldList>(const HistoryEventFieldList& data)
3145  {
3146  SerializeContainer(*this, data.EventFields);
3147  }
3148 
3149 */
3150 
3151 /* DISABLED
3152 
3153  template<>
3154  void DataSerializer::Serialize<HistoryEvent>(const HistoryEvent& data)
3155  {
3156  SerializeContainer(*this, data.Events);
3157  }
3158 
3159 */
3160 
3161 /* DISABLED
3162 
3163  template<>
3164  void DataSerializer::Serialize<UpdateEventDetails>(const UpdateEventDetails& data)
3165  {
3166  *this << data.NodeId;
3167  *this << data.PerformInsertReplace;
3168  *this << data.Filter;
3169  SerializeContainer(*this, data.EventData);
3170  }
3171 
3172 */
3173 
3174 /* DISABLED
3175 
3176  template<>
3177  void DataSerializer::Serialize<StatusChangeNotification>(const StatusChangeNotification& data)
3178  {
3179  *this << data.TypeId;
3180  *this << data.Encoding;
3181  *this << data.BodyLength;
3182  *this << data.Status;
3183  *this << data.DiagnosticInfo;
3184  }
3185 
3186 */
3187 
3188 template<>
3189 void DataSerializer::Serialize<SubscriptionAcknowledgement>(const SubscriptionAcknowledgement & data)
3190 {
3191  *this << data.SubscriptionId;
3192  *this << data.SequenceNumber;
3193 }
3194 
3195 
3196 template<>
3197 void DataSerializer::Serialize<PublishRequest>(const PublishRequest & data)
3198 {
3199  *this << data.TypeId;
3200  *this << data.Header;
3201  SerializeContainer(*this, data.SubscriptionAcknowledgements);
3202 }
3203 
3204 
3205 template<>
3206 void DataSerializer::Serialize<PublishResult>(const PublishResult & data)
3207 {
3208  *this << data.SubscriptionId;
3209  SerializeContainer(*this, data.AvailableSequenceNumbers);
3210  *this << data.MoreNotifications;
3211  *this << data.NotificationMessage;
3212  SerializeContainer(*this, data.Results);
3213  SerializeContainer(*this, data.DiagnosticInfos);
3214 }
3215 
3216 
3217 template<>
3218 void DataSerializer::Serialize<PublishResponse>(const PublishResponse & data)
3219 {
3220  *this << data.TypeId;
3221  *this << data.Header;
3222  *this << data.Parameters;
3223 }
3224 
3225 
3226 template<>
3227 void DataSerializer::Serialize<RepublishParameters>(const RepublishParameters & data)
3228 {
3229  *this << data.SubscriptionId;
3230  *this << data.RetransmitSequenceNumber;
3231 }
3232 
3233 
3234 template<>
3235 void DataSerializer::Serialize<RepublishRequest>(const RepublishRequest & data)
3236 {
3237  *this << data.TypeId;
3238  *this << data.Header;
3239  *this << data.Parameters;
3240 }
3241 
3242 
3243 template<>
3244 void DataSerializer::Serialize<RepublishResponse>(const RepublishResponse & data)
3245 {
3246  *this << data.TypeId;
3247  *this << data.Header;
3248  *this << data.NotificationMessage;
3249 }
3250 
3251 
3252 /* DISABLED
3253 
3254  template<>
3255  void DataSerializer::Serialize<TransferResult>(const TransferResult& data)
3256  {
3257  *this << data.Status;
3258  SerializeContainer(*this, data.AvailableSequenceNumbers);
3259  }
3260 
3261 */
3262 
3263 /* DISABLED
3264 
3265  template<>
3266  void DataSerializer::Serialize<TransferSubscriptionsParameters>(const TransferSubscriptionsParameters& data)
3267  {
3268  SerializeContainer(*this, data.SubscriptionIds);
3269  *this << data.SendInitialValues;
3270  }
3271 
3272 */
3273 
3274 /* DISABLED
3275 
3276  template<>
3277  void DataSerializer::Serialize<TransferSubscriptionsRequest>(const TransferSubscriptionsRequest& data)
3278  {
3279  *this << data.TypeId;
3280  *this << data.Header;
3281  *this << data.Parameters;
3282  }
3283 
3284 */
3285 
3286 /* DISABLED
3287 
3288  template<>
3289  void DataSerializer::Serialize<TransferSubscriptionsResult>(const TransferSubscriptionsResult& data)
3290  {
3291  SerializeContainer(*this, data.Results);
3292  SerializeContainer(*this, data.DiagnosticInfos);
3293  }
3294 
3295 */
3296 
3297 /* DISABLED
3298 
3299  template<>
3300  void DataSerializer::Serialize<TransferSubscriptionsResponse>(const TransferSubscriptionsResponse& data)
3301  {
3302  *this << data.TypeId;
3303  *this << data.Header;
3304  *this << data.Parameters;
3305  }
3306 
3307 */
3308 
3309 template<>
3310 void DataSerializer::Serialize<DeleteSubscriptionsRequest>(const DeleteSubscriptionsRequest & data)
3311 {
3312  *this << data.TypeId;
3313  *this << data.Header;
3314  SerializeContainer(*this, data.SubscriptionIds);
3315 }
3316 
3317 
3318 template<>
3319 void DataSerializer::Serialize<DeleteSubscriptionsResponse>(const DeleteSubscriptionsResponse & data)
3320 {
3321  *this << data.TypeId;
3322  *this << data.Header;
3323  SerializeContainer(*this, data.Results);
3324  SerializeContainer(*this, data.DiagnosticInfos);
3325 }
3326 
3327 
3328 /* DISABLED
3329 
3330  template<>
3331  void DataSerializer::Serialize<ScalarTestType>(const ScalarTestType& data)
3332  {
3333  *this << data.Boolean;
3334  *this << data.SByte;
3335  *this << data.Byte;
3336  *this << data.Int16;
3337  *this << data.UInt16;
3338  *this << data.Int32;
3339  *this << data.UInt32;
3340  *this << data.Int64;
3341  *this << data.UInt64;
3342  *this << data.Float;
3343  *this << data.Double;
3344  *this << data.String;
3345  *this << data.DateTime;
3346  *this << data.Guid;
3347  *this << data.ByteString;
3348  *this << data.XmlElement;
3349  *this << data.NodeId;
3350  *this << data.ExpandedNodeId;
3351  *this << data.Status;
3352  *this << data.DiagnosticInfo;
3353  *this << data.QualifiedName;
3354  *this << data.LocalizedText;
3355  *this << data.ExtensionObject;
3356  *this << data.DataValue;
3357  *this << data.EnumeratedValue;
3358  }
3359 
3360 */
3361 
3362 /* DISABLED
3363 
3364  template<>
3365  void DataSerializer::Serialize<ArrayTestType>(const ArrayTestType& data)
3366  {
3367  SerializeContainer(*this, data.Booleans);
3368  SerializeContainer(*this, data.SBytes);
3369  SerializeContainer(*this, data.Int16s);
3370  SerializeContainer(*this, data.UInt16s);
3371  SerializeContainer(*this, data.Int32s);
3372  SerializeContainer(*this, data.UInt32s);
3373  SerializeContainer(*this, data.Int64s);
3374  SerializeContainer(*this, data.UInt64s);
3375  SerializeContainer(*this, data.Floats);
3376  SerializeContainer(*this, data.Doubles);
3377  SerializeContainer(*this, data.Strings);
3378  SerializeContainer(*this, data.DateTimes);
3379  SerializeContainer(*this, data.Guids);
3380  SerializeContainer(*this, data.ByteStrings);
3381  SerializeContainer(*this, data.XmlElements);
3382  SerializeContainer(*this, data.NodeIds);
3383  SerializeContainer(*this, data.ExpandedNodeIds);
3384  SerializeContainer(*this, data.StatusCodes);
3385  SerializeContainer(*this, data.DiagnosticInfos);
3386  SerializeContainer(*this, data.QualifiedNames);
3387  SerializeContainer(*this, data.LocalizedTexts);
3388  SerializeContainer(*this, data.ExtensionObjects);
3389  SerializeContainer(*this, data.DataValues);
3390  SerializeContainer(*this, data.Variants);
3391  SerializeContainer(*this, data.EnumeratedValues);
3392  }
3393 
3394 */
3395 
3396 /* DISABLED
3397 
3398  template<>
3399  void DataSerializer::Serialize<CompositeTestType>(const CompositeTestType& data)
3400  {
3401  *this << data.Field1;
3402  *this << data.Field2;
3403  }
3404 
3405 */
3406 
3407 /* DISABLED
3408 
3409  template<>
3410  void DataSerializer::Serialize<TestStackParameters>(const TestStackParameters& data)
3411  {
3412  *this << data.TestId;
3413  *this << data.Iteration;
3414  *this << data.Input;
3415  }
3416 
3417 */
3418 
3419 /* DISABLED
3420 
3421  template<>
3422  void DataSerializer::Serialize<TestStackRequest>(const TestStackRequest& data)
3423  {
3424  *this << data.TypeId;
3425  *this << data.Header;
3426  *this << data.Parameters;
3427  }
3428 
3429 */
3430 
3431 /* DISABLED
3432 
3433  template<>
3434  void DataSerializer::Serialize<TestStackResult>(const TestStackResult& data)
3435  {
3436  *this << data.Output;
3437  }
3438 
3439 */
3440 
3441 /* DISABLED
3442 
3443  template<>
3444  void DataSerializer::Serialize<TestStackResponse>(const TestStackResponse& data)
3445  {
3446  *this << data.TypeId;
3447  *this << data.Header;
3448  *this << data.Parameters;
3449  }
3450 
3451 */
3452 
3453 /* DISABLED
3454 
3455  template<>
3456  void DataSerializer::Serialize<TestStackExParameters>(const TestStackExParameters& data)
3457  {
3458  *this << data.TestId;
3459  *this << data.Iteration;
3460  *this << data.Input;
3461  }
3462 
3463 */
3464 
3465 /* DISABLED
3466 
3467  template<>
3468  void DataSerializer::Serialize<TestStackExRequest>(const TestStackExRequest& data)
3469  {
3470  *this << data.TypeId;
3471  *this << data.Header;
3472  *this << data.Parameters;
3473  }
3474 
3475 */
3476 
3477 /* DISABLED
3478 
3479  template<>
3480  void DataSerializer::Serialize<TestStackExResult>(const TestStackExResult& data)
3481  {
3482  *this << data.Output;
3483  }
3484 
3485 */
3486 
3487 /* DISABLED
3488 
3489  template<>
3490  void DataSerializer::Serialize<TestStackExResponse>(const TestStackExResponse& data)
3491  {
3492  *this << data.TypeId;
3493  *this << data.Header;
3494  *this << data.Parameters;
3495  }
3496 
3497 */
3498 
3499 /* DISABLED
3500 
3501  template<>
3502  void DataSerializer::Serialize<BuildInfo>(const BuildInfo& data)
3503  {
3504  *this << data.ProductUri;
3505  *this << data.ManufacturerName;
3506  *this << data.ProductName;
3507  *this << data.SoftwareVersion;
3508  *this << data.BuildNumber;
3509  *this << data.BuildDate;
3510  }
3511 
3512 */
3513 
3514 /* DISABLED
3515 
3516  template<>
3517  void DataSerializer::Serialize<RedundantServerDataType>(const RedundantServerDataType& data)
3518  {
3519  *this << data.ServerId;
3520  *this << data.ServiceLevel;
3521  *this << data.ServerState;
3522  }
3523 
3524 */
3525 
3526 /* DISABLED
3527 
3528  template<>
3529  void DataSerializer::Serialize<EndpointUrlListDataType>(const EndpointUrlListDataType& data)
3530  {
3531  SerializeContainer(*this, data.EndpointUrlList);
3532  }
3533 
3534 */
3535 
3536 /* DISABLED
3537 
3538  template<>
3539  void DataSerializer::Serialize<NetworkGroupDataType>(const NetworkGroupDataType& data)
3540  {
3541  *this << data.ServerUri;
3542  SerializeContainer(*this, data.NetworkPaths);
3543  }
3544 
3545 */
3546 
3547 /* DISABLED
3548 
3549  template<>
3550  void DataSerializer::Serialize<SamplingIntervalDiagnosticsDataType>(const SamplingIntervalDiagnosticsDataType& data)
3551  {
3552  *this << data.SamplingInterval;
3553  *this << data.MonitoredItemCount;
3554  *this << data.MaxMonitoredItemCount;
3555  *this << data.DisabledMonitoredItemCount;
3556  }
3557 
3558 */
3559 
3560 /* DISABLED
3561 
3562  template<>
3563  void DataSerializer::Serialize<ServerDiagnosticsSummaryDataType>(const ServerDiagnosticsSummaryDataType& data)
3564  {
3565  *this << data.ServerViewCount;
3566  *this << data.CurrentSessionCount;
3567  *this << data.CumulatedSessionCount;
3568  *this << data.SecurityRejectedSessionCount;
3569  *this << data.RejectedSessionCount;
3570  *this << data.SessionTimeoutCount;
3571  *this << data.SessionAbortCount;
3572  *this << data.CurrentSubscriptionCount;
3573  *this << data.CumulatedSubscriptionCount;
3574  *this << data.PublishingIntervalCount;
3575  *this << data.SecurityRejectedRequestsCount;
3576  *this << data.RejectedRequestsCount;
3577  }
3578 
3579 */
3580 
3581 /* DISABLED
3582 
3583  template<>
3584  void DataSerializer::Serialize<ServerStatusDataType>(const ServerStatusDataType& data)
3585  {
3586  *this << data.StartTime;
3587  *this << data.CurrentTime;
3588  *this << data.State;
3589  *this << data.BuildInfo;
3590  *this << data.SecondsTillShutdown;
3591  *this << data.ShutdownReason;
3592  }
3593 
3594 */
3595 
3596 /* DISABLED
3597 
3598  template<>
3599  void DataSerializer::Serialize<SessionSecurityDiagnosticsDataType>(const SessionSecurityDiagnosticsDataType& data)
3600  {
3601  *this << data.SessionId;
3602  *this << data.ClientUserIdOfSession;
3603  SerializeContainer(*this, data.ClientUserIdHistory);
3604  *this << data.AuthenticationMechanism;
3605  *this << data.Encoding;
3606  *this << data.TransportProtocol;
3607  *this << data.SecurityMode;
3608  *this << data.SecurityPolicyUri;
3609  *this << data.ClientCertificate;
3610  }
3611 
3612 */
3613 
3614 /* DISABLED
3615 
3616  template<>
3617  void DataSerializer::Serialize<ServiceCounterDataType>(const ServiceCounterDataType& data)
3618  {
3619  *this << data.TotalCount;
3620  *this << data.ErrorCount;
3621  }
3622 
3623 */
3624 
3625 /* DISABLED
3626 
3627  template<>
3628  void DataSerializer::Serialize<SessionDiagnosticsDataType>(const SessionDiagnosticsDataType& data)
3629  {
3630  *this << data.SessionId;
3631  *this << data.SessionName;
3632  *this << data.ClientDescription;
3633  *this << data.ServerUri;
3634  *this << data.EndpointUrl;
3635  SerializeContainer(*this, data.LocaleIds);
3636  *this << data.ActualSessionTimeout;
3637  *this << data.MaxResponseMessageSize;
3638  *this << data.ClientConnectionTime;
3639  *this << data.ClientLastContactTime;
3640  *this << data.CurrentSubscriptionsCount;
3641  *this << data.CurrentMonitoredItemsCount;
3642  *this << data.CurrentPublishRequestsInQueue;
3643  *this << data.TotalRequestCount;
3644  *this << data.UnauthorizedRequestCount;
3645  *this << data.ReadCount;
3646  *this << data.HistoryReadCount;
3647  *this << data.WriteCount;
3648  *this << data.HistoryUpdateCount;
3649  *this << data.CallCount;
3650  *this << data.CreateMonitoredItemsCount;
3651  *this << data.ModifyMonitoredItemsCount;
3652  *this << data.SetMonitoringModeCount;
3653  *this << data.SetTriggeringCount;
3654  *this << data.DeleteMonitoredItemsCount;
3655  *this << data.CreateSubscriptionCount;
3656  *this << data.ModifySubscriptionCount;
3657  *this << data.SetPublishingModeCount;
3658  *this << data.PublishCount;
3659  *this << data.RepublishCount;
3660  *this << data.TransferSubscriptionsCount;
3661  *this << data.DeleteSubscriptionsCount;
3662  *this << data.AddNodesCount;
3663  *this << data.AddReferencesCount;
3664  *this << data.DeleteNodesCount;
3665  *this << data.DeleteReferencesCount;
3666  *this << data.BrowseCount;
3667  *this << data.BrowseNextCount;
3668  *this << data.TranslateBrowsePathsToNodeIdsCount;
3669  *this << data.QueryFirstCount;
3670  *this << data.QueryNextCount;
3671  *this << data.RegisterNodesCount;
3672  *this << data.UnregisterNodesCount;
3673  }
3674 
3675 */
3676 
3677 /* DISABLED
3678 
3679  template<>
3680  void DataSerializer::Serialize<StatusResult>(const StatusResult& data)
3681  {
3682  *this << data.Status;
3683  *this << data.DiagnosticInfo;
3684  }
3685 
3686 */
3687 
3688 /* DISABLED
3689 
3690  template<>
3691  void DataSerializer::Serialize<SubscriptionDiagnosticsDataType>(const SubscriptionDiagnosticsDataType& data)
3692  {
3693  *this << data.SessionId;
3694  *this << data.SubscriptionId;
3695  *this << data.Priority;
3696  *this << data.PublishingInterval;
3697  *this << data.MaxKeepAliveCount;
3698  *this << data.MaxLifetimeCount;
3699  *this << data.MaxNotificationsPerPublish;
3700  *this << data.PublishingEnabled;
3701  *this << data.ModifyCount;
3702  *this << data.EnableCount;
3703  *this << data.DisableCount;
3704  *this << data.RepublishRequestCount;
3705  *this << data.RepublishMessageRequestCount;
3706  *this << data.RepublishMessageCount;
3707  *this << data.TransferRequestCount;
3708  *this << data.TransferredToAltClientCount;
3709  *this << data.TransferredToSameClientCount;
3710  *this << data.PublishRequestCount;
3711  *this << data.DataChangeNotificationsCount;
3712  *this << data.EventNotificationsCount;
3713  *this << data.NotificationsCount;
3714  *this << data.LatePublishRequestCount;
3715  *this << data.CurrentKeepAliveCount;
3716  *this << data.CurrentLifetimeCount;
3717  *this << data.UnacknowledgedMessageCount;
3718  *this << data.DiscardedMessageCount;
3719  *this << data.MonitoredItemCount;
3720  *this << data.DisabledMonitoredItemCount;
3721  *this << data.MonitoringQueueOverflowCount;
3722  *this << data.NextSequenceNumber;
3723  *this << data.EventQueueOverFlowCount;
3724  }
3725 
3726 */
3727 
3728 /* DISABLED
3729 
3730  template<>
3731  void DataSerializer::Serialize<ModelChangeStructureDataType>(const ModelChangeStructureDataType& data)
3732  {
3733  *this << data.Affected;
3734  *this << data.AffectedType;
3735  *this << data.Verb;
3736  }
3737 
3738 */
3739 
3740 /* DISABLED
3741 
3742  template<>
3743  void DataSerializer::Serialize<SemanticChangeStructureDataType>(const SemanticChangeStructureDataType& data)
3744  {
3745  *this << data.Affected;
3746  *this << data.AffectedType;
3747  }
3748 
3749 */
3750 
3751 /* DISABLED
3752 
3753  template<>
3754  void DataSerializer::Serialize<Range>(const Range& data)
3755  {
3756  *this << data.Low;
3757  *this << data.High;
3758  }
3759 
3760 */
3761 
3762 /* DISABLED
3763 
3764  template<>
3765  void DataSerializer::Serialize<EUInformation>(const EUInformation& data)
3766  {
3767  *this << data.NamespaceUri;
3768  *this << data.UnitId;
3769  *this << data.DisplayName;
3770  *this << data.Description;
3771  }
3772 
3773 */
3774 
3775 /* DISABLED
3776 
3777  template<>
3778  void DataSerializer::Serialize<ComplexNumberType>(const ComplexNumberType& data)
3779  {
3780  *this << data.Real;
3781  *this << data.Imaginary;
3782  }
3783 
3784 */
3785 
3786 /* DISABLED
3787 
3788  template<>
3789  void DataSerializer::Serialize<DoubleComplexNumberType>(const DoubleComplexNumberType& data)
3790  {
3791  *this << data.Real;
3792  *this << data.Imaginary;
3793  }
3794 
3795 */
3796 
3797 /* DISABLED
3798 
3799  template<>
3800  void DataSerializer::Serialize<AxisInformation>(const AxisInformation& data)
3801  {
3802  *this << data.EngineeringUnits;
3803  *this << data.EURange;
3804  *this << data.Title;
3805  *this << data.AxisScaleType;
3806  SerializeContainer(*this, data.AxisSteps);
3807  }
3808 
3809 */
3810 
3811 /* DISABLED
3812 
3813  template<>
3814  void DataSerializer::Serialize<XVType>(const XVType& data)
3815  {
3816  *this << data.X;
3817  *this << data.Value;
3818  }
3819 
3820 */
3821 
3822 /* DISABLED
3823 
3824  template<>
3825  void DataSerializer::Serialize<ProgramDiagnosticDataType>(const ProgramDiagnosticDataType& data)
3826  {
3827  *this << data.CreateSessionId;
3828  *this << data.CreateClientName;
3829  *this << data.InvocationCreationTime;
3830  *this << data.LastTransitionTime;
3831  *this << data.LastMethodCall;
3832  *this << data.LastMethodSessionId;
3833  SerializeContainer(*this, data.LastMethodInputArguments);
3834  SerializeContainer(*this, data.LastMethodOutputArguments);
3835  *this << data.LastMethodCallTime;
3836  *this << data.LastMethodReturnStatus;
3837  }
3838 
3839 */
3840 
3841 template<>
3842 void DataSerializer::Serialize<Annotation>(const Annotation & data)
3843 {
3844  *this << data.Message;
3845  *this << data.UserName;
3846  *this << data.AnnotationTime;
3847 }
3848 
3849 
3850 }
3851 
3852 } // namespace
3853 
OpcUa::SerializeContainer
void SerializeContainer(Stream &out, const Container &c, uint32_t emptySizeValue=~uint32_t())
Definition: binary_serialization.h:21
OpcUa::ModelChangeStructureVerbMask
ModelChangeStructureVerbMask
Definition: enums.h:339
OpcUa::AttributeWriteMask
AttributeWriteMask
Definition: enums.h:142
OpcUa::PerformUpdateType
PerformUpdateType
Definition: enums.h:259
OpcUa::DeadbandType
DeadbandType
Definition: enums.h:290
OpcUa::ServerState
ServerState
Definition: enums.h:324
OpcUa::OpenFileMode
OpenFileMode
Definition: enums.h:27
OpcUa::SecurityTokenRequestType
SecurityTokenRequestType
Definition: enums.h:92
OpcUa::ExceptionDeviationFormat
ExceptionDeviationFormat
Definition: enums.h:361
OpcUa::TimestampsToReturn
TimestampsToReturn
Definition: enums.h:237
OpcUa::EnumeratedTestType
EnumeratedTestType
Definition: enums.h:301
OpcUa::BrowseDirection
BrowseDirection
Definition: enums.h:173
OpcUa::HistoryUpdateType
HistoryUpdateType
Definition: enums.h:248
OpcUa::MessageSecurityMode
MessageSecurityMode
Definition: enums.h:68
OpcUa
OPC UA Address space part. GNU LGPL.
Definition: ua/client/addon.h:18
testing::gmock_generated_actions_test::Binary
const char * Binary(const char *input, short n)
Definition: gmock-generated-actions_test.cc:95
OpcUa::RedundancySupport
RedundancySupport
Definition: enums.h:311
OpcUa::MonitoringMode
MonitoringMode
Definition: enums.h:270
OpcUa::UserTokenType
UserTokenType
Definition: enums.h:80
OpcUa::NodeAttributesMask
NodeAttributesMask
Definition: enums.h:102
OpcUa::BrowseResultMask
BrowseResultMask
Definition: enums.h:184
OpcUa::NodeClass
NodeClass
Definition: enums.h:39
OpcUa::FilterOperator
FilterOperator
Definition: enums.h:212
OpcUa::DataChangeTrigger
DataChangeTrigger
Definition: enums.h:280
OpcUa::ComplianceLevel
ComplianceLevel
Definition: enums.h:201
binary_serialization.h
OpcUa::AxisScaleEnumeration
AxisScaleEnumeration
Definition: enums.h:351
OpcUa::ApplicationType
ApplicationType
Definition: enums.h:56

ros_opcua_impl_freeopcua
Author(s): Denis Štogl
autogenerated on Tue Jan 19 2021 03:12:07