ros_opcua_impl_freeopcua: rawsize

Go to the documentation of this file.
00001 // DO NOT EDIT THIS FILE!
00002 // It is automatically generated from opcfoundation.org schemas.
00003 //
00004 
00014 
00015 #include "binary_serialization.h"
00016 #include <opc/ua/protocol/protocol.h>
00017 
00018 #include <opc/ua/protocol/binary/stream.h>
00019 
00020 namespace OpcUa
00021 {
00022     namespace Binary
00023     {
00024 
00025     template<>
00026     std::size_t RawSize<OpenFileMode>(const OpenFileMode& data)
00027     {
00028         return sizeof(uint32_t);
00029     }
00030 
00031 
00032     template<>
00033     std::size_t RawSize<NodeClass>(const NodeClass& data)
00034     {
00035         return sizeof(uint32_t);
00036     }
00037 
00038 
00039     template<>
00040     std::size_t RawSize<ApplicationType>(const ApplicationType& data)
00041     {
00042         return sizeof(uint32_t);
00043     }
00044 
00045 
00046     template<>
00047     std::size_t RawSize<MessageSecurityMode>(const MessageSecurityMode& data)
00048     {
00049         return sizeof(uint32_t);
00050     }
00051 
00052 
00053     template<>
00054     std::size_t RawSize<UserTokenType>(const UserTokenType& data)
00055     {
00056         return sizeof(uint32_t);
00057     }
00058 
00059 
00060     template<>
00061     std::size_t RawSize<SecurityTokenRequestType>(const SecurityTokenRequestType& data)
00062     {
00063         return sizeof(uint32_t);
00064     }
00065 
00066 
00067     template<>
00068     std::size_t RawSize<NodeAttributesMask>(const NodeAttributesMask& data)
00069     {
00070         return sizeof(uint32_t);
00071     }
00072 
00073 
00074     template<>
00075     std::size_t RawSize<AttributeWriteMask>(const AttributeWriteMask& data)
00076     {
00077         return sizeof(uint32_t);
00078     }
00079 
00080 
00081     template<>
00082     std::size_t RawSize<BrowseDirection>(const BrowseDirection& data)
00083     {
00084         return sizeof(uint32_t);
00085     }
00086 
00087 
00088     template<>
00089     std::size_t RawSize<BrowseResultMask>(const BrowseResultMask& data)
00090     {
00091         return sizeof(uint32_t);
00092     }
00093 
00094 
00095     template<>
00096     std::size_t RawSize<ComplianceLevel>(const ComplianceLevel& data)
00097     {
00098         return sizeof(uint32_t);
00099     }
00100 
00101 
00102     template<>
00103     std::size_t RawSize<FilterOperator>(const FilterOperator& data)
00104     {
00105         return sizeof(uint32_t);
00106     }
00107 
00108 
00109     template<>
00110     std::size_t RawSize<TimestampsToReturn>(const TimestampsToReturn& data)
00111     {
00112         return sizeof(uint32_t);
00113     }
00114 
00115 
00116     template<>
00117     std::size_t RawSize<HistoryUpdateType>(const HistoryUpdateType& data)
00118     {
00119         return sizeof(uint32_t);
00120     }
00121 
00122 
00123     template<>
00124     std::size_t RawSize<PerformUpdateType>(const PerformUpdateType& data)
00125     {
00126         return sizeof(uint32_t);
00127     }
00128 
00129 
00130     template<>
00131     std::size_t RawSize<MonitoringMode>(const MonitoringMode& data)
00132     {
00133         return sizeof(uint32_t);
00134     }
00135 
00136 
00137     template<>
00138     std::size_t RawSize<DataChangeTrigger>(const DataChangeTrigger& data)
00139     {
00140         return sizeof(uint32_t);
00141     }
00142 
00143 
00144     template<>
00145     std::size_t RawSize<DeadbandType>(const DeadbandType& data)
00146     {
00147         return sizeof(uint32_t);
00148     }
00149 
00150 
00151     template<>
00152     std::size_t RawSize<EnumeratedTestType>(const EnumeratedTestType& data)
00153     {
00154         return sizeof(uint32_t);
00155     }
00156 
00157 
00158     template<>
00159     std::size_t RawSize<RedundancySupport>(const RedundancySupport& data)
00160     {
00161         return sizeof(uint32_t);
00162     }
00163 
00164 
00165     template<>
00166     std::size_t RawSize<ServerState>(const ServerState& data)
00167     {
00168         return sizeof(uint32_t);
00169     }
00170 
00171 
00172     template<>
00173     std::size_t RawSize<ModelChangeStructureVerbMask>(const ModelChangeStructureVerbMask& data)
00174     {
00175         return sizeof(uint32_t);
00176     }
00177 
00178 
00179     template<>
00180     std::size_t RawSize<AxisScaleEnumeration>(const AxisScaleEnumeration& data)
00181     {
00182         return sizeof(uint32_t);
00183     }
00184 
00185 
00186     template<>
00187     std::size_t RawSize<ExceptionDeviationFormat>(const ExceptionDeviationFormat& data)
00188     {
00189         return sizeof(uint32_t);
00190     }
00191 
00192 
00193     template<>
00194     std::size_t RawSize<XmlElement>(const XmlElement& data)
00195     {
00196         size_t size = 0;
00197         size += RawSize(data.Length);
00198         size += RawSizeContainer(data.Value);
00199         return size;
00200     }
00201 
00202 
00203 /* DISABLED
00204 
00205     template<>
00206     std::size_t RawSize<TwoByteNodeId>(const TwoByteNodeId& data)
00207     {
00208         size_t size = 0;
00209         size += RawSize(data.Identifier);
00210         return size;
00211     }
00212 
00213 */
00214 
00215 /* DISABLED
00216 
00217     template<>
00218     std::size_t RawSize<FourByteNodeId>(const FourByteNodeId& data)
00219     {
00220         size_t size = 0;
00221         size += RawSize(data.NamespaceIndex);
00222         size += RawSize(data.Identifier);
00223         return size;
00224     }
00225 
00226 */
00227 
00228 /* DISABLED
00229 
00230     template<>
00231     std::size_t RawSize<NumericNodeId>(const NumericNodeId& data)
00232     {
00233         size_t size = 0;
00234         size += RawSize(data.NamespaceIndex);
00235         size += RawSize(data.Identifier);
00236         return size;
00237     }
00238 
00239 */
00240 
00241 /* DISABLED
00242 
00243     template<>
00244     std::size_t RawSize<StringNodeId>(const StringNodeId& data)
00245     {
00246         size_t size = 0;
00247         size += RawSize(data.NamespaceIndex);
00248         size += RawSize(data.Identifier);
00249         return size;
00250     }
00251 
00252 */
00253 
00254 /* DISABLED
00255 
00256     template<>
00257     std::size_t RawSize<GuidNodeId>(const GuidNodeId& data)
00258     {
00259         size_t size = 0;
00260         size += RawSize(data.NamespaceIndex);
00261         size += RawSize(data.Identifier);
00262         return size;
00263     }
00264 
00265 */
00266 
00267 /* DISABLED
00268 
00269     template<>
00270     std::size_t RawSize<ByteStringNodeId>(const ByteStringNodeId& data)
00271     {
00272         size_t size = 0;
00273         size += RawSize(data.NamespaceIndex);
00274         size += RawSize(data.Identifier);
00275         return size;
00276     }
00277 
00278 */
00279 
00280 /* DISABLED
00281 
00282     template<>
00283     std::size_t RawSize<NodeId>(const NodeId& data)
00284     {
00285         size_t size = 0;
00286         size += RawSize(data.NodeIdType);
00287         if ((data.NodeIdType) & (1<<(0))) size += RawSize(data.TwoByte);
00288         if ((data.NodeIdType) & (1<<(1))) size += RawSize(data.FourByte);
00289         if ((data.NodeIdType) & (1<<(2))) size += RawSize(data.Numeric);
00290         if ((data.NodeIdType) & (1<<(3))) size += RawSize(data.String);
00291         if ((data.NodeIdType) & (1<<(4))) size += RawSize(data.Guid);
00292         if ((data.NodeIdType) & (1<<(5))) size += RawSize(data.ByteString);
00293         return size;
00294     }
00295 
00296 */
00297 
00298     template<>
00299     std::size_t RawSize<ExtensionObject>(const ExtensionObject& data)
00300     {
00301         size_t size = 0;
00302         size += RawSize(data.TypeId);
00303         size += RawSize(data.Encoding);
00304         if ((data.Encoding) & (1<<(0))) size += RawSize(data.Body);
00305         return size;
00306     }
00307 
00308 
00309 /* DISABLED
00310 
00311     template<>
00312     std::size_t RawSize<ExpandedNodeId>(const ExpandedNodeId& data)
00313     {
00314         size_t size = 0;
00315         size += RawSize(data.NodeIdType);
00316         if ((data.NodeIdType) & (1<<(0))) size += RawSize(data.TwoByte);
00317         if ((data.NodeIdType) & (1<<(1))) size += RawSize(data.FourByte);
00318         if ((data.NodeIdType) & (1<<(2))) size += RawSize(data.Numeric);
00319         if ((data.NodeIdType) & (1<<(3))) size += RawSize(data.String);
00320         if ((data.NodeIdType) & (1<<(4))) size += RawSize(data.Guid);
00321         if ((data.NodeIdType) & (1<<(5))) size += RawSize(data.ByteString);
00322         if ((data.NodeIdType) & (1<<(7))) size += RawSize(data.NamespaceURI);
00323         if ((data.NodeIdType) & (1<<(6))) size += RawSize(data.ServerIndex);
00324         return size;
00325     }
00326 
00327 */
00328 
00329 /* DISABLED
00330 
00331     template<>
00332     std::size_t RawSize<DiagnosticInfo>(const DiagnosticInfo& data)
00333     {
00334         size_t size = 0;
00335         size += RawSize(data.Encoding);
00336         if ((data.Encoding) & (1<<(0))) size += RawSize(data.SymbolicId);
00337         if ((data.Encoding) & (1<<(1))) size += RawSize(data.NamespaceURI);
00338         if ((data.Encoding) & (1<<(2))) size += RawSize(data.LocalizedText);
00339         if ((data.Encoding) & (1<<(4))) size += RawSize(data.AdditionalInfo);
00340         if ((data.Encoding) & (1<<(5))) size += RawSize(data.InnerStatusCode);
00341         if ((data.Encoding) & (1<<(6))) size += RawSize(data.InnerDiagnosticInfo);
00342         return size;
00343     }
00344 
00345 */
00346 
00347 /* DISABLED
00348 
00349     template<>
00350     std::size_t RawSize<QualifiedName>(const QualifiedName& data)
00351     {
00352         size_t size = 0;
00353         size += RawSize(data.NamespaceIndex);
00354         size += RawSize(data.Name);
00355         return size;
00356     }
00357 
00358 */
00359 
00360 /* DISABLED
00361 
00362     template<>
00363     std::size_t RawSize<LocalizedText>(const LocalizedText& data)
00364     {
00365         size_t size = 0;
00366         size += RawSize(data.Encoding);
00367         if ((data.Encoding) & (1<<(0))) size += RawSize(data.Locale);
00368         if ((data.Encoding) & (1<<(1))) size += RawSize(data.Text);
00369         return size;
00370     }
00371 
00372 */
00373 
00374 /* DISABLED
00375 
00376     template<>
00377     std::size_t RawSize<Variant>(const Variant& data)
00378     {
00379         size_t size = 0;
00380         size += RawSize(data.Encoding);
00381         if ((data.Encoding) & (1<<(7))) size += RawSize(data.ArrayLength);
00382         if ((data.VariantType) & (1<<(1))) size += RawSizeContainer(data.Boolean);
00383         if ((data.VariantType) & (1<<(2))) size += RawSizeContainer(data.SByte);
00384         if ((data.VariantType) & (1<<(3))) size += RawSizeContainer(data.Byte);
00385         if ((data.VariantType) & (1<<(4))) size += RawSizeContainer(data.Int16);
00386         if ((data.VariantType) & (1<<(5))) size += RawSizeContainer(data.UInt16);
00387         if ((data.VariantType) & (1<<(6))) size += RawSizeContainer(data.Int32);
00388         if ((data.VariantType) & (1<<(7))) size += RawSizeContainer(data.UInt32);
00389         if ((data.VariantType) & (1<<(8))) size += RawSizeContainer(data.Int64);
00390         if ((data.VariantType) & (1<<(9))) size += RawSizeContainer(data.UInt64);
00391         if ((data.VariantType) & (1<<(10))) size += RawSizeContainer(data.Float);
00392         if ((data.VariantType) & (1<<(11))) size += RawSizeContainer(data.Double);
00393         if ((data.VariantType) & (1<<(12))) size += RawSizeContainer(data.String);
00394         if ((data.VariantType) & (1<<(13))) size += RawSizeContainer(data.DateTime);
00395         if ((data.VariantType) & (1<<(14))) size += RawSizeContainer(data.Guid);
00396         if ((data.VariantType) & (1<<(15))) size += RawSizeContainer(data.ByteString);
00397         if ((data.VariantType) & (1<<(16))) size += RawSizeContainer(data.XmlElement);
00398         if ((data.VariantType) & (1<<(17))) size += RawSizeContainer(data.NodeId);
00399         if ((data.VariantType) & (1<<(18))) size += RawSizeContainer(data.ExpandedNodeId);
00400         if ((data.VariantType) & (1<<(19))) size += RawSizeContainer(data.Status);
00401         if ((data.VariantType) & (1<<(20))) size += RawSizeContainer(data.DiagnosticInfo);
00402         if ((data.VariantType) & (1<<(21))) size += RawSizeContainer(data.QualifiedName);
00403         if ((data.VariantType) & (1<<(22))) size += RawSizeContainer(data.LocalizedText);
00404         if ((data.VariantType) & (1<<(23))) size += RawSizeContainer(data.ExtensionObject);
00405         if ((data.VariantType) & (1<<(24))) size += RawSizeContainer(data.DataValue);
00406         if ((data.VariantType) & (1<<(25))) size += RawSizeContainer(data.Variant);
00407         return size;
00408     }
00409 
00410 */
00411 
00412 /* DISABLED
00413 
00414     template<>
00415     std::size_t RawSize<DataValue>(const DataValue& data)
00416     {
00417         size_t size = 0;
00418         size += RawSize(data.Encoding);
00419         if ((data.Encoding) & (1<<(0))) size += RawSize(data.Value);
00420         if ((data.Encoding) & (1<<(1))) size += RawSize(data.Status);
00421         if ((data.Encoding) & (1<<(2))) size += RawSize(data.SourceTimestamp);
00422         if ((data.Encoding) & (1<<(3))) size += RawSize(data.SourcePicoseconds);
00423         if ((data.Encoding) & (1<<(4))) size += RawSize(data.ServerTimestamp);
00424         if ((data.Encoding) & (1<<(5))) size += RawSize(data.ServerPicoseconds);
00425         return size;
00426     }
00427 
00428 */
00429 
00430 /* DISABLED
00431 
00432     template<>
00433     std::size_t RawSize<ReferenceNode>(const ReferenceNode& data)
00434     {
00435         size_t size = 0;
00436         size += RawSize(data.ReferenceTypeId);
00437         size += RawSize(data.IsInverse);
00438         size += RawSize(data.TargetId);
00439         return size;
00440     }
00441 
00442 */
00443 
00444 /* DISABLED
00445 
00446     template<>
00447     std::size_t RawSize<Node>(const Node& data)
00448     {
00449         size_t size = 0;
00450         size += RawSize(data.NodeId);
00451         size += RawSize(data.NodeClass);
00452         size += RawSize(data.BrowseName);
00453         size += RawSize(data.DisplayName);
00454         size += RawSize(data.Description);
00455         size += RawSize(data.WriteMask);
00456         size += RawSize(data.UserWriteMask);
00457         size += RawSizeContainer(data.References);
00458         return size;
00459     }
00460 
00461 */
00462 
00463 /* DISABLED
00464 
00465     template<>
00466     std::size_t RawSize<InstanceNode>(const InstanceNode& data)
00467     {
00468         size_t size = 0;
00469         size += RawSize(data.NodeId);
00470         size += RawSize(data.NodeClass);
00471         size += RawSize(data.BrowseName);
00472         size += RawSize(data.DisplayName);
00473         size += RawSize(data.Description);
00474         size += RawSize(data.WriteMask);
00475         size += RawSize(data.UserWriteMask);
00476         size += RawSizeContainer(data.References);
00477         return size;
00478     }
00479 
00480 */
00481 
00482 /* DISABLED
00483 
00484     template<>
00485     std::size_t RawSize<TypeNode>(const TypeNode& data)
00486     {
00487         size_t size = 0;
00488         size += RawSize(data.NodeId);
00489         size += RawSize(data.NodeClass);
00490         size += RawSize(data.BrowseName);
00491         size += RawSize(data.DisplayName);
00492         size += RawSize(data.Description);
00493         size += RawSize(data.WriteMask);
00494         size += RawSize(data.UserWriteMask);
00495         size += RawSizeContainer(data.References);
00496         return size;
00497     }
00498 
00499 */
00500 
00501 /* DISABLED
00502 
00503     template<>
00504     std::size_t RawSize<ObjectNode>(const ObjectNode& data)
00505     {
00506         size_t size = 0;
00507         size += RawSize(data.NodeId);
00508         size += RawSize(data.NodeClass);
00509         size += RawSize(data.BrowseName);
00510         size += RawSize(data.DisplayName);
00511         size += RawSize(data.Description);
00512         size += RawSize(data.WriteMask);
00513         size += RawSize(data.UserWriteMask);
00514         size += RawSizeContainer(data.References);
00515         size += RawSize(data.EventNotifier);
00516         return size;
00517     }
00518 
00519 */
00520 
00521 /* DISABLED
00522 
00523     template<>
00524     std::size_t RawSize<ObjectTypeNode>(const ObjectTypeNode& data)
00525     {
00526         size_t size = 0;
00527         size += RawSize(data.NodeId);
00528         size += RawSize(data.NodeClass);
00529         size += RawSize(data.BrowseName);
00530         size += RawSize(data.DisplayName);
00531         size += RawSize(data.Description);
00532         size += RawSize(data.WriteMask);
00533         size += RawSize(data.UserWriteMask);
00534         size += RawSizeContainer(data.References);
00535         size += RawSize(data.IsAbstract);
00536         return size;
00537     }
00538 
00539 */
00540 
00541 /* DISABLED
00542 
00543     template<>
00544     std::size_t RawSize<VariableNode>(const VariableNode& data)
00545     {
00546         size_t size = 0;
00547         size += RawSize(data.NodeId);
00548         size += RawSize(data.NodeClass);
00549         size += RawSize(data.BrowseName);
00550         size += RawSize(data.DisplayName);
00551         size += RawSize(data.Description);
00552         size += RawSize(data.WriteMask);
00553         size += RawSize(data.UserWriteMask);
00554         size += RawSizeContainer(data.References);
00555         size += RawSize(data.Value);
00556         size += RawSize(data.DataType);
00557         size += RawSize(data.ValueRank);
00558         size += RawSizeContainer(data.ArrayDimensions);
00559         size += RawSize(data.AccessLevel);
00560         size += RawSize(data.UserAccessLevel);
00561         size += RawSize(data.MinimumSamplingInterval);
00562         size += RawSize(data.Historizing);
00563         return size;
00564     }
00565 
00566 */
00567 
00568 /* DISABLED
00569 
00570     template<>
00571     std::size_t RawSize<VariableTypeNode>(const VariableTypeNode& data)
00572     {
00573         size_t size = 0;
00574         size += RawSize(data.NodeId);
00575         size += RawSize(data.NodeClass);
00576         size += RawSize(data.BrowseName);
00577         size += RawSize(data.DisplayName);
00578         size += RawSize(data.Description);
00579         size += RawSize(data.WriteMask);
00580         size += RawSize(data.UserWriteMask);
00581         size += RawSizeContainer(data.References);
00582         size += RawSize(data.Value);
00583         size += RawSize(data.DataType);
00584         size += RawSize(data.ValueRank);
00585         size += RawSizeContainer(data.ArrayDimensions);
00586         size += RawSize(data.IsAbstract);
00587         return size;
00588     }
00589 
00590 */
00591 
00592 /* DISABLED
00593 
00594     template<>
00595     std::size_t RawSize<ReferenceTypeNode>(const ReferenceTypeNode& data)
00596     {
00597         size_t size = 0;
00598         size += RawSize(data.NodeId);
00599         size += RawSize(data.NodeClass);
00600         size += RawSize(data.BrowseName);
00601         size += RawSize(data.DisplayName);
00602         size += RawSize(data.Description);
00603         size += RawSize(data.WriteMask);
00604         size += RawSize(data.UserWriteMask);
00605         size += RawSizeContainer(data.References);
00606         size += RawSize(data.IsAbstract);
00607         size += RawSize(data.Symmetric);
00608         size += RawSize(data.InverseName);
00609         return size;
00610     }
00611 
00612 */
00613 
00614 /* DISABLED
00615 
00616     template<>
00617     std::size_t RawSize<MethodNode>(const MethodNode& data)
00618     {
00619         size_t size = 0;
00620         size += RawSize(data.NodeId);
00621         size += RawSize(data.NodeClass);
00622         size += RawSize(data.BrowseName);
00623         size += RawSize(data.DisplayName);
00624         size += RawSize(data.Description);
00625         size += RawSize(data.WriteMask);
00626         size += RawSize(data.UserWriteMask);
00627         size += RawSizeContainer(data.References);
00628         size += RawSize(data.Executable);
00629         size += RawSize(data.UserExecutable);
00630         return size;
00631     }
00632 
00633 */
00634 
00635 /* DISABLED
00636 
00637     template<>
00638     std::size_t RawSize<ViewNode>(const ViewNode& data)
00639     {
00640         size_t size = 0;
00641         size += RawSize(data.NodeId);
00642         size += RawSize(data.NodeClass);
00643         size += RawSize(data.BrowseName);
00644         size += RawSize(data.DisplayName);
00645         size += RawSize(data.Description);
00646         size += RawSize(data.WriteMask);
00647         size += RawSize(data.UserWriteMask);
00648         size += RawSizeContainer(data.References);
00649         size += RawSize(data.ContainsNoLoops);
00650         size += RawSize(data.EventNotifier);
00651         return size;
00652     }
00653 
00654 */
00655 
00656 /* DISABLED
00657 
00658     template<>
00659     std::size_t RawSize<DataTypeNode>(const DataTypeNode& data)
00660     {
00661         size_t size = 0;
00662         size += RawSize(data.NodeId);
00663         size += RawSize(data.NodeClass);
00664         size += RawSize(data.BrowseName);
00665         size += RawSize(data.DisplayName);
00666         size += RawSize(data.Description);
00667         size += RawSize(data.WriteMask);
00668         size += RawSize(data.UserWriteMask);
00669         size += RawSizeContainer(data.References);
00670         size += RawSize(data.IsAbstract);
00671         return size;
00672     }
00673 
00674 */
00675 
00676 /* DISABLED
00677 
00678     template<>
00679     std::size_t RawSize<Argument>(const Argument& data)
00680     {
00681         size_t size = 0;
00682         size += RawSize(data.Name);
00683         size += RawSize(data.DataType);
00684         size += RawSize(data.ValueRank);
00685         size += RawSizeContainer(data.ArrayDimensions);
00686         size += RawSize(data.Description);
00687         return size;
00688     }
00689 
00690 */
00691 
00692 /* DISABLED
00693 
00694     template<>
00695     std::size_t RawSize<EnumValueType>(const EnumValueType& data)
00696     {
00697         size_t size = 0;
00698         size += RawSize(data.Value);
00699         size += RawSize(data.DisplayName);
00700         size += RawSize(data.Description);
00701         return size;
00702     }
00703 
00704 */
00705 
00706 /* DISABLED
00707 
00708     template<>
00709     std::size_t RawSize<TimeZoneDataType>(const TimeZoneDataType& data)
00710     {
00711         size_t size = 0;
00712         size += RawSize(data.Offset);
00713         size += RawSize(data.DaylightSavingInOffset);
00714         return size;
00715     }
00716 
00717 */
00718 
00719     template<>
00720     std::size_t RawSize<ApplicationDescription>(const ApplicationDescription& data)
00721     {
00722         size_t size = 0;
00723         size += RawSize(data.ApplicationUri);
00724         size += RawSize(data.ProductUri);
00725         size += RawSize(data.ApplicationName);
00726         size += RawSize(data.ApplicationType);
00727         size += RawSize(data.GatewayServerUri);
00728         size += RawSize(data.DiscoveryProfileUri);
00729         size += RawSizeContainer(data.DiscoveryUrls);
00730         return size;
00731     }
00732 
00733 
00734 /* DISABLED
00735 
00736     template<>
00737     std::size_t RawSize<RequestHeader>(const RequestHeader& data)
00738     {
00739         size_t size = 0;
00740         size += RawSize(data.AuthenticationToken);
00741         size += RawSize(data.Timestamp);
00742         size += RawSize(data.RequestHandle);
00743         size += RawSize(data.ReturnDiagnostics);
00744         size += RawSize(data.AuditEntryId);
00745         size += RawSize(data.TimeoutHint);
00746         size += RawSize(data.AdditionalHeader);
00747         return size;
00748     }
00749 
00750 */
00751 
00752 /* DISABLED
00753 
00754     template<>
00755     std::size_t RawSize<ResponseHeader>(const ResponseHeader& data)
00756     {
00757         size_t size = 0;
00758         size += RawSize(data.Timestamp);
00759         size += RawSize(data.RequestHandle);
00760         size += RawSize(data.ServiceResult);
00761         size += RawSize(data.ServiceDiagnostics);
00762         size += RawSizeContainer(data.StringTable);
00763         size += RawSize(data.AdditionalHeader);
00764         return size;
00765     }
00766 
00767 */
00768 
00769 /* DISABLED
00770 
00771     template<>
00772     std::size_t RawSize<ServiceFault>(const ServiceFault& data)
00773     {
00774         size_t size = 0;
00775         size += RawSize(data.TypeId);
00776         size += RawSize(data.Header);
00777         return size;
00778     }
00779 
00780 */
00781 
00782 /* DISABLED
00783 
00784     template<>
00785     std::size_t RawSize<FindServersParameters>(const FindServersParameters& data)
00786     {
00787         size_t size = 0;
00788         size += RawSize(data.EndpointUrl);
00789         size += RawSizeContainer(data.LocaleIds);
00790         size += RawSizeContainer(data.ServerUris);
00791         return size;
00792     }
00793 
00794 */
00795 
00796 /* DISABLED
00797 
00798     template<>
00799     std::size_t RawSize<FindServersRequest>(const FindServersRequest& data)
00800     {
00801         size_t size = 0;
00802         size += RawSize(data.TypeId);
00803         size += RawSize(data.Header);
00804         size += RawSize(data.Parameters);
00805         return size;
00806     }
00807 
00808 */
00809 
00810 /* DISABLED
00811 
00812     template<>
00813     std::size_t RawSize<FindServersResult>(const FindServersResult& data)
00814     {
00815         size_t size = 0;
00816         size += RawSizeContainer(data.Servers);
00817         return size;
00818     }
00819 
00820 */
00821 
00822 /* DISABLED
00823 
00824     template<>
00825     std::size_t RawSize<FindServersResponse>(const FindServersResponse& data)
00826     {
00827         size_t size = 0;
00828         size += RawSize(data.TypeId);
00829         size += RawSize(data.Header);
00830         size += RawSize(data.Parameters);
00831         return size;
00832     }
00833 
00834 */
00835 
00836     template<>
00837     std::size_t RawSize<UserTokenPolicy>(const UserTokenPolicy& data)
00838     {
00839         size_t size = 0;
00840         size += RawSize(data.PolicyId);
00841         size += RawSize(data.TokenType);
00842         size += RawSize(data.IssuedTokenType);
00843         size += RawSize(data.IssuerEndpointUrl);
00844         size += RawSize(data.SecurityPolicyUri);
00845         return size;
00846     }
00847 
00848 
00849     template<>
00850     std::size_t RawSize<EndpointDescription>(const EndpointDescription& data)
00851     {
00852         size_t size = 0;
00853         size += RawSize(data.EndpointUrl);
00854         size += RawSize(data.Server);
00855         size += RawSize(data.ServerCertificate);
00856         size += RawSize(data.SecurityMode);
00857         size += RawSize(data.SecurityPolicyUri);
00858         size += RawSizeContainer(data.UserIdentityTokens);
00859         size += RawSize(data.TransportProfileUri);
00860         size += RawSize(data.SecurityLevel);
00861         return size;
00862     }
00863 
00864 
00865     template<>
00866     std::size_t RawSize<GetEndpointsParameters>(const GetEndpointsParameters& data)
00867     {
00868         size_t size = 0;
00869         size += RawSize(data.EndpointUrl);
00870         size += RawSizeContainer(data.LocaleIds);
00871         size += RawSizeContainer(data.ProfileUris);
00872         return size;
00873     }
00874 
00875 
00876     template<>
00877     std::size_t RawSize<GetEndpointsRequest>(const GetEndpointsRequest& data)
00878     {
00879         size_t size = 0;
00880         size += RawSize(data.TypeId);
00881         size += RawSize(data.Header);
00882         size += RawSize(data.Parameters);
00883         return size;
00884     }
00885 
00886 
00887     template<>
00888     std::size_t RawSize<GetEndpointsResponse>(const GetEndpointsResponse& data)
00889     {
00890         size_t size = 0;
00891         size += RawSize(data.TypeId);
00892         size += RawSize(data.Header);
00893         size += RawSizeContainer(data.Endpoints);
00894         return size;
00895     }
00896 
00897 
00898 /* DISABLED
00899 
00900     template<>
00901     std::size_t RawSize<RegisteredServer>(const RegisteredServer& data)
00902     {
00903         size_t size = 0;
00904         size += RawSize(data.ServerUri);
00905         size += RawSize(data.ProductUri);
00906         size += RawSizeContainer(data.ServerNames);
00907         size += RawSize(data.ServerType);
00908         size += RawSize(data.GatewayServerUri);
00909         size += RawSizeContainer(data.DiscoveryUrls);
00910         size += RawSize(data.SemaphoreFilePath);
00911         size += RawSize(data.IsOnline);
00912         return size;
00913     }
00914 
00915 */
00916 
00917 /* DISABLED
00918 
00919     template<>
00920     std::size_t RawSize<RegisterServerParameters>(const RegisterServerParameters& data)
00921     {
00922         size_t size = 0;
00923         size += RawSize(data.Server);
00924         return size;
00925     }
00926 
00927 */
00928 
00929 /* DISABLED
00930 
00931     template<>
00932     std::size_t RawSize<RegisterServerRequest>(const RegisterServerRequest& data)
00933     {
00934         size_t size = 0;
00935         size += RawSize(data.TypeId);
00936         size += RawSize(data.Header);
00937         size += RawSize(data.Parameters);
00938         return size;
00939     }
00940 
00941 */
00942 
00943 /* DISABLED
00944 
00945     template<>
00946     std::size_t RawSize<RegisterServerResponse>(const RegisterServerResponse& data)
00947     {
00948         size_t size = 0;
00949         size += RawSize(data.TypeId);
00950         size += RawSize(data.Header);
00951         return size;
00952     }
00953 
00954 */
00955 
00956 /* DISABLED
00957 
00958     template<>
00959     std::size_t RawSize<ChannelSecurityToken>(const ChannelSecurityToken& data)
00960     {
00961         size_t size = 0;
00962         size += RawSize(data.ChannelId);
00963         size += RawSize(data.TokenId);
00964         size += RawSize(data.CreatedAt);
00965         size += RawSize(data.RevisedLifetime);
00966         return size;
00967     }
00968 
00969 */
00970 
00971 /* DISABLED
00972 
00973     template<>
00974     std::size_t RawSize<OpenSecureChannelParameters>(const OpenSecureChannelParameters& data)
00975     {
00976         size_t size = 0;
00977         size += RawSize(data.ClientProtocolVersion);
00978         size += RawSize(data.RequestType);
00979         size += RawSize(data.SecurityMode);
00980         size += RawSize(data.ClientNonce);
00981         size += RawSize(data.RequestedLifetime);
00982         return size;
00983     }
00984 
00985 */
00986 
00987 /* DISABLED
00988 
00989     template<>
00990     std::size_t RawSize<OpenSecureChannelRequest>(const OpenSecureChannelRequest& data)
00991     {
00992         size_t size = 0;
00993         size += RawSize(data.TypeId);
00994         size += RawSize(data.Header);
00995         size += RawSize(data.Parameters);
00996         return size;
00997     }
00998 
00999 */
01000 
01001 /* DISABLED
01002 
01003     template<>
01004     std::size_t RawSize<OpenSecureChannelResult>(const OpenSecureChannelResult& data)
01005     {
01006         size_t size = 0;
01007         size += RawSize(data.ServerProtocolVersion);
01008         size += RawSize(data.SecurityToken);
01009         size += RawSize(data.ServerNonce);
01010         return size;
01011     }
01012 
01013 */
01014 
01015 /* DISABLED
01016 
01017     template<>
01018     std::size_t RawSize<OpenSecureChannelResponse>(const OpenSecureChannelResponse& data)
01019     {
01020         size_t size = 0;
01021         size += RawSize(data.TypeId);
01022         size += RawSize(data.Header);
01023         size += RawSize(data.Parameters);
01024         return size;
01025     }
01026 
01027 */
01028 
01029 /* DISABLED
01030 
01031     template<>
01032     std::size_t RawSize<CloseSecureChannelRequest>(const CloseSecureChannelRequest& data)
01033     {
01034         size_t size = 0;
01035         size += RawSize(data.TypeId);
01036         size += RawSize(data.Header);
01037         return size;
01038     }
01039 
01040 */
01041 
01042 /* DISABLED
01043 
01044     template<>
01045     std::size_t RawSize<CloseSecureChannelResponse>(const CloseSecureChannelResponse& data)
01046     {
01047         size_t size = 0;
01048         size += RawSize(data.TypeId);
01049         size += RawSize(data.Header);
01050         return size;
01051     }
01052 
01053 */
01054 
01055     template<>
01056     std::size_t RawSize<SignedSoftwareCertificate>(const SignedSoftwareCertificate& data)
01057     {
01058         size_t size = 0;
01059         size += RawSize(data.CertificateData);
01060         size += RawSize(data.Signature);
01061         return size;
01062     }
01063 
01064 
01065     template<>
01066     std::size_t RawSize<SignatureData>(const SignatureData& data)
01067     {
01068         size_t size = 0;
01069         size += RawSize(data.Algorithm);
01070         size += RawSize(data.Signature);
01071         return size;
01072     }
01073 
01074 
01075     template<>
01076     std::size_t RawSize<CreateSessionParameters>(const CreateSessionParameters& data)
01077     {
01078         size_t size = 0;
01079         size += RawSize(data.ClientDescription);
01080         size += RawSize(data.ServerUri);
01081         size += RawSize(data.EndpointUrl);
01082         size += RawSize(data.SessionName);
01083         size += RawSize(data.ClientNonce);
01084         size += RawSize(data.ClientCertificate);
01085         size += RawSize(data.RequestedSessionTimeout);
01086         size += RawSize(data.MaxResponseMessageSize);
01087         return size;
01088     }
01089 
01090 
01091     template<>
01092     std::size_t RawSize<CreateSessionRequest>(const CreateSessionRequest& data)
01093     {
01094         size_t size = 0;
01095         size += RawSize(data.TypeId);
01096         size += RawSize(data.Header);
01097         size += RawSize(data.Parameters);
01098         return size;
01099     }
01100 
01101 
01102     template<>
01103     std::size_t RawSize<CreateSessionResult>(const CreateSessionResult& data)
01104     {
01105         size_t size = 0;
01106         size += RawSize(data.SessionId);
01107         size += RawSize(data.AuthenticationToken);
01108         size += RawSize(data.RevisedSessionTimeout);
01109         size += RawSize(data.ServerNonce);
01110         size += RawSize(data.ServerCertificate);
01111         size += RawSizeContainer(data.ServerEndpoints);
01112         size += RawSizeContainer(data.ServerSoftwareCertificates);
01113         size += RawSize(data.ServerSignature);
01114         size += RawSize(data.MaxRequestMessageSize);
01115         return size;
01116     }
01117 
01118 
01119     template<>
01120     std::size_t RawSize<CreateSessionResponse>(const CreateSessionResponse& data)
01121     {
01122         size_t size = 0;
01123         size += RawSize(data.TypeId);
01124         size += RawSize(data.Header);
01125         size += RawSize(data.Parameters);
01126         return size;
01127     }
01128 
01129 
01130 /* DISABLED
01131 
01132     template<>
01133     std::size_t RawSize<UserIdentityToken>(const UserIdentityToken& data)
01134     {
01135         size_t size = 0;
01136         size += RawSize(data.TypeId);
01137         size += RawSize(data.Encoding);
01138         size += RawSize(data.BodyLength);
01139         size += RawSize(data.PolicyId);
01140         return size;
01141     }
01142 
01143 */
01144 
01145 /* DISABLED
01146 
01147     template<>
01148     std::size_t RawSize<AnonymousIdentityToken>(const AnonymousIdentityToken& data)
01149     {
01150         size_t size = 0;
01151         size += RawSize(data.TypeId);
01152         size += RawSize(data.Encoding);
01153         size += RawSize(data.BodyLength);
01154         size += RawSize(data.PolicyId);
01155         return size;
01156     }
01157 
01158 */
01159 
01160 /* DISABLED
01161 
01162     template<>
01163     std::size_t RawSize<UserNameIdentityToken>(const UserNameIdentityToken& data)
01164     {
01165         size_t size = 0;
01166         size += RawSize(data.TypeId);
01167         size += RawSize(data.Encoding);
01168         size += RawSize(data.BodyLength);
01169         size += RawSize(data.PolicyId);
01170         size += RawSize(data.UserName);
01171         size += RawSize(data.Password);
01172         size += RawSize(data.EncryptionAlgorithm);
01173         return size;
01174     }
01175 
01176 */
01177 
01178 /* DISABLED
01179 
01180     template<>
01181     std::size_t RawSize<X509IdentityToken>(const X509IdentityToken& data)
01182     {
01183         size_t size = 0;
01184         size += RawSize(data.TypeId);
01185         size += RawSize(data.Encoding);
01186         size += RawSize(data.BodyLength);
01187         size += RawSize(data.PolicyId);
01188         size += RawSize(data.CertificateData);
01189         return size;
01190     }
01191 
01192 */
01193 
01194 /* DISABLED
01195 
01196     template<>
01197     std::size_t RawSize<IssuedIdentityToken>(const IssuedIdentityToken& data)
01198     {
01199         size_t size = 0;
01200         size += RawSize(data.TypeId);
01201         size += RawSize(data.Encoding);
01202         size += RawSize(data.BodyLength);
01203         size += RawSize(data.PolicyId);
01204         size += RawSize(data.TokenData);
01205         size += RawSize(data.EncryptionAlgorithm);
01206         return size;
01207     }
01208 
01209 */
01210 
01211     template<>
01212     std::size_t RawSize<ActivateSessionParameters>(const ActivateSessionParameters& data)
01213     {
01214         size_t size = 0;
01215         size += RawSize(data.ClientSignature);
01216         size += RawSizeContainer(data.ClientSoftwareCertificates);
01217         size += RawSizeContainer(data.LocaleIds);
01218         size += RawSize(data.UserIdentityToken);
01219         size += RawSize(data.UserTokenSignature);
01220         return size;
01221     }
01222 
01223 
01224     template<>
01225     std::size_t RawSize<ActivateSessionRequest>(const ActivateSessionRequest& data)
01226     {
01227         size_t size = 0;
01228         size += RawSize(data.TypeId);
01229         size += RawSize(data.Header);
01230         size += RawSize(data.Parameters);
01231         return size;
01232     }
01233 
01234 
01235     template<>
01236     std::size_t RawSize<ActivateSessionResult>(const ActivateSessionResult& data)
01237     {
01238         size_t size = 0;
01239         size += RawSize(data.ServerNonce);
01240         size += RawSizeContainer(data.Results);
01241         size += RawSizeContainer(data.DiagnosticInfos);
01242         return size;
01243     }
01244 
01245 
01246     template<>
01247     std::size_t RawSize<ActivateSessionResponse>(const ActivateSessionResponse& data)
01248     {
01249         size_t size = 0;
01250         size += RawSize(data.TypeId);
01251         size += RawSize(data.Header);
01252         size += RawSize(data.Parameters);
01253         return size;
01254     }
01255 
01256 
01257 /* DISABLED
01258 
01259     template<>
01260     std::size_t RawSize<CloseSessionRequest>(const CloseSessionRequest& data)
01261     {
01262         size_t size = 0;
01263         size += RawSize(data.TypeId);
01264         size += RawSize(data.Header);
01265         size += RawSize(data.DeleteSubscriptions);
01266         return size;
01267     }
01268 
01269 */
01270 
01271 /* DISABLED
01272 
01273     template<>
01274     std::size_t RawSize<CloseSessionResponse>(const CloseSessionResponse& data)
01275     {
01276         size_t size = 0;
01277         size += RawSize(data.TypeId);
01278         size += RawSize(data.Header);
01279         return size;
01280     }
01281 
01282 */
01283 
01284 /* DISABLED
01285 
01286     template<>
01287     std::size_t RawSize<CancelParameters>(const CancelParameters& data)
01288     {
01289         size_t size = 0;
01290         size += RawSize(data.RequestHandle);
01291         return size;
01292     }
01293 
01294 */
01295 
01296 /* DISABLED
01297 
01298     template<>
01299     std::size_t RawSize<CancelRequest>(const CancelRequest& data)
01300     {
01301         size_t size = 0;
01302         size += RawSize(data.TypeId);
01303         size += RawSize(data.Header);
01304         size += RawSize(data.Parameters);
01305         return size;
01306     }
01307 
01308 */
01309 
01310 /* DISABLED
01311 
01312     template<>
01313     std::size_t RawSize<CancelResult>(const CancelResult& data)
01314     {
01315         size_t size = 0;
01316         size += RawSize(data.CancelCount);
01317         return size;
01318     }
01319 
01320 */
01321 
01322 /* DISABLED
01323 
01324     template<>
01325     std::size_t RawSize<CancelResponse>(const CancelResponse& data)
01326     {
01327         size_t size = 0;
01328         size += RawSize(data.TypeId);
01329         size += RawSize(data.Header);
01330         size += RawSize(data.Parameters);
01331         return size;
01332     }
01333 
01334 */
01335 
01336 /* DISABLED
01337 
01338     template<>
01339     std::size_t RawSize<NodeAttributes>(const NodeAttributes& data)
01340     {
01341         size_t size = 0;
01342         size += RawSize(data.TypeId);
01343         size += RawSize(data.Encoding);
01344         size += RawSize(data.BodyLength);
01345         size += RawSize(data.SpecifiedAttributes);
01346         size += RawSize(data.DisplayName);
01347         size += RawSize(data.Description);
01348         size += RawSize(data.WriteMask);
01349         size += RawSize(data.UserWriteMask);
01350         return size;
01351     }
01352 
01353 */
01354 
01355 /* DISABLED
01356 
01357     template<>
01358     std::size_t RawSize<ObjectAttributes>(const ObjectAttributes& data)
01359     {
01360         size_t size = 0;
01361         size += RawSize(data.TypeId);
01362         size += RawSize(data.Encoding);
01363         size += RawSize(data.BodyLength);
01364         size += RawSize(data.SpecifiedAttributes);
01365         size += RawSize(data.DisplayName);
01366         size += RawSize(data.Description);
01367         size += RawSize(data.WriteMask);
01368         size += RawSize(data.UserWriteMask);
01369         size += RawSize(data.EventNotifier);
01370         return size;
01371     }
01372 
01373 */
01374 
01375 /* DISABLED
01376 
01377     template<>
01378     std::size_t RawSize<VariableAttributes>(const VariableAttributes& data)
01379     {
01380         size_t size = 0;
01381         size += RawSize(data.TypeId);
01382         size += RawSize(data.Encoding);
01383         size += RawSize(data.BodyLength);
01384         size += RawSize(data.SpecifiedAttributes);
01385         size += RawSize(data.DisplayName);
01386         size += RawSize(data.Description);
01387         size += RawSize(data.WriteMask);
01388         size += RawSize(data.UserWriteMask);
01389         size += RawSize(data.Value);
01390         size += RawSize(data.DataType);
01391         size += RawSize(data.ValueRank);
01392         size += RawSizeContainer(data.ArrayDimensions);
01393         size += RawSize(data.AccessLevel);
01394         size += RawSize(data.UserAccessLevel);
01395         size += RawSize(data.MinimumSamplingInterval);
01396         size += RawSize(data.Historizing);
01397         return size;
01398     }
01399 
01400 */
01401 
01402 /* DISABLED
01403 
01404     template<>
01405     std::size_t RawSize<MethodAttributes>(const MethodAttributes& data)
01406     {
01407         size_t size = 0;
01408         size += RawSize(data.TypeId);
01409         size += RawSize(data.Encoding);
01410         size += RawSize(data.BodyLength);
01411         size += RawSize(data.SpecifiedAttributes);
01412         size += RawSize(data.DisplayName);
01413         size += RawSize(data.Description);
01414         size += RawSize(data.WriteMask);
01415         size += RawSize(data.UserWriteMask);
01416         size += RawSize(data.Executable);
01417         size += RawSize(data.UserExecutable);
01418         return size;
01419     }
01420 
01421 */
01422 
01423 /* DISABLED
01424 
01425     template<>
01426     std::size_t RawSize<ObjectTypeAttributes>(const ObjectTypeAttributes& data)
01427     {
01428         size_t size = 0;
01429         size += RawSize(data.TypeId);
01430         size += RawSize(data.Encoding);
01431         size += RawSize(data.BodyLength);
01432         size += RawSize(data.SpecifiedAttributes);
01433         size += RawSize(data.DisplayName);
01434         size += RawSize(data.Description);
01435         size += RawSize(data.WriteMask);
01436         size += RawSize(data.UserWriteMask);
01437         size += RawSize(data.IsAbstract);
01438         return size;
01439     }
01440 
01441 */
01442 
01443 /* DISABLED
01444 
01445     template<>
01446     std::size_t RawSize<VariableTypeAttributes>(const VariableTypeAttributes& data)
01447     {
01448         size_t size = 0;
01449         size += RawSize(data.TypeId);
01450         size += RawSize(data.Encoding);
01451         size += RawSize(data.BodyLength);
01452         size += RawSize(data.SpecifiedAttributes);
01453         size += RawSize(data.DisplayName);
01454         size += RawSize(data.Description);
01455         size += RawSize(data.WriteMask);
01456         size += RawSize(data.UserWriteMask);
01457         size += RawSize(data.Value);
01458         size += RawSize(data.DataType);
01459         size += RawSize(data.ValueRank);
01460         size += RawSizeContainer(data.ArrayDimensions);
01461         size += RawSize(data.IsAbstract);
01462         return size;
01463     }
01464 
01465 */
01466 
01467 /* DISABLED
01468 
01469     template<>
01470     std::size_t RawSize<ReferenceTypeAttributes>(const ReferenceTypeAttributes& data)
01471     {
01472         size_t size = 0;
01473         size += RawSize(data.TypeId);
01474         size += RawSize(data.Encoding);
01475         size += RawSize(data.BodyLength);
01476         size += RawSize(data.SpecifiedAttributes);
01477         size += RawSize(data.DisplayName);
01478         size += RawSize(data.Description);
01479         size += RawSize(data.WriteMask);
01480         size += RawSize(data.UserWriteMask);
01481         size += RawSize(data.IsAbstract);
01482         size += RawSize(data.Symmetric);
01483         size += RawSize(data.InverseName);
01484         return size;
01485     }
01486 
01487 */
01488 
01489 /* DISABLED
01490 
01491     template<>
01492     std::size_t RawSize<DataTypeAttributes>(const DataTypeAttributes& data)
01493     {
01494         size_t size = 0;
01495         size += RawSize(data.TypeId);
01496         size += RawSize(data.Encoding);
01497         size += RawSize(data.BodyLength);
01498         size += RawSize(data.SpecifiedAttributes);
01499         size += RawSize(data.DisplayName);
01500         size += RawSize(data.Description);
01501         size += RawSize(data.WriteMask);
01502         size += RawSize(data.UserWriteMask);
01503         size += RawSize(data.IsAbstract);
01504         return size;
01505     }
01506 
01507 */
01508 
01509 /* DISABLED
01510 
01511     template<>
01512     std::size_t RawSize<ViewAttributes>(const ViewAttributes& data)
01513     {
01514         size_t size = 0;
01515         size += RawSize(data.TypeId);
01516         size += RawSize(data.Encoding);
01517         size += RawSize(data.BodyLength);
01518         size += RawSize(data.SpecifiedAttributes);
01519         size += RawSize(data.DisplayName);
01520         size += RawSize(data.Description);
01521         size += RawSize(data.WriteMask);
01522         size += RawSize(data.UserWriteMask);
01523         size += RawSize(data.ContainsNoLoops);
01524         size += RawSize(data.EventNotifier);
01525         return size;
01526     }
01527 
01528 */
01529 
01530 /* DISABLED
01531 
01532     template<>
01533     std::size_t RawSize<AddNodesItem>(const AddNodesItem& data)
01534     {
01535         size_t size = 0;
01536         size += RawSize(data.ParentNodeId);
01537         size += RawSize(data.ReferenceTypeId);
01538         size += RawSize(data.RequestedNewNodeId);
01539         size += RawSize(data.BrowseName);
01540         size += RawSize(data.NodeClass);
01541         size += RawSize(data.NodeAttributes);
01542         size += RawSize(data.TypeDefinition);
01543         return size;
01544     }
01545 
01546 */
01547 
01548 /* DISABLED
01549 
01550     template<>
01551     std::size_t RawSize<AddNodesResult>(const AddNodesResult& data)
01552     {
01553         size_t size = 0;
01554         size += RawSize(data.Status);
01555         size += RawSize(data.AddedNodeId);
01556         return size;
01557     }
01558 
01559 */
01560 
01561 /* DISABLED
01562 
01563     template<>
01564     std::size_t RawSize<AddNodesParameters>(const AddNodesParameters& data)
01565     {
01566         size_t size = 0;
01567         size += RawSizeContainer(data.NodesToAdd);
01568         return size;
01569     }
01570 
01571 */
01572 
01573 /* DISABLED
01574 
01575     template<>
01576     std::size_t RawSize<AddNodesRequest>(const AddNodesRequest& data)
01577     {
01578         size_t size = 0;
01579         size += RawSize(data.TypeId);
01580         size += RawSize(data.Header);
01581         size += RawSize(data.Parameters);
01582         return size;
01583     }
01584 
01585 */
01586 
01587 /* DISABLED
01588 
01589     template<>
01590     std::size_t RawSize<AddNodesResponse>(const AddNodesResponse& data)
01591     {
01592         size_t size = 0;
01593         size += RawSize(data.TypeId);
01594         size += RawSize(data.Header);
01595         size += RawSizeContainer(data.Results);
01596         size += RawSizeContainer(data.DiagnosticInfos);
01597         return size;
01598     }
01599 
01600 */
01601 
01602 /* DISABLED
01603 
01604     template<>
01605     std::size_t RawSize<AddReferencesItem>(const AddReferencesItem& data)
01606     {
01607         size_t size = 0;
01608         size += RawSize(data.SourceNodeId);
01609         size += RawSize(data.ReferenceTypeId);
01610         size += RawSize(data.IsForward);
01611         size += RawSize(data.TargetServerUri);
01612         size += RawSize(data.TargetNodeId);
01613         size += RawSize(data.TargetNodeClass);
01614         return size;
01615     }
01616 
01617 */
01618 
01619 /* DISABLED
01620 
01621     template<>
01622     std::size_t RawSize<AddReferencesRequest>(const AddReferencesRequest& data)
01623     {
01624         size_t size = 0;
01625         size += RawSize(data.TypeId);
01626         size += RawSize(data.Header);
01627         size += RawSizeContainer(data.ReferencesToAdd);
01628         return size;
01629     }
01630 
01631 */
01632 
01633 /* DISABLED
01634 
01635     template<>
01636     std::size_t RawSize<AddReferencesResponse>(const AddReferencesResponse& data)
01637     {
01638         size_t size = 0;
01639         size += RawSize(data.TypeId);
01640         size += RawSize(data.Header);
01641         size += RawSizeContainer(data.Results);
01642         size += RawSizeContainer(data.DiagnosticInfos);
01643         return size;
01644     }
01645 
01646 */
01647 
01648     template<>
01649     std::size_t RawSize<DeleteNodesItem>(const DeleteNodesItem& data)
01650     {
01651         size_t size = 0;
01652         size += RawSize(data.NodeId);
01653         size += RawSize(data.DeleteTargetReferences);
01654         return size;
01655     }
01656 
01657 
01658     template<>
01659     std::size_t RawSize<DeleteNodesRequest>(const DeleteNodesRequest& data)
01660     {
01661         size_t size = 0;
01662         size += RawSize(data.TypeId);
01663         size += RawSize(data.Header);
01664         size += RawSizeContainer(data.NodesToDelete);
01665         return size;
01666     }
01667 
01668 
01669     template<>
01670     std::size_t RawSize<DeleteNodesResponse>(const DeleteNodesResponse& data)
01671     {
01672         size_t size = 0;
01673         size += RawSize(data.TypeId);
01674         size += RawSize(data.Header);
01675         size += RawSizeContainer(data.Results);
01676         size += RawSizeContainer(data.DiagnosticInfos);
01677         return size;
01678     }
01679 
01680 
01681 /* DISABLED
01682 
01683     template<>
01684     std::size_t RawSize<DeleteReferencesItem>(const DeleteReferencesItem& data)
01685     {
01686         size_t size = 0;
01687         size += RawSize(data.SourceNodeId);
01688         size += RawSize(data.ReferenceTypeId);
01689         size += RawSize(data.IsForward);
01690         size += RawSize(data.TargetNodeId);
01691         size += RawSize(data.DeleteBidirectional);
01692         return size;
01693     }
01694 
01695 */
01696 
01697 /* DISABLED
01698 
01699     template<>
01700     std::size_t RawSize<DeleteReferencesParameters>(const DeleteReferencesParameters& data)
01701     {
01702         size_t size = 0;
01703         size += RawSizeContainer(data.ReferencesToDelete);
01704         return size;
01705     }
01706 
01707 */
01708 
01709 /* DISABLED
01710 
01711     template<>
01712     std::size_t RawSize<DeleteReferencesRequest>(const DeleteReferencesRequest& data)
01713     {
01714         size_t size = 0;
01715         size += RawSize(data.TypeId);
01716         size += RawSize(data.Header);
01717         size += RawSize(data.Parameters);
01718         return size;
01719     }
01720 
01721 */
01722 
01723 /* DISABLED
01724 
01725     template<>
01726     std::size_t RawSize<DeleteReferencesResult>(const DeleteReferencesResult& data)
01727     {
01728         size_t size = 0;
01729         size += RawSizeContainer(data.Results);
01730         size += RawSizeContainer(data.DiagnosticInfos);
01731         return size;
01732     }
01733 
01734 */
01735 
01736 /* DISABLED
01737 
01738     template<>
01739     std::size_t RawSize<DeleteReferencesResponse>(const DeleteReferencesResponse& data)
01740     {
01741         size_t size = 0;
01742         size += RawSize(data.TypeId);
01743         size += RawSize(data.Header);
01744         size += RawSize(data.Parameters);
01745         return size;
01746     }
01747 
01748 */
01749 
01750 /* DISABLED
01751 
01752     template<>
01753     std::size_t RawSize<ViewDescription>(const ViewDescription& data)
01754     {
01755         size_t size = 0;
01756         size += RawSize(data.ViewId);
01757         size += RawSize(data.Timestamp);
01758         size += RawSize(data.ViewVersion);
01759         return size;
01760     }
01761 
01762 */
01763 
01764 /* DISABLED
01765 
01766     template<>
01767     std::size_t RawSize<BrowseDescription>(const BrowseDescription& data)
01768     {
01769         size_t size = 0;
01770         size += RawSize(data.NodeId);
01771         size += RawSize(data.BrowseDirection);
01772         size += RawSize(data.ReferenceTypeId);
01773         size += RawSize(data.IncludeSubtypes);
01774         size += RawSize(data.NodeClassMask);
01775         size += RawSize(data.ResultMask);
01776         return size;
01777     }
01778 
01779 */
01780 
01781 /* DISABLED
01782 
01783     template<>
01784     std::size_t RawSize<ReferenceDescription>(const ReferenceDescription& data)
01785     {
01786         size_t size = 0;
01787         size += RawSize(data.ReferenceTypeId);
01788         size += RawSize(data.IsForward);
01789         size += RawSize(data.NodeId);
01790         size += RawSize(data.BrowseName);
01791         size += RawSize(data.DisplayName);
01792         size += RawSize(data.NodeClass);
01793         size += RawSize(data.TypeDefinition);
01794         return size;
01795     }
01796 
01797 */
01798 
01799 /* DISABLED
01800 
01801     template<>
01802     std::size_t RawSize<BrowseResult>(const BrowseResult& data)
01803     {
01804         size_t size = 0;
01805         size += RawSize(data.Status);
01806         size += RawSize(data.ContinuationPoint);
01807         size += RawSizeContainer(data.References);
01808         return size;
01809     }
01810 
01811 */
01812 
01813 /* DISABLED
01814 
01815     template<>
01816     std::size_t RawSize<BrowseParameters>(const BrowseParameters& data)
01817     {
01818         size_t size = 0;
01819         size += RawSize(data.View);
01820         size += RawSize(data.RequestedMaxReferencesPerNode);
01821         size += RawSizeContainer(data.NodesToBrowse);
01822         return size;
01823     }
01824 
01825 */
01826 
01827 /* DISABLED
01828 
01829     template<>
01830     std::size_t RawSize<BrowseRequest>(const BrowseRequest& data)
01831     {
01832         size_t size = 0;
01833         size += RawSize(data.TypeId);
01834         size += RawSize(data.Header);
01835         size += RawSize(data.Parameters);
01836         return size;
01837     }
01838 
01839 */
01840 
01841 /* DISABLED
01842 
01843     template<>
01844     std::size_t RawSize<BrowseResponse>(const BrowseResponse& data)
01845     {
01846         size_t size = 0;
01847         size += RawSize(data.TypeId);
01848         size += RawSize(data.Header);
01849         size += RawSizeContainer(data.Results);
01850         size += RawSizeContainer(data.DiagnosticInfos);
01851         return size;
01852     }
01853 
01854 */
01855 
01856 /* DISABLED
01857 
01858     template<>
01859     std::size_t RawSize<BrowseNextParameters>(const BrowseNextParameters& data)
01860     {
01861         size_t size = 0;
01862         size += RawSize(data.ReleaseContinuationPoints);
01863         size += RawSizeContainer(data.ContinuationPoints);
01864         return size;
01865     }
01866 
01867 */
01868 
01869 /* DISABLED
01870 
01871     template<>
01872     std::size_t RawSize<BrowseNextRequest>(const BrowseNextRequest& data)
01873     {
01874         size_t size = 0;
01875         size += RawSize(data.TypeId);
01876         size += RawSize(data.Header);
01877         size += RawSize(data.Parameters);
01878         return size;
01879     }
01880 
01881 */
01882 
01883 /* DISABLED
01884 
01885     template<>
01886     std::size_t RawSize<BrowseNextResult>(const BrowseNextResult& data)
01887     {
01888         size_t size = 0;
01889         size += RawSizeContainer(data.Results);
01890         size += RawSizeContainer(data.DiagnosticInfos);
01891         return size;
01892     }
01893 
01894 */
01895 
01896 /* DISABLED
01897 
01898     template<>
01899     std::size_t RawSize<BrowseNextResponse>(const BrowseNextResponse& data)
01900     {
01901         size_t size = 0;
01902         size += RawSize(data.TypeId);
01903         size += RawSize(data.Header);
01904         size += RawSize(data.Parameters);
01905         return size;
01906     }
01907 
01908 */
01909 
01910 /* DISABLED
01911 
01912     template<>
01913     std::size_t RawSize<RelativePathElement>(const RelativePathElement& data)
01914     {
01915         size_t size = 0;
01916         size += RawSize(data.ReferenceTypeId);
01917         size += RawSize(data.IsInverse);
01918         size += RawSize(data.IncludeSubtypes);
01919         size += RawSize(data.TargetName);
01920         return size;
01921     }
01922 
01923 */
01924 
01925 /* DISABLED
01926 
01927     template<>
01928     std::size_t RawSize<RelativePath>(const RelativePath& data)
01929     {
01930         size_t size = 0;
01931         size += RawSizeContainer(data.Elements);
01932         return size;
01933     }
01934 
01935 */
01936 
01937 /* DISABLED
01938 
01939     template<>
01940     std::size_t RawSize<BrowsePath>(const BrowsePath& data)
01941     {
01942         size_t size = 0;
01943         size += RawSize(data.StartingNode);
01944         size += RawSize(data.RelativePath);
01945         return size;
01946     }
01947 
01948 */
01949 
01950 /* DISABLED
01951 
01952     template<>
01953     std::size_t RawSize<BrowsePathTarget>(const BrowsePathTarget& data)
01954     {
01955         size_t size = 0;
01956         size += RawSize(data.TargetId);
01957         size += RawSize(data.RemainingPathIndex);
01958         return size;
01959     }
01960 
01961 */
01962 
01963 /* DISABLED
01964 
01965     template<>
01966     std::size_t RawSize<BrowsePathResult>(const BrowsePathResult& data)
01967     {
01968         size_t size = 0;
01969         size += RawSize(data.Status);
01970         size += RawSizeContainer(data.Targets);
01971         return size;
01972     }
01973 
01974 */
01975 
01976 /* DISABLED
01977 
01978     template<>
01979     std::size_t RawSize<TranslateBrowsePathsToNodeIdsParameters>(const TranslateBrowsePathsToNodeIdsParameters& data)
01980     {
01981         size_t size = 0;
01982         size += RawSizeContainer(data.BrowsePaths);
01983         return size;
01984     }
01985 
01986 */
01987 
01988 /* DISABLED
01989 
01990     template<>
01991     std::size_t RawSize<TranslateBrowsePathsToNodeIdsRequest>(const TranslateBrowsePathsToNodeIdsRequest& data)
01992     {
01993         size_t size = 0;
01994         size += RawSize(data.TypeId);
01995         size += RawSize(data.Header);
01996         size += RawSize(data.Parameters);
01997         return size;
01998     }
01999 
02000 */
02001 
02002 /* DISABLED
02003 
02004     template<>
02005     std::size_t RawSize<TranslateBrowsePathsToNodeIdsResponse>(const TranslateBrowsePathsToNodeIdsResponse& data)
02006     {
02007         size_t size = 0;
02008         size += RawSize(data.TypeId);
02009         size += RawSize(data.Header);
02010         size += RawSizeContainer(data.Results);
02011         size += RawSizeContainer(data.DiagnosticInfos);
02012         return size;
02013     }
02014 
02015 */
02016 
02017 /* DISABLED
02018 
02019     template<>
02020     std::size_t RawSize<RegisterNodesParameters>(const RegisterNodesParameters& data)
02021     {
02022         size_t size = 0;
02023         size += RawSizeContainer(data.NodesToRegister);
02024         return size;
02025     }
02026 
02027 */
02028 
02029 /* DISABLED
02030 
02031     template<>
02032     std::size_t RawSize<RegisterNodesRequest>(const RegisterNodesRequest& data)
02033     {
02034         size_t size = 0;
02035         size += RawSize(data.TypeId);
02036         size += RawSize(data.Header);
02037         size += RawSize(data.Parameters);
02038         return size;
02039     }
02040 
02041 */
02042 
02043 /* DISABLED
02044 
02045     template<>
02046     std::size_t RawSize<RegisterNodesResult>(const RegisterNodesResult& data)
02047     {
02048         size_t size = 0;
02049         size += RawSizeContainer(data.RegisteredNodeIds);
02050         return size;
02051     }
02052 
02053 */
02054 
02055 /* DISABLED
02056 
02057     template<>
02058     std::size_t RawSize<RegisterNodesResponse>(const RegisterNodesResponse& data)
02059     {
02060         size_t size = 0;
02061         size += RawSize(data.TypeId);
02062         size += RawSize(data.Header);
02063         size += RawSize(data.Parameters);
02064         return size;
02065     }
02066 
02067 */
02068 
02069 /* DISABLED
02070 
02071     template<>
02072     std::size_t RawSize<UnregisterNodesParameters>(const UnregisterNodesParameters& data)
02073     {
02074         size_t size = 0;
02075         size += RawSizeContainer(data.NodesToUnregister);
02076         return size;
02077     }
02078 
02079 */
02080 
02081 /* DISABLED
02082 
02083     template<>
02084     std::size_t RawSize<UnregisterNodesRequest>(const UnregisterNodesRequest& data)
02085     {
02086         size_t size = 0;
02087         size += RawSize(data.TypeId);
02088         size += RawSize(data.Header);
02089         size += RawSize(data.Parameters);
02090         return size;
02091     }
02092 
02093 */
02094 
02095 /* DISABLED
02096 
02097     template<>
02098     std::size_t RawSize<UnregisterNodesResponse>(const UnregisterNodesResponse& data)
02099     {
02100         size_t size = 0;
02101         size += RawSize(data.TypeId);
02102         size += RawSize(data.Header);
02103         return size;
02104     }
02105 
02106 */
02107 
02108 /* DISABLED
02109 
02110     template<>
02111     std::size_t RawSize<EndpointConfiguration>(const EndpointConfiguration& data)
02112     {
02113         size_t size = 0;
02114         size += RawSize(data.OperationTimeout);
02115         size += RawSize(data.UseBinaryEncoding);
02116         size += RawSize(data.MaxStringLength);
02117         size += RawSize(data.MaxByteStringLength);
02118         size += RawSize(data.MaxArrayLength);
02119         size += RawSize(data.MaxMessageSize);
02120         size += RawSize(data.MaxBufferSize);
02121         size += RawSize(data.ChannelLifetime);
02122         size += RawSize(data.SecurityTokenLifetime);
02123         return size;
02124     }
02125 
02126 */
02127 
02128 /* DISABLED
02129 
02130     template<>
02131     std::size_t RawSize<SupportedProfile>(const SupportedProfile& data)
02132     {
02133         size_t size = 0;
02134         size += RawSize(data.OrganizationUri);
02135         size += RawSize(data.ProfileId);
02136         size += RawSize(data.ComplianceTool);
02137         size += RawSize(data.ComplianceDate);
02138         size += RawSize(data.ComplianceLevel);
02139         size += RawSizeContainer(data.UnsupportedUnitIds);
02140         return size;
02141     }
02142 
02143 */
02144 
02145 /* DISABLED
02146 
02147     template<>
02148     std::size_t RawSize<SoftwareCertificate>(const SoftwareCertificate& data)
02149     {
02150         size_t size = 0;
02151         size += RawSize(data.ProductName);
02152         size += RawSize(data.ProductUri);
02153         size += RawSize(data.VendorName);
02154         size += RawSize(data.VendorProductCertificate);
02155         size += RawSize(data.SoftwareVersion);
02156         size += RawSize(data.BuildNumber);
02157         size += RawSize(data.BuildDate);
02158         size += RawSize(data.IssuedBy);
02159         size += RawSize(data.IssueDate);
02160         size += RawSizeContainer(data.SupportedProfiles);
02161         return size;
02162     }
02163 
02164 */
02165 
02166 /* DISABLED
02167 
02168     template<>
02169     std::size_t RawSize<QueryDataDescription>(const QueryDataDescription& data)
02170     {
02171         size_t size = 0;
02172         size += RawSize(data.RelativePath);
02173         size += RawSize(data.AttributeId);
02174         size += RawSize(data.IndexRange);
02175         return size;
02176     }
02177 
02178 */
02179 
02180 /* DISABLED
02181 
02182     template<>
02183     std::size_t RawSize<NodeTypeDescription>(const NodeTypeDescription& data)
02184     {
02185         size_t size = 0;
02186         size += RawSize(data.TypeDefinitionNode);
02187         size += RawSize(data.IncludeSubTypes);
02188         size += RawSizeContainer(data.DataToReturn);
02189         return size;
02190     }
02191 
02192 */
02193 
02194 /* DISABLED
02195 
02196     template<>
02197     std::size_t RawSize<QueryDataSet>(const QueryDataSet& data)
02198     {
02199         size_t size = 0;
02200         size += RawSize(data.NodeId);
02201         size += RawSize(data.TypeDefinitionNode);
02202         size += RawSizeContainer(data.Values);
02203         return size;
02204     }
02205 
02206 */
02207 
02208 /* DISABLED
02209 
02210     template<>
02211     std::size_t RawSize<NodeReference>(const NodeReference& data)
02212     {
02213         size_t size = 0;
02214         size += RawSize(data.NodeId);
02215         size += RawSize(data.ReferenceTypeId);
02216         size += RawSize(data.IsForward);
02217         size += RawSizeContainer(data.ReferencedNodeIds);
02218         return size;
02219     }
02220 
02221 */
02222 
02223 /* DISABLED
02224 
02225     template<>
02226     std::size_t RawSize<ContentFilterElement>(const ContentFilterElement& data)
02227     {
02228         size_t size = 0;
02229         size += RawSize(data.FilterOperator);
02230         size += RawSizeContainer(data.FilterOperands);
02231         return size;
02232     }
02233 
02234 */
02235 
02236 /* DISABLED
02237 
02238     template<>
02239     std::size_t RawSize<ContentFilter>(const ContentFilter& data)
02240     {
02241         size_t size = 0;
02242         size += RawSizeContainer(data.Elements);
02243         return size;
02244     }
02245 
02246 */
02247 
02248 /* DISABLED
02249 
02250     template<>
02251     std::size_t RawSize<FilterOperand>(const FilterOperand& data)
02252     {
02253         size_t size = 0;
02254         size += RawSize(data.TypeId);
02255         size += RawSize(data.Encoding);
02256         if ((data.Encoding) & (1<<(0))) size += RawSize(data.Body);
02257         return size;
02258     }
02259 
02260 */
02261 
02262 /* DISABLED
02263 
02264     template<>
02265     std::size_t RawSize<ElementOperand>(const ElementOperand& data)
02266     {
02267         size_t size = 0;
02268         size += RawSize(data.TypeId);
02269         size += RawSize(data.Encoding);
02270         size += RawSize(data.BodyLength);
02271         size += RawSize(data.Index);
02272         return size;
02273     }
02274 
02275 */
02276 
02277 /* DISABLED
02278 
02279     template<>
02280     std::size_t RawSize<LiteralOperand>(const LiteralOperand& data)
02281     {
02282         size_t size = 0;
02283         size += RawSize(data.TypeId);
02284         size += RawSize(data.Encoding);
02285         size += RawSize(data.BodyLength);
02286         size += RawSize(data.Value);
02287         return size;
02288     }
02289 
02290 */
02291 
02292 /* DISABLED
02293 
02294     template<>
02295     std::size_t RawSize<AttributeOperand>(const AttributeOperand& data)
02296     {
02297         size_t size = 0;
02298         size += RawSize(data.TypeId);
02299         size += RawSize(data.Encoding);
02300         size += RawSize(data.BodyLength);
02301         size += RawSize(data.NodeId);
02302         size += RawSize(data.Alias);
02303         size += RawSize(data.BrowsePath);
02304         size += RawSize(data.AttributeId);
02305         size += RawSize(data.IndexRange);
02306         return size;
02307     }
02308 
02309 */
02310 
02311 /* DISABLED
02312 
02313     template<>
02314     std::size_t RawSize<SimpleAttributeOperand>(const SimpleAttributeOperand& data)
02315     {
02316         size_t size = 0;
02317         size += RawSize(data.TypeId);
02318         size += RawSize(data.Encoding);
02319         size += RawSize(data.BodyLength);
02320         size += RawSize(data.TypeDefinitionId);
02321         size += RawSizeContainer(data.BrowsePath);
02322         size += RawSize(data.AttributeId);
02323         size += RawSize(data.IndexRange);
02324         return size;
02325     }
02326 
02327 */
02328 
02329 /* DISABLED
02330 
02331     template<>
02332     std::size_t RawSize<ContentFilterElementResult>(const ContentFilterElementResult& data)
02333     {
02334         size_t size = 0;
02335         size += RawSize(data.Status);
02336         size += RawSizeContainer(data.OperandStatusCodes);
02337         size += RawSizeContainer(data.OperandDiagnosticInfos);
02338         return size;
02339     }
02340 
02341 */
02342 
02343 /* DISABLED
02344 
02345     template<>
02346     std::size_t RawSize<ContentFilterResult>(const ContentFilterResult& data)
02347     {
02348         size_t size = 0;
02349         size += RawSizeContainer(data.ElementResults);
02350         size += RawSizeContainer(data.ElementDiagnosticInfos);
02351         return size;
02352     }
02353 
02354 */
02355 
02356 /* DISABLED
02357 
02358     template<>
02359     std::size_t RawSize<ParsingResult>(const ParsingResult& data)
02360     {
02361         size_t size = 0;
02362         size += RawSize(data.Status);
02363         size += RawSizeContainer(data.DataStatusCodes);
02364         size += RawSizeContainer(data.DataDiagnosticInfos);
02365         return size;
02366     }
02367 
02368 */
02369 
02370 /* DISABLED
02371 
02372     template<>
02373     std::size_t RawSize<QueryFirstParameters>(const QueryFirstParameters& data)
02374     {
02375         size_t size = 0;
02376         size += RawSize(data.View);
02377         size += RawSizeContainer(data.NodeTypes);
02378         size += RawSize(data.Filter);
02379         size += RawSize(data.MaxDataSetsToReturn);
02380         size += RawSize(data.MaxReferencesToReturn);
02381         return size;
02382     }
02383 
02384 */
02385 
02386 /* DISABLED
02387 
02388     template<>
02389     std::size_t RawSize<QueryFirstRequest>(const QueryFirstRequest& data)
02390     {
02391         size_t size = 0;
02392         size += RawSize(data.TypeId);
02393         size += RawSize(data.Header);
02394         size += RawSize(data.Parameters);
02395         return size;
02396     }
02397 
02398 */
02399 
02400 /* DISABLED
02401 
02402     template<>
02403     std::size_t RawSize<QueryFirstResult>(const QueryFirstResult& data)
02404     {
02405         size_t size = 0;
02406         size += RawSizeContainer(data.QueryDataSets);
02407         size += RawSize(data.ContinuationPoint);
02408         size += RawSizeContainer(data.ParsingResults);
02409         size += RawSizeContainer(data.DiagnosticInfos);
02410         size += RawSize(data.FilterResult);
02411         return size;
02412     }
02413 
02414 */
02415 
02416 /* DISABLED
02417 
02418     template<>
02419     std::size_t RawSize<QueryFirstResponse>(const QueryFirstResponse& data)
02420     {
02421         size_t size = 0;
02422         size += RawSize(data.TypeId);
02423         size += RawSize(data.Header);
02424         size += RawSize(data.Parameters);
02425         return size;
02426     }
02427 
02428 */
02429 
02430 /* DISABLED
02431 
02432     template<>
02433     std::size_t RawSize<QueryNextParameters>(const QueryNextParameters& data)
02434     {
02435         size_t size = 0;
02436         size += RawSize(data.ReleaseContinuationPoint);
02437         size += RawSize(data.ContinuationPoint);
02438         return size;
02439     }
02440 
02441 */
02442 
02443 /* DISABLED
02444 
02445     template<>
02446     std::size_t RawSize<QueryNextRequest>(const QueryNextRequest& data)
02447     {
02448         size_t size = 0;
02449         size += RawSize(data.TypeId);
02450         size += RawSize(data.Header);
02451         size += RawSize(data.Parameters);
02452         return size;
02453     }
02454 
02455 */
02456 
02457 /* DISABLED
02458 
02459     template<>
02460     std::size_t RawSize<QueryNextResult>(const QueryNextResult& data)
02461     {
02462         size_t size = 0;
02463         size += RawSizeContainer(data.QueryDataSets);
02464         size += RawSize(data.RevisedContinuationPoint);
02465         return size;
02466     }
02467 
02468 */
02469 
02470 /* DISABLED
02471 
02472     template<>
02473     std::size_t RawSize<QueryNextResponse>(const QueryNextResponse& data)
02474     {
02475         size_t size = 0;
02476         size += RawSize(data.TypeId);
02477         size += RawSize(data.Header);
02478         size += RawSize(data.Parameters);
02479         return size;
02480     }
02481 
02482 */
02483 
02484     template<>
02485     std::size_t RawSize<ReadValueId>(const ReadValueId& data)
02486     {
02487         size_t size = 0;
02488         size += RawSize(data.NodeId);
02489         size += RawSize(data.AttributeId);
02490         size += RawSize(data.IndexRange);
02491         size += RawSize(data.DataEncoding);
02492         return size;
02493     }
02494 
02495 
02496     template<>
02497     std::size_t RawSize<ReadParameters>(const ReadParameters& data)
02498     {
02499         size_t size = 0;
02500         size += RawSize(data.MaxAge);
02501         size += RawSize(data.TimestampsToReturn);
02502         size += RawSizeContainer(data.AttributesToRead);
02503         return size;
02504     }
02505 
02506 
02507     template<>
02508     std::size_t RawSize<ReadRequest>(const ReadRequest& data)
02509     {
02510         size_t size = 0;
02511         size += RawSize(data.TypeId);
02512         size += RawSize(data.Header);
02513         size += RawSize(data.Parameters);
02514         return size;
02515     }
02516 
02517 
02518     template<>
02519     std::size_t RawSize<ReadResponse>(const ReadResponse& data)
02520     {
02521         size_t size = 0;
02522         size += RawSize(data.TypeId);
02523         size += RawSize(data.Header);
02524         size += RawSizeContainer(data.Results);
02525         size += RawSizeContainer(data.DiagnosticInfos);
02526         return size;
02527     }
02528 
02529 
02530 /* DISABLED
02531 
02532     template<>
02533     std::size_t RawSize<HistoryReadValueId>(const HistoryReadValueId& data)
02534     {
02535         size_t size = 0;
02536         size += RawSize(data.NodeId);
02537         size += RawSize(data.IndexRange);
02538         size += RawSize(data.DataEncoding);
02539         size += RawSize(data.ContinuationPoint);
02540         return size;
02541     }
02542 
02543 */
02544 
02545 /* DISABLED
02546 
02547     template<>
02548     std::size_t RawSize<HistoryReadResult>(const HistoryReadResult& data)
02549     {
02550         size_t size = 0;
02551         size += RawSize(data.Status);
02552         size += RawSize(data.ContinuationPoint);
02553         size += RawSize(data.HistoryData);
02554         return size;
02555     }
02556 
02557 */
02558 
02559 /* DISABLED
02560 
02561     template<>
02562     std::size_t RawSize<HistoryReadDetails>(const HistoryReadDetails& data)
02563     {
02564         size_t size = 0;
02565         size += RawSize(data.TypeId);
02566         size += RawSize(data.Encoding);
02567         if ((data.Encoding) & (1<<(0))) size += RawSize(data.Body);
02568         return size;
02569     }
02570 
02571 */
02572 
02573 /* DISABLED
02574 
02575     template<>
02576     std::size_t RawSize<ReadRawModifiedDetails>(const ReadRawModifiedDetails& data)
02577     {
02578         size_t size = 0;
02579         size += RawSize(data.TypeId);
02580         size += RawSize(data.Encoding);
02581         size += RawSize(data.BodyLength);
02582         size += RawSize(data.IsReadModified);
02583         size += RawSize(data.StartTime);
02584         size += RawSize(data.EndTime);
02585         size += RawSize(data.NumValuesPerNode);
02586         size += RawSize(data.ReturnBounds);
02587         return size;
02588     }
02589 
02590 */
02591 
02592 /* DISABLED
02593 
02594     template<>
02595     std::size_t RawSize<ReadAtTimeDetails>(const ReadAtTimeDetails& data)
02596     {
02597         size_t size = 0;
02598         size += RawSize(data.TypeId);
02599         size += RawSize(data.Encoding);
02600         size += RawSize(data.BodyLength);
02601         size += RawSizeContainer(data.ReqTimes);
02602         size += RawSize(data.UseSimpleBounds);
02603         return size;
02604     }
02605 
02606 */
02607 
02608 /* DISABLED
02609 
02610     template<>
02611     std::size_t RawSize<HistoryData>(const HistoryData& data)
02612     {
02613         size_t size = 0;
02614         size += RawSizeContainer(data.DataValues);
02615         return size;
02616     }
02617 
02618 */
02619 
02620 /* DISABLED
02621 
02622     template<>
02623     std::size_t RawSize<ModificationInfo>(const ModificationInfo& data)
02624     {
02625         size_t size = 0;
02626         size += RawSize(data.ModificationTime);
02627         size += RawSize(data.UpdateType);
02628         size += RawSize(data.UserName);
02629         return size;
02630     }
02631 
02632 */
02633 
02634 /* DISABLED
02635 
02636     template<>
02637     std::size_t RawSize<HistoryModifiedData>(const HistoryModifiedData& data)
02638     {
02639         size_t size = 0;
02640         size += RawSizeContainer(data.DataValues);
02641         size += RawSizeContainer(data.ModificationInfos);
02642         return size;
02643     }
02644 
02645 */
02646 
02647 /* DISABLED
02648 
02649     template<>
02650     std::size_t RawSize<HistoryReadParameters>(const HistoryReadParameters& data)
02651     {
02652         size_t size = 0;
02653         size += RawSize(data.HistoryReadDetails);
02654         size += RawSize(data.TimestampsToReturn);
02655         size += RawSize(data.ReleaseContinuationPoints);
02656         size += RawSizeContainer(data.AttributesToRead);
02657         return size;
02658     }
02659 
02660 */
02661 
02662 /* DISABLED
02663 
02664     template<>
02665     std::size_t RawSize<HistoryReadRequest>(const HistoryReadRequest& data)
02666     {
02667         size_t size = 0;
02668         size += RawSize(data.TypeId);
02669         size += RawSize(data.Header);
02670         size += RawSize(data.Parameters);
02671         return size;
02672     }
02673 
02674 */
02675 
02676 /* DISABLED
02677 
02678     template<>
02679     std::size_t RawSize<HistoryReadResponse>(const HistoryReadResponse& data)
02680     {
02681         size_t size = 0;
02682         size += RawSize(data.TypeId);
02683         size += RawSize(data.Header);
02684         size += RawSizeContainer(data.Results);
02685         size += RawSizeContainer(data.DiagnosticInfos);
02686         return size;
02687     }
02688 
02689 */
02690 
02691     template<>
02692     std::size_t RawSize<WriteValue>(const WriteValue& data)
02693     {
02694         size_t size = 0;
02695         size += RawSize(data.NodeId);
02696         size += RawSize(data.AttributeId);
02697         size += RawSize(data.IndexRange);
02698         size += RawSize(data.Value);
02699         return size;
02700     }
02701 
02702 
02703     template<>
02704     std::size_t RawSize<WriteParameters>(const WriteParameters& data)
02705     {
02706         size_t size = 0;
02707         size += RawSizeContainer(data.NodesToWrite);
02708         return size;
02709     }
02710 
02711 
02712     template<>
02713     std::size_t RawSize<WriteRequest>(const WriteRequest& data)
02714     {
02715         size_t size = 0;
02716         size += RawSize(data.TypeId);
02717         size += RawSize(data.Header);
02718         size += RawSize(data.Parameters);
02719         return size;
02720     }
02721 
02722 
02723     template<>
02724     std::size_t RawSize<WriteResponse>(const WriteResponse& data)
02725     {
02726         size_t size = 0;
02727         size += RawSize(data.TypeId);
02728         size += RawSize(data.Header);
02729         size += RawSizeContainer(data.Results);
02730         size += RawSizeContainer(data.DiagnosticInfos);
02731         return size;
02732     }
02733 
02734 
02735 /* DISABLED
02736 
02737     template<>
02738     std::size_t RawSize<HistoryUpdateDetails>(const HistoryUpdateDetails& data)
02739     {
02740         size_t size = 0;
02741         size += RawSize(data.NodeId);
02742         return size;
02743     }
02744 
02745 */
02746 
02747 /* DISABLED
02748 
02749     template<>
02750     std::size_t RawSize<UpdateDataDetails>(const UpdateDataDetails& data)
02751     {
02752         size_t size = 0;
02753         size += RawSize(data.NodeId);
02754         size += RawSize(data.PerformInsertReplace);
02755         size += RawSizeContainer(data.UpdateValues);
02756         return size;
02757     }
02758 
02759 */
02760 
02761 /* DISABLED
02762 
02763     template<>
02764     std::size_t RawSize<UpdateStructureDataDetails>(const UpdateStructureDataDetails& data)
02765     {
02766         size_t size = 0;
02767         size += RawSize(data.NodeId);
02768         size += RawSize(data.PerformInsertReplace);
02769         size += RawSizeContainer(data.UpdateValues);
02770         return size;
02771     }
02772 
02773 */
02774 
02775 /* DISABLED
02776 
02777     template<>
02778     std::size_t RawSize<DeleteRawModifiedDetails>(const DeleteRawModifiedDetails& data)
02779     {
02780         size_t size = 0;
02781         size += RawSize(data.NodeId);
02782         size += RawSize(data.IsDeleteModified);
02783         size += RawSize(data.StartTime);
02784         size += RawSize(data.EndTime);
02785         return size;
02786     }
02787 
02788 */
02789 
02790 /* DISABLED
02791 
02792     template<>
02793     std::size_t RawSize<DeleteAtTimeDetails>(const DeleteAtTimeDetails& data)
02794     {
02795         size_t size = 0;
02796         size += RawSize(data.NodeId);
02797         size += RawSizeContainer(data.ReqTimes);
02798         return size;
02799     }
02800 
02801 */
02802 
02803 /* DISABLED
02804 
02805     template<>
02806     std::size_t RawSize<DeleteEventDetails>(const DeleteEventDetails& data)
02807     {
02808         size_t size = 0;
02809         size += RawSize(data.NodeId);
02810         size += RawSizeContainer(data.EventIds);
02811         return size;
02812     }
02813 
02814 */
02815 
02816 /* DISABLED
02817 
02818     template<>
02819     std::size_t RawSize<HistoryUpdateResult>(const HistoryUpdateResult& data)
02820     {
02821         size_t size = 0;
02822         size += RawSize(data.Status);
02823         size += RawSizeContainer(data.OperationResults);
02824         size += RawSizeContainer(data.DiagnosticInfos);
02825         return size;
02826     }
02827 
02828 */
02829 
02830 /* DISABLED
02831 
02832     template<>
02833     std::size_t RawSize<HistoryUpdateParameters>(const HistoryUpdateParameters& data)
02834     {
02835         size_t size = 0;
02836         size += RawSizeContainer(data.HistoryUpdateDetails);
02837         return size;
02838     }
02839 
02840 */
02841 
02842 /* DISABLED
02843 
02844     template<>
02845     std::size_t RawSize<HistoryUpdateRequest>(const HistoryUpdateRequest& data)
02846     {
02847         size_t size = 0;
02848         size += RawSize(data.TypeId);
02849         size += RawSize(data.Header);
02850         size += RawSize(data.Parameters);
02851         return size;
02852     }
02853 
02854 */
02855 
02856 /* DISABLED
02857 
02858     template<>
02859     std::size_t RawSize<HistoryUpdateResponse>(const HistoryUpdateResponse& data)
02860     {
02861         size_t size = 0;
02862         size += RawSize(data.TypeId);
02863         size += RawSize(data.Header);
02864         size += RawSizeContainer(data.Results);
02865         size += RawSizeContainer(data.DiagnosticInfos);
02866         return size;
02867     }
02868 
02869 */
02870 
02871     template<>
02872     std::size_t RawSize<CallMethodRequest>(const CallMethodRequest& data)
02873     {
02874         size_t size = 0;
02875         size += RawSize(data.ObjectId);
02876         size += RawSize(data.MethodId);
02877         size += RawSizeContainer(data.InputArguments);
02878         return size;
02879     }
02880 
02881 
02882     template<>
02883     std::size_t RawSize<CallMethodResult>(const CallMethodResult& data)
02884     {
02885         size_t size = 0;
02886         size += RawSize(data.Status);
02887         size += RawSizeContainer(data.InputArgumentResults);
02888         size += RawSizeContainer(data.InputArgumentDiagnosticInfos);
02889         size += RawSizeContainer(data.OutputArguments);
02890         return size;
02891     }
02892 
02893 
02894     template<>
02895     std::size_t RawSize<CallRequest>(const CallRequest& data)
02896     {
02897         size_t size = 0;
02898         size += RawSize(data.TypeId);
02899         size += RawSize(data.Header);
02900         size += RawSizeContainer(data.MethodsToCall);
02901         return size;
02902     }
02903 
02904 
02905     template<>
02906     std::size_t RawSize<CallResponse>(const CallResponse& data)
02907     {
02908         size_t size = 0;
02909         size += RawSize(data.TypeId);
02910         size += RawSize(data.Header);
02911         size += RawSizeContainer(data.Results);
02912         size += RawSizeContainer(data.DiagnosticInfos);
02913         return size;
02914     }
02915 
02916 
02917 /* DISABLED
02918 
02919     template<>
02920     std::size_t RawSize<MonitoringFilter>(const MonitoringFilter& data)
02921     {
02922         size_t size = 0;
02923         size += RawSize(data.TypeId);
02924         size += RawSize(data.Encoding);
02925         if ((data.Encoding) & (1<<(0))) size += RawSize(data.Body);
02926         return size;
02927     }
02928 
02929 */
02930 
02931 /* DISABLED
02932 
02933     template<>
02934     std::size_t RawSize<DataChangeFilter>(const DataChangeFilter& data)
02935     {
02936         size_t size = 0;
02937         size += RawSize(data.TypeId);
02938         size += RawSize(data.Encoding);
02939         size += RawSize(data.BodyLength);
02940         size += RawSize(data.Trigger);
02941         size += RawSize(data.DeadbandType);
02942         size += RawSize(data.DeadbandValue);
02943         return size;
02944     }
02945 
02946 */
02947 
02948 /* DISABLED
02949 
02950     template<>
02951     std::size_t RawSize<EventFilter>(const EventFilter& data)
02952     {
02953         size_t size = 0;
02954         size += RawSize(data.TypeId);
02955         size += RawSize(data.Encoding);
02956         size += RawSize(data.BodyLength);
02957         size += RawSizeContainer(data.SelectClauses);
02958         size += RawSize(data.WhereClause);
02959         return size;
02960     }
02961 
02962 */
02963 
02964 /* DISABLED
02965 
02966     template<>
02967     std::size_t RawSize<ReadEventDetails>(const ReadEventDetails& data)
02968     {
02969         size_t size = 0;
02970         size += RawSize(data.TypeId);
02971         size += RawSize(data.Encoding);
02972         size += RawSize(data.BodyLength);
02973         size += RawSize(data.NumValuesPerNode);
02974         size += RawSize(data.StartTime);
02975         size += RawSize(data.EndTime);
02976         size += RawSize(data.Filter);
02977         return size;
02978     }
02979 
02980 */
02981 
02982 /* DISABLED
02983 
02984     template<>
02985     std::size_t RawSize<AggregateConfiguration>(const AggregateConfiguration& data)
02986     {
02987         size_t size = 0;
02988         size += RawSize(data.UseServerCapabilitiesDefaults);
02989         size += RawSize(data.TreatUncertainAsBad);
02990         size += RawSize(data.PercentDataBad);
02991         size += RawSize(data.PercentDataGood);
02992         size += RawSize(data.UseSlopedExtrapolation);
02993         return size;
02994     }
02995 
02996 */
02997 
02998 /* DISABLED
02999 
03000     template<>
03001     std::size_t RawSize<ReadProcessedDetails>(const ReadProcessedDetails& data)
03002     {
03003         size_t size = 0;
03004         size += RawSize(data.TypeId);
03005         size += RawSize(data.Encoding);
03006         size += RawSize(data.BodyLength);
03007         size += RawSize(data.StartTime);
03008         size += RawSize(data.EndTime);
03009         size += RawSize(data.ProcessingInterval);
03010         size += RawSizeContainer(data.AggregateType);
03011         size += RawSize(data.AggregateConfiguration);
03012         return size;
03013     }
03014 
03015 */
03016 
03017 /* DISABLED
03018 
03019     template<>
03020     std::size_t RawSize<AggregateFilter>(const AggregateFilter& data)
03021     {
03022         size_t size = 0;
03023         size += RawSize(data.TypeId);
03024         size += RawSize(data.Encoding);
03025         size += RawSize(data.BodyLength);
03026         size += RawSize(data.StartTime);
03027         size += RawSize(data.AggregateType);
03028         size += RawSize(data.ProcessingInterval);
03029         size += RawSize(data.AggregateConfiguration);
03030         return size;
03031     }
03032 
03033 */
03034 
03035 /* DISABLED
03036 
03037     template<>
03038     std::size_t RawSize<MonitoringFilterResult>(const MonitoringFilterResult& data)
03039     {
03040         size_t size = 0;
03041         size += RawSize(data.TypeId);
03042         size += RawSize(data.Encoding);
03043         if ((data.Encoding) & (1<<(0))) size += RawSize(data.Body);
03044         return size;
03045     }
03046 
03047 */
03048 
03049 /* DISABLED
03050 
03051     template<>
03052     std::size_t RawSize<EventFilterResult>(const EventFilterResult& data)
03053     {
03054         size_t size = 0;
03055         size += RawSize(data.TypeId);
03056         size += RawSize(data.Encoding);
03057         size += RawSize(data.BodyLength);
03058         size += RawSizeContainer(data.SelectClauseResults);
03059         size += RawSizeContainer(data.SelectClauseDiagnosticInfos);
03060         size += RawSize(data.WhereClauseResult);
03061         return size;
03062     }
03063 
03064 */
03065 
03066 /* DISABLED
03067 
03068     template<>
03069     std::size_t RawSize<HistoryUpdateEventResult>(const HistoryUpdateEventResult& data)
03070     {
03071         size_t size = 0;
03072         size += RawSize(data.Status);
03073         size += RawSize(data.EventFilterResult);
03074         return size;
03075     }
03076 
03077 */
03078 
03079 /* DISABLED
03080 
03081     template<>
03082     std::size_t RawSize<AggregateFilterResult>(const AggregateFilterResult& data)
03083     {
03084         size_t size = 0;
03085         size += RawSize(data.TypeId);
03086         size += RawSize(data.Encoding);
03087         size += RawSize(data.BodyLength);
03088         size += RawSize(data.RevisedStartTime);
03089         size += RawSize(data.RevisedProcessingInterval);
03090         size += RawSize(data.RevisedAggregateConfiguration);
03091         return size;
03092     }
03093 
03094 */
03095 
03096     template<>
03097     std::size_t RawSize<MonitoringParameters>(const MonitoringParameters& data)
03098     {
03099         size_t size = 0;
03100         size += RawSize(data.ClientHandle);
03101         size += RawSize(data.SamplingInterval);
03102         size += RawSize(data.Filter);
03103         size += RawSize(data.QueueSize);
03104         size += RawSize(data.DiscardOldest);
03105         return size;
03106     }
03107 
03108 
03109     template<>
03110     std::size_t RawSize<MonitoredItemCreateRequest>(const MonitoredItemCreateRequest& data)
03111     {
03112         size_t size = 0;
03113         size += RawSize(data.ItemToMonitor);
03114         size += RawSize(data.MonitoringMode);
03115         size += RawSize(data.RequestedParameters);
03116         return size;
03117     }
03118 
03119 
03120     template<>
03121     std::size_t RawSize<MonitoredItemCreateResult>(const MonitoredItemCreateResult& data)
03122     {
03123         size_t size = 0;
03124         size += RawSize(data.Status);
03125         size += RawSize(data.MonitoredItemId);
03126         size += RawSize(data.RevisedSamplingInterval);
03127         size += RawSize(data.RevisedQueueSize);
03128         size += RawSize(data.FilterResult);
03129         return size;
03130     }
03131 
03132 
03133     template<>
03134     std::size_t RawSize<MonitoredItemsParameters>(const MonitoredItemsParameters& data)
03135     {
03136         size_t size = 0;
03137         size += RawSize(data.SubscriptionId);
03138         size += RawSize(data.TimestampsToReturn);
03139         size += RawSizeContainer(data.ItemsToCreate);
03140         return size;
03141     }
03142 
03143 
03144     template<>
03145     std::size_t RawSize<CreateMonitoredItemsRequest>(const CreateMonitoredItemsRequest& data)
03146     {
03147         size_t size = 0;
03148         size += RawSize(data.TypeId);
03149         size += RawSize(data.Header);
03150         size += RawSize(data.Parameters);
03151         return size;
03152     }
03153 
03154 
03155     template<>
03156     std::size_t RawSize<CreateMonitoredItemsResponse>(const CreateMonitoredItemsResponse& data)
03157     {
03158         size_t size = 0;
03159         size += RawSize(data.TypeId);
03160         size += RawSize(data.Header);
03161         size += RawSizeContainer(data.Results);
03162         size += RawSizeContainer(data.DiagnosticInfos);
03163         return size;
03164     }
03165 
03166 
03167 /* DISABLED
03168 
03169     template<>
03170     std::size_t RawSize<MonitoredItemModifyRequest>(const MonitoredItemModifyRequest& data)
03171     {
03172         size_t size = 0;
03173         size += RawSize(data.MonitoredItemId);
03174         size += RawSize(data.RequestedParameters);
03175         return size;
03176     }
03177 
03178 */
03179 
03180 /* DISABLED
03181 
03182     template<>
03183     std::size_t RawSize<MonitoredItemModifyResult>(const MonitoredItemModifyResult& data)
03184     {
03185         size_t size = 0;
03186         size += RawSize(data.Status);
03187         size += RawSize(data.RevisedSamplingInterval);
03188         size += RawSize(data.RevisedQueueSize);
03189         size += RawSize(data.FilterResult);
03190         return size;
03191     }
03192 
03193 */
03194 
03195 /* DISABLED
03196 
03197     template<>
03198     std::size_t RawSize<ModifyMonitoredItemsParameters>(const ModifyMonitoredItemsParameters& data)
03199     {
03200         size_t size = 0;
03201         size += RawSize(data.SubscriptionId);
03202         size += RawSize(data.TimestampsToReturn);
03203         size += RawSizeContainer(data.ItemsToModify);
03204         return size;
03205     }
03206 
03207 */
03208 
03209 /* DISABLED
03210 
03211     template<>
03212     std::size_t RawSize<ModifyMonitoredItemsRequest>(const ModifyMonitoredItemsRequest& data)
03213     {
03214         size_t size = 0;
03215         size += RawSize(data.TypeId);
03216         size += RawSize(data.Header);
03217         size += RawSize(data.Parameters);
03218         return size;
03219     }
03220 
03221 */
03222 
03223 /* DISABLED
03224 
03225     template<>
03226     std::size_t RawSize<ModifyMonitoredItemsResponse>(const ModifyMonitoredItemsResponse& data)
03227     {
03228         size_t size = 0;
03229         size += RawSize(data.TypeId);
03230         size += RawSize(data.Header);
03231         size += RawSizeContainer(data.Results);
03232         size += RawSizeContainer(data.DiagnosticInfos);
03233         return size;
03234     }
03235 
03236 */
03237 
03238 /* DISABLED
03239 
03240     template<>
03241     std::size_t RawSize<SetMonitoringModeParameters>(const SetMonitoringModeParameters& data)
03242     {
03243         size_t size = 0;
03244         size += RawSize(data.SubscriptionId);
03245         size += RawSize(data.MonitoringMode);
03246         size += RawSizeContainer(data.MonitoredItemIds);
03247         return size;
03248     }
03249 
03250 */
03251 
03252 /* DISABLED
03253 
03254     template<>
03255     std::size_t RawSize<SetMonitoringModeRequest>(const SetMonitoringModeRequest& data)
03256     {
03257         size_t size = 0;
03258         size += RawSize(data.TypeId);
03259         size += RawSize(data.Header);
03260         size += RawSize(data.Parameters);
03261         return size;
03262     }
03263 
03264 */
03265 
03266 /* DISABLED
03267 
03268     template<>
03269     std::size_t RawSize<SetMonitoringModeResult>(const SetMonitoringModeResult& data)
03270     {
03271         size_t size = 0;
03272         size += RawSizeContainer(data.Results);
03273         size += RawSizeContainer(data.DiagnosticInfos);
03274         return size;
03275     }
03276 
03277 */
03278 
03279 /* DISABLED
03280 
03281     template<>
03282     std::size_t RawSize<SetMonitoringModeResponse>(const SetMonitoringModeResponse& data)
03283     {
03284         size_t size = 0;
03285         size += RawSize(data.TypeId);
03286         size += RawSize(data.Header);
03287         size += RawSize(data.Parameters);
03288         return size;
03289     }
03290 
03291 */
03292 
03293 /* DISABLED
03294 
03295     template<>
03296     std::size_t RawSize<SetTriggeringParameters>(const SetTriggeringParameters& data)
03297     {
03298         size_t size = 0;
03299         size += RawSize(data.SubscriptionId);
03300         size += RawSize(data.TriggeringItemId);
03301         size += RawSizeContainer(data.LinksToAdd);
03302         size += RawSizeContainer(data.LinksToRemove);
03303         return size;
03304     }
03305 
03306 */
03307 
03308 /* DISABLED
03309 
03310     template<>
03311     std::size_t RawSize<SetTriggeringRequest>(const SetTriggeringRequest& data)
03312     {
03313         size_t size = 0;
03314         size += RawSize(data.TypeId);
03315         size += RawSize(data.Header);
03316         size += RawSize(data.Parameters);
03317         return size;
03318     }
03319 
03320 */
03321 
03322 /* DISABLED
03323 
03324     template<>
03325     std::size_t RawSize<SetTriggeringResult>(const SetTriggeringResult& data)
03326     {
03327         size_t size = 0;
03328         size += RawSizeContainer(data.AddResults);
03329         size += RawSizeContainer(data.AddDiagnosticInfos);
03330         size += RawSizeContainer(data.RemoveResults);
03331         size += RawSizeContainer(data.RemoveDiagnosticInfos);
03332         return size;
03333     }
03334 
03335 */
03336 
03337 /* DISABLED
03338 
03339     template<>
03340     std::size_t RawSize<SetTriggeringResponse>(const SetTriggeringResponse& data)
03341     {
03342         size_t size = 0;
03343         size += RawSize(data.TypeId);
03344         size += RawSize(data.Header);
03345         size += RawSize(data.Parameters);
03346         return size;
03347     }
03348 
03349 */
03350 
03351     template<>
03352     std::size_t RawSize<DeleteMonitoredItemsParameters>(const DeleteMonitoredItemsParameters& data)
03353     {
03354         size_t size = 0;
03355         size += RawSize(data.SubscriptionId);
03356         size += RawSizeContainer(data.MonitoredItemIds);
03357         return size;
03358     }
03359 
03360 
03361     template<>
03362     std::size_t RawSize<DeleteMonitoredItemsRequest>(const DeleteMonitoredItemsRequest& data)
03363     {
03364         size_t size = 0;
03365         size += RawSize(data.TypeId);
03366         size += RawSize(data.Header);
03367         size += RawSize(data.Parameters);
03368         return size;
03369     }
03370 
03371 
03372     template<>
03373     std::size_t RawSize<DeleteMonitoredItemsResponse>(const DeleteMonitoredItemsResponse& data)
03374     {
03375         size_t size = 0;
03376         size += RawSize(data.TypeId);
03377         size += RawSize(data.Header);
03378         size += RawSizeContainer(data.Results);
03379         size += RawSizeContainer(data.DiagnosticInfos);
03380         return size;
03381     }
03382 
03383 
03384     template<>
03385     std::size_t RawSize<CreateSubscriptionParameters>(const CreateSubscriptionParameters& data)
03386     {
03387         size_t size = 0;
03388         size += RawSize(data.RequestedPublishingInterval);
03389         size += RawSize(data.RequestedLifetimeCount);
03390         size += RawSize(data.RequestedMaxKeepAliveCount);
03391         size += RawSize(data.MaxNotificationsPerPublish);
03392         size += RawSize(data.PublishingEnabled);
03393         size += RawSize(data.Priority);
03394         return size;
03395     }
03396 
03397 
03398     template<>
03399     std::size_t RawSize<CreateSubscriptionRequest>(const CreateSubscriptionRequest& data)
03400     {
03401         size_t size = 0;
03402         size += RawSize(data.TypeId);
03403         size += RawSize(data.Header);
03404         size += RawSize(data.Parameters);
03405         return size;
03406     }
03407 
03408 
03409     template<>
03410     std::size_t RawSize<SubscriptionData>(const SubscriptionData& data)
03411     {
03412         size_t size = 0;
03413         size += RawSize(data.SubscriptionId);
03414         size += RawSize(data.RevisedPublishingInterval);
03415         size += RawSize(data.RevisedLifetimeCount);
03416         size += RawSize(data.RevisedMaxKeepAliveCount);
03417         return size;
03418     }
03419 
03420 
03421     template<>
03422     std::size_t RawSize<CreateSubscriptionResponse>(const CreateSubscriptionResponse& data)
03423     {
03424         size_t size = 0;
03425         size += RawSize(data.TypeId);
03426         size += RawSize(data.Header);
03427         size += RawSize(data.Data);
03428         return size;
03429     }
03430 
03431 
03432 /* DISABLED
03433 
03434     template<>
03435     std::size_t RawSize<ModifySubscriptionParameters>(const ModifySubscriptionParameters& data)
03436     {
03437         size_t size = 0;
03438         size += RawSize(data.SubscriptionId);
03439         size += RawSize(data.RequestedPublishingInterval);
03440         size += RawSize(data.RequestedLifetimeCount);
03441         size += RawSize(data.RequestedMaxKeepAliveCount);
03442         size += RawSize(data.MaxNotificationsPerPublish);
03443         size += RawSize(data.Priority);
03444         return size;
03445     }
03446 
03447 */
03448 
03449 /* DISABLED
03450 
03451     template<>
03452     std::size_t RawSize<ModifySubscriptionRequest>(const ModifySubscriptionRequest& data)
03453     {
03454         size_t size = 0;
03455         size += RawSize(data.TypeId);
03456         size += RawSize(data.Header);
03457         size += RawSize(data.Parameters);
03458         return size;
03459     }
03460 
03461 */
03462 
03463 /* DISABLED
03464 
03465     template<>
03466     std::size_t RawSize<ModifySubscriptionResult>(const ModifySubscriptionResult& data)
03467     {
03468         size_t size = 0;
03469         size += RawSize(data.RevisedPublishingInterval);
03470         size += RawSize(data.RevisedLifetimeCount);
03471         size += RawSize(data.RevisedMaxKeepAliveCount);
03472         return size;
03473     }
03474 
03475 */
03476 
03477 /* DISABLED
03478 
03479     template<>
03480     std::size_t RawSize<ModifySubscriptionResponse>(const ModifySubscriptionResponse& data)
03481     {
03482         size_t size = 0;
03483         size += RawSize(data.TypeId);
03484         size += RawSize(data.Header);
03485         size += RawSize(data.Parameters);
03486         return size;
03487     }
03488 
03489 */
03490 
03491     template<>
03492     std::size_t RawSize<PublishingModeParameters>(const PublishingModeParameters& data)
03493     {
03494         size_t size = 0;
03495         size += RawSize(data.PublishingEnabled);
03496         size += RawSizeContainer(data.SubscriptionIds);
03497         return size;
03498     }
03499 
03500 
03501     template<>
03502     std::size_t RawSize<SetPublishingModeRequest>(const SetPublishingModeRequest& data)
03503     {
03504         size_t size = 0;
03505         size += RawSize(data.TypeId);
03506         size += RawSize(data.Header);
03507         size += RawSize(data.Parameters);
03508         return size;
03509     }
03510 
03511 
03512     template<>
03513     std::size_t RawSize<PublishingModeResult>(const PublishingModeResult& data)
03514     {
03515         size_t size = 0;
03516         size += RawSizeContainer(data.Results);
03517         size += RawSizeContainer(data.DiagnosticInfos);
03518         return size;
03519     }
03520 
03521 
03522     template<>
03523     std::size_t RawSize<SetPublishingModeResponse>(const SetPublishingModeResponse& data)
03524     {
03525         size_t size = 0;
03526         size += RawSize(data.TypeId);
03527         size += RawSize(data.Header);
03528         size += RawSize(data.Result);
03529         return size;
03530     }
03531 
03532 
03533     template<>
03534     std::size_t RawSize<NotificationMessage>(const NotificationMessage& data)
03535     {
03536         size_t size = 0;
03537         size += RawSize(data.SequenceNumber);
03538         size += RawSize(data.PublishTime);
03539         size += RawSizeContainer(data.NotificationData);
03540         return size;
03541     }
03542 
03543 
03544 /* DISABLED
03545 
03546     template<>
03547     std::size_t RawSize<NotificationData>(const NotificationData& data)
03548     {
03549         size_t size = 0;
03550         size += RawSize(data.TypeId);
03551         size += RawSize(data.Encoding);
03552         if ((data.Encoding) & (1<<(0))) size += RawSize(data.Body);
03553         return size;
03554     }
03555 
03556 */
03557 
03558 /* DISABLED
03559 
03560     template<>
03561     std::size_t RawSize<MonitoredItemNotification>(const MonitoredItemNotification& data)
03562     {
03563         size_t size = 0;
03564         size += RawSize(data.ClientHandle);
03565         size += RawSize(data.Value);
03566         return size;
03567     }
03568 
03569 */
03570 
03571 /* DISABLED
03572 
03573     template<>
03574     std::size_t RawSize<DataChangeNotification>(const DataChangeNotification& data)
03575     {
03576         size_t size = 0;
03577         size += RawSize(data.TypeId);
03578         size += RawSize(data.Encoding);
03579         size += RawSize(data.BodyLength);
03580         size += RawSizeContainer(data.MonitoredItems);
03581         size += RawSizeContainer(data.DiagnosticInfos);
03582         return size;
03583     }
03584 
03585 */
03586 
03587 /* DISABLED
03588 
03589     template<>
03590     std::size_t RawSize<EventFieldList>(const EventFieldList& data)
03591     {
03592         size_t size = 0;
03593         size += RawSize(data.ClientHandle);
03594         size += RawSizeContainer(data.EventFields);
03595         return size;
03596     }
03597 
03598 */
03599 
03600 /* DISABLED
03601 
03602     template<>
03603     std::size_t RawSize<EventNotificationList>(const EventNotificationList& data)
03604     {
03605         size_t size = 0;
03606         size += RawSize(data.TypeId);
03607         size += RawSize(data.Encoding);
03608         size += RawSize(data.BodyLength);
03609         size += RawSizeContainer(data.Events);
03610         return size;
03611     }
03612 
03613 */
03614 
03615 /* DISABLED
03616 
03617     template<>
03618     std::size_t RawSize<HistoryEventFieldList>(const HistoryEventFieldList& data)
03619     {
03620         size_t size = 0;
03621         size += RawSizeContainer(data.EventFields);
03622         return size;
03623     }
03624 
03625 */
03626 
03627 /* DISABLED
03628 
03629     template<>
03630     std::size_t RawSize<HistoryEvent>(const HistoryEvent& data)
03631     {
03632         size_t size = 0;
03633         size += RawSizeContainer(data.Events);
03634         return size;
03635     }
03636 
03637 */
03638 
03639 /* DISABLED
03640 
03641     template<>
03642     std::size_t RawSize<UpdateEventDetails>(const UpdateEventDetails& data)
03643     {
03644         size_t size = 0;
03645         size += RawSize(data.NodeId);
03646         size += RawSize(data.PerformInsertReplace);
03647         size += RawSize(data.Filter);
03648         size += RawSizeContainer(data.EventData);
03649         return size;
03650     }
03651 
03652 */
03653 
03654 /* DISABLED
03655 
03656     template<>
03657     std::size_t RawSize<StatusChangeNotification>(const StatusChangeNotification& data)
03658     {
03659         size_t size = 0;
03660         size += RawSize(data.TypeId);
03661         size += RawSize(data.Encoding);
03662         size += RawSize(data.BodyLength);
03663         size += RawSize(data.Status);
03664         size += RawSize(data.DiagnosticInfo);
03665         return size;
03666     }
03667 
03668 */
03669 
03670     template<>
03671     std::size_t RawSize<SubscriptionAcknowledgement>(const SubscriptionAcknowledgement& data)
03672     {
03673         size_t size = 0;
03674         size += RawSize(data.SubscriptionId);
03675         size += RawSize(data.SequenceNumber);
03676         return size;
03677     }
03678 
03679 
03680     template<>
03681     std::size_t RawSize<PublishRequest>(const PublishRequest& data)
03682     {
03683         size_t size = 0;
03684         size += RawSize(data.TypeId);
03685         size += RawSize(data.Header);
03686         size += RawSizeContainer(data.SubscriptionAcknowledgements);
03687         return size;
03688     }
03689 
03690 
03691     template<>
03692     std::size_t RawSize<PublishResult>(const PublishResult& data)
03693     {
03694         size_t size = 0;
03695         size += RawSize(data.SubscriptionId);
03696         size += RawSizeContainer(data.AvailableSequenceNumbers);
03697         size += RawSize(data.MoreNotifications);
03698         size += RawSize(data.NotificationMessage);
03699         size += RawSizeContainer(data.Results);
03700         size += RawSizeContainer(data.DiagnosticInfos);
03701         return size;
03702     }
03703 
03704 
03705     template<>
03706     std::size_t RawSize<PublishResponse>(const PublishResponse& data)
03707     {
03708         size_t size = 0;
03709         size += RawSize(data.TypeId);
03710         size += RawSize(data.Header);
03711         size += RawSize(data.Parameters);
03712         return size;
03713     }
03714 
03715 
03716     template<>
03717     std::size_t RawSize<RepublishParameters>(const RepublishParameters& data)
03718     {
03719         size_t size = 0;
03720         size += RawSize(data.SubscriptionId);
03721         size += RawSize(data.RetransmitSequenceNumber);
03722         return size;
03723     }
03724 
03725 
03726     template<>
03727     std::size_t RawSize<RepublishRequest>(const RepublishRequest& data)
03728     {
03729         size_t size = 0;
03730         size += RawSize(data.TypeId);
03731         size += RawSize(data.Header);
03732         size += RawSize(data.Parameters);
03733         return size;
03734     }
03735 
03736 
03737     template<>
03738     std::size_t RawSize<RepublishResponse>(const RepublishResponse& data)
03739     {
03740         size_t size = 0;
03741         size += RawSize(data.TypeId);
03742         size += RawSize(data.Header);
03743         size += RawSize(data.NotificationMessage);
03744         return size;
03745     }
03746 
03747 
03748 /* DISABLED
03749 
03750     template<>
03751     std::size_t RawSize<TransferResult>(const TransferResult& data)
03752     {
03753         size_t size = 0;
03754         size += RawSize(data.Status);
03755         size += RawSizeContainer(data.AvailableSequenceNumbers);
03756         return size;
03757     }
03758 
03759 */
03760 
03761 /* DISABLED
03762 
03763     template<>
03764     std::size_t RawSize<TransferSubscriptionsParameters>(const TransferSubscriptionsParameters& data)
03765     {
03766         size_t size = 0;
03767         size += RawSizeContainer(data.SubscriptionIds);
03768         size += RawSize(data.SendInitialValues);
03769         return size;
03770     }
03771 
03772 */
03773 
03774 /* DISABLED
03775 
03776     template<>
03777     std::size_t RawSize<TransferSubscriptionsRequest>(const TransferSubscriptionsRequest& data)
03778     {
03779         size_t size = 0;
03780         size += RawSize(data.TypeId);
03781         size += RawSize(data.Header);
03782         size += RawSize(data.Parameters);
03783         return size;
03784     }
03785 
03786 */
03787 
03788 /* DISABLED
03789 
03790     template<>
03791     std::size_t RawSize<TransferSubscriptionsResult>(const TransferSubscriptionsResult& data)
03792     {
03793         size_t size = 0;
03794         size += RawSizeContainer(data.Results);
03795         size += RawSizeContainer(data.DiagnosticInfos);
03796         return size;
03797     }
03798 
03799 */
03800 
03801 /* DISABLED
03802 
03803     template<>
03804     std::size_t RawSize<TransferSubscriptionsResponse>(const TransferSubscriptionsResponse& data)
03805     {
03806         size_t size = 0;
03807         size += RawSize(data.TypeId);
03808         size += RawSize(data.Header);
03809         size += RawSize(data.Parameters);
03810         return size;
03811     }
03812 
03813 */
03814 
03815     template<>
03816     std::size_t RawSize<DeleteSubscriptionsRequest>(const DeleteSubscriptionsRequest& data)
03817     {
03818         size_t size = 0;
03819         size += RawSize(data.TypeId);
03820         size += RawSize(data.Header);
03821         size += RawSizeContainer(data.SubscriptionIds);
03822         return size;
03823     }
03824 
03825 
03826     template<>
03827     std::size_t RawSize<DeleteSubscriptionsResponse>(const DeleteSubscriptionsResponse& data)
03828     {
03829         size_t size = 0;
03830         size += RawSize(data.TypeId);
03831         size += RawSize(data.Header);
03832         size += RawSizeContainer(data.Results);
03833         size += RawSizeContainer(data.DiagnosticInfos);
03834         return size;
03835     }
03836 
03837 
03838 /* DISABLED
03839 
03840     template<>
03841     std::size_t RawSize<ScalarTestType>(const ScalarTestType& data)
03842     {
03843         size_t size = 0;
03844         size += RawSize(data.Boolean);
03845         size += RawSize(data.SByte);
03846         size += RawSize(data.Byte);
03847         size += RawSize(data.Int16);
03848         size += RawSize(data.UInt16);
03849         size += RawSize(data.Int32);
03850         size += RawSize(data.UInt32);
03851         size += RawSize(data.Int64);
03852         size += RawSize(data.UInt64);
03853         size += RawSize(data.Float);
03854         size += RawSize(data.Double);
03855         size += RawSize(data.String);
03856         size += RawSize(data.DateTime);
03857         size += RawSize(data.Guid);
03858         size += RawSize(data.ByteString);
03859         size += RawSize(data.XmlElement);
03860         size += RawSize(data.NodeId);
03861         size += RawSize(data.ExpandedNodeId);
03862         size += RawSize(data.Status);
03863         size += RawSize(data.DiagnosticInfo);
03864         size += RawSize(data.QualifiedName);
03865         size += RawSize(data.LocalizedText);
03866         size += RawSize(data.ExtensionObject);
03867         size += RawSize(data.DataValue);
03868         size += RawSize(data.EnumeratedValue);
03869         return size;
03870     }
03871 
03872 */
03873 
03874 /* DISABLED
03875 
03876     template<>
03877     std::size_t RawSize<ArrayTestType>(const ArrayTestType& data)
03878     {
03879         size_t size = 0;
03880         size += RawSizeContainer(data.Booleans);
03881         size += RawSizeContainer(data.SBytes);
03882         size += RawSizeContainer(data.Int16s);
03883         size += RawSizeContainer(data.UInt16s);
03884         size += RawSizeContainer(data.Int32s);
03885         size += RawSizeContainer(data.UInt32s);
03886         size += RawSizeContainer(data.Int64s);
03887         size += RawSizeContainer(data.UInt64s);
03888         size += RawSizeContainer(data.Floats);
03889         size += RawSizeContainer(data.Doubles);
03890         size += RawSizeContainer(data.Strings);
03891         size += RawSizeContainer(data.DateTimes);
03892         size += RawSizeContainer(data.Guids);
03893         size += RawSizeContainer(data.ByteStrings);
03894         size += RawSizeContainer(data.XmlElements);
03895         size += RawSizeContainer(data.NodeIds);
03896         size += RawSizeContainer(data.ExpandedNodeIds);
03897         size += RawSizeContainer(data.StatusCodes);
03898         size += RawSizeContainer(data.DiagnosticInfos);
03899         size += RawSizeContainer(data.QualifiedNames);
03900         size += RawSizeContainer(data.LocalizedTexts);
03901         size += RawSizeContainer(data.ExtensionObjects);
03902         size += RawSizeContainer(data.DataValues);
03903         size += RawSizeContainer(data.Variants);
03904         size += RawSizeContainer(data.EnumeratedValues);
03905         return size;
03906     }
03907 
03908 */
03909 
03910 /* DISABLED
03911 
03912     template<>
03913     std::size_t RawSize<CompositeTestType>(const CompositeTestType& data)
03914     {
03915         size_t size = 0;
03916         size += RawSize(data.Field1);
03917         size += RawSize(data.Field2);
03918         return size;
03919     }
03920 
03921 */
03922 
03923 /* DISABLED
03924 
03925     template<>
03926     std::size_t RawSize<TestStackParameters>(const TestStackParameters& data)
03927     {
03928         size_t size = 0;
03929         size += RawSize(data.TestId);
03930         size += RawSize(data.Iteration);
03931         size += RawSize(data.Input);
03932         return size;
03933     }
03934 
03935 */
03936 
03937 /* DISABLED
03938 
03939     template<>
03940     std::size_t RawSize<TestStackRequest>(const TestStackRequest& data)
03941     {
03942         size_t size = 0;
03943         size += RawSize(data.TypeId);
03944         size += RawSize(data.Header);
03945         size += RawSize(data.Parameters);
03946         return size;
03947     }
03948 
03949 */
03950 
03951 /* DISABLED
03952 
03953     template<>
03954     std::size_t RawSize<TestStackResult>(const TestStackResult& data)
03955     {
03956         size_t size = 0;
03957         size += RawSize(data.Output);
03958         return size;
03959     }
03960 
03961 */
03962 
03963 /* DISABLED
03964 
03965     template<>
03966     std::size_t RawSize<TestStackResponse>(const TestStackResponse& data)
03967     {
03968         size_t size = 0;
03969         size += RawSize(data.TypeId);
03970         size += RawSize(data.Header);
03971         size += RawSize(data.Parameters);
03972         return size;
03973     }
03974 
03975 */
03976 
03977 /* DISABLED
03978 
03979     template<>
03980     std::size_t RawSize<TestStackExParameters>(const TestStackExParameters& data)
03981     {
03982         size_t size = 0;
03983         size += RawSize(data.TestId);
03984         size += RawSize(data.Iteration);
03985         size += RawSize(data.Input);
03986         return size;
03987     }
03988 
03989 */
03990 
03991 /* DISABLED
03992 
03993     template<>
03994     std::size_t RawSize<TestStackExRequest>(const TestStackExRequest& data)
03995     {
03996         size_t size = 0;
03997         size += RawSize(data.TypeId);
03998         size += RawSize(data.Header);
03999         size += RawSize(data.Parameters);
04000         return size;
04001     }
04002 
04003 */
04004 
04005 /* DISABLED
04006 
04007     template<>
04008     std::size_t RawSize<TestStackExResult>(const TestStackExResult& data)
04009     {
04010         size_t size = 0;
04011         size += RawSize(data.Output);
04012         return size;
04013     }
04014 
04015 */
04016 
04017 /* DISABLED
04018 
04019     template<>
04020     std::size_t RawSize<TestStackExResponse>(const TestStackExResponse& data)
04021     {
04022         size_t size = 0;
04023         size += RawSize(data.TypeId);
04024         size += RawSize(data.Header);
04025         size += RawSize(data.Parameters);
04026         return size;
04027     }
04028 
04029 */
04030 
04031 /* DISABLED
04032 
04033     template<>
04034     std::size_t RawSize<BuildInfo>(const BuildInfo& data)
04035     {
04036         size_t size = 0;
04037         size += RawSize(data.ProductUri);
04038         size += RawSize(data.ManufacturerName);
04039         size += RawSize(data.ProductName);
04040         size += RawSize(data.SoftwareVersion);
04041         size += RawSize(data.BuildNumber);
04042         size += RawSize(data.BuildDate);
04043         return size;
04044     }
04045 
04046 */
04047 
04048 /* DISABLED
04049 
04050     template<>
04051     std::size_t RawSize<RedundantServerDataType>(const RedundantServerDataType& data)
04052     {
04053         size_t size = 0;
04054         size += RawSize(data.ServerId);
04055         size += RawSize(data.ServiceLevel);
04056         size += RawSize(data.ServerState);
04057         return size;
04058     }
04059 
04060 */
04061 
04062 /* DISABLED
04063 
04064     template<>
04065     std::size_t RawSize<EndpointUrlListDataType>(const EndpointUrlListDataType& data)
04066     {
04067         size_t size = 0;
04068         size += RawSizeContainer(data.EndpointUrlList);
04069         return size;
04070     }
04071 
04072 */
04073 
04074 /* DISABLED
04075 
04076     template<>
04077     std::size_t RawSize<NetworkGroupDataType>(const NetworkGroupDataType& data)
04078     {
04079         size_t size = 0;
04080         size += RawSize(data.ServerUri);
04081         size += RawSizeContainer(data.NetworkPaths);
04082         return size;
04083     }
04084 
04085 */
04086 
04087 /* DISABLED
04088 
04089     template<>
04090     std::size_t RawSize<SamplingIntervalDiagnosticsDataType>(const SamplingIntervalDiagnosticsDataType& data)
04091     {
04092         size_t size = 0;
04093         size += RawSize(data.SamplingInterval);
04094         size += RawSize(data.MonitoredItemCount);
04095         size += RawSize(data.MaxMonitoredItemCount);
04096         size += RawSize(data.DisabledMonitoredItemCount);
04097         return size;
04098     }
04099 
04100 */
04101 
04102 /* DISABLED
04103 
04104     template<>
04105     std::size_t RawSize<ServerDiagnosticsSummaryDataType>(const ServerDiagnosticsSummaryDataType& data)
04106     {
04107         size_t size = 0;
04108         size += RawSize(data.ServerViewCount);
04109         size += RawSize(data.CurrentSessionCount);
04110         size += RawSize(data.CumulatedSessionCount);
04111         size += RawSize(data.SecurityRejectedSessionCount);
04112         size += RawSize(data.RejectedSessionCount);
04113         size += RawSize(data.SessionTimeoutCount);
04114         size += RawSize(data.SessionAbortCount);
04115         size += RawSize(data.CurrentSubscriptionCount);
04116         size += RawSize(data.CumulatedSubscriptionCount);
04117         size += RawSize(data.PublishingIntervalCount);
04118         size += RawSize(data.SecurityRejectedRequestsCount);
04119         size += RawSize(data.RejectedRequestsCount);
04120         return size;
04121     }
04122 
04123 */
04124 
04125 /* DISABLED
04126 
04127     template<>
04128     std::size_t RawSize<ServerStatusDataType>(const ServerStatusDataType& data)
04129     {
04130         size_t size = 0;
04131         size += RawSize(data.StartTime);
04132         size += RawSize(data.CurrentTime);
04133         size += RawSize(data.State);
04134         size += RawSize(data.BuildInfo);
04135         size += RawSize(data.SecondsTillShutdown);
04136         size += RawSize(data.ShutdownReason);
04137         return size;
04138     }
04139 
04140 */
04141 
04142 /* DISABLED
04143 
04144     template<>
04145     std::size_t RawSize<SessionSecurityDiagnosticsDataType>(const SessionSecurityDiagnosticsDataType& data)
04146     {
04147         size_t size = 0;
04148         size += RawSize(data.SessionId);
04149         size += RawSize(data.ClientUserIdOfSession);
04150         size += RawSizeContainer(data.ClientUserIdHistory);
04151         size += RawSize(data.AuthenticationMechanism);
04152         size += RawSize(data.Encoding);
04153         size += RawSize(data.TransportProtocol);
04154         size += RawSize(data.SecurityMode);
04155         size += RawSize(data.SecurityPolicyUri);
04156         size += RawSize(data.ClientCertificate);
04157         return size;
04158     }
04159 
04160 */
04161 
04162 /* DISABLED
04163 
04164     template<>
04165     std::size_t RawSize<ServiceCounterDataType>(const ServiceCounterDataType& data)
04166     {
04167         size_t size = 0;
04168         size += RawSize(data.TotalCount);
04169         size += RawSize(data.ErrorCount);
04170         return size;
04171     }
04172 
04173 */
04174 
04175 /* DISABLED
04176 
04177     template<>
04178     std::size_t RawSize<SessionDiagnosticsDataType>(const SessionDiagnosticsDataType& data)
04179     {
04180         size_t size = 0;
04181         size += RawSize(data.SessionId);
04182         size += RawSize(data.SessionName);
04183         size += RawSize(data.ClientDescription);
04184         size += RawSize(data.ServerUri);
04185         size += RawSize(data.EndpointUrl);
04186         size += RawSizeContainer(data.LocaleIds);
04187         size += RawSize(data.ActualSessionTimeout);
04188         size += RawSize(data.MaxResponseMessageSize);
04189         size += RawSize(data.ClientConnectionTime);
04190         size += RawSize(data.ClientLastContactTime);
04191         size += RawSize(data.CurrentSubscriptionsCount);
04192         size += RawSize(data.CurrentMonitoredItemsCount);
04193         size += RawSize(data.CurrentPublishRequestsInQueue);
04194         size += RawSize(data.TotalRequestCount);
04195         size += RawSize(data.UnauthorizedRequestCount);
04196         size += RawSize(data.ReadCount);
04197         size += RawSize(data.HistoryReadCount);
04198         size += RawSize(data.WriteCount);
04199         size += RawSize(data.HistoryUpdateCount);
04200         size += RawSize(data.CallCount);
04201         size += RawSize(data.CreateMonitoredItemsCount);
04202         size += RawSize(data.ModifyMonitoredItemsCount);
04203         size += RawSize(data.SetMonitoringModeCount);
04204         size += RawSize(data.SetTriggeringCount);
04205         size += RawSize(data.DeleteMonitoredItemsCount);
04206         size += RawSize(data.CreateSubscriptionCount);
04207         size += RawSize(data.ModifySubscriptionCount);
04208         size += RawSize(data.SetPublishingModeCount);
04209         size += RawSize(data.PublishCount);
04210         size += RawSize(data.RepublishCount);
04211         size += RawSize(data.TransferSubscriptionsCount);
04212         size += RawSize(data.DeleteSubscriptionsCount);
04213         size += RawSize(data.AddNodesCount);
04214         size += RawSize(data.AddReferencesCount);
04215         size += RawSize(data.DeleteNodesCount);
04216         size += RawSize(data.DeleteReferencesCount);
04217         size += RawSize(data.BrowseCount);
04218         size += RawSize(data.BrowseNextCount);
04219         size += RawSize(data.TranslateBrowsePathsToNodeIdsCount);
04220         size += RawSize(data.QueryFirstCount);
04221         size += RawSize(data.QueryNextCount);
04222         size += RawSize(data.RegisterNodesCount);
04223         size += RawSize(data.UnregisterNodesCount);
04224         return size;
04225     }
04226 
04227 */
04228 
04229 /* DISABLED
04230 
04231     template<>
04232     std::size_t RawSize<StatusResult>(const StatusResult& data)
04233     {
04234         size_t size = 0;
04235         size += RawSize(data.Status);
04236         size += RawSize(data.DiagnosticInfo);
04237         return size;
04238     }
04239 
04240 */
04241 
04242 /* DISABLED
04243 
04244     template<>
04245     std::size_t RawSize<SubscriptionDiagnosticsDataType>(const SubscriptionDiagnosticsDataType& data)
04246     {
04247         size_t size = 0;
04248         size += RawSize(data.SessionId);
04249         size += RawSize(data.SubscriptionId);
04250         size += RawSize(data.Priority);
04251         size += RawSize(data.PublishingInterval);
04252         size += RawSize(data.MaxKeepAliveCount);
04253         size += RawSize(data.MaxLifetimeCount);
04254         size += RawSize(data.MaxNotificationsPerPublish);
04255         size += RawSize(data.PublishingEnabled);
04256         size += RawSize(data.ModifyCount);
04257         size += RawSize(data.EnableCount);
04258         size += RawSize(data.DisableCount);
04259         size += RawSize(data.RepublishRequestCount);
04260         size += RawSize(data.RepublishMessageRequestCount);
04261         size += RawSize(data.RepublishMessageCount);
04262         size += RawSize(data.TransferRequestCount);
04263         size += RawSize(data.TransferredToAltClientCount);
04264         size += RawSize(data.TransferredToSameClientCount);
04265         size += RawSize(data.PublishRequestCount);
04266         size += RawSize(data.DataChangeNotificationsCount);
04267         size += RawSize(data.EventNotificationsCount);
04268         size += RawSize(data.NotificationsCount);
04269         size += RawSize(data.LatePublishRequestCount);
04270         size += RawSize(data.CurrentKeepAliveCount);
04271         size += RawSize(data.CurrentLifetimeCount);
04272         size += RawSize(data.UnacknowledgedMessageCount);
04273         size += RawSize(data.DiscardedMessageCount);
04274         size += RawSize(data.MonitoredItemCount);
04275         size += RawSize(data.DisabledMonitoredItemCount);
04276         size += RawSize(data.MonitoringQueueOverflowCount);
04277         size += RawSize(data.NextSequenceNumber);
04278         size += RawSize(data.EventQueueOverFlowCount);
04279         return size;
04280     }
04281 
04282 */
04283 
04284 /* DISABLED
04285 
04286     template<>
04287     std::size_t RawSize<ModelChangeStructureDataType>(const ModelChangeStructureDataType& data)
04288     {
04289         size_t size = 0;
04290         size += RawSize(data.Affected);
04291         size += RawSize(data.AffectedType);
04292         size += RawSize(data.Verb);
04293         return size;
04294     }
04295 
04296 */
04297 
04298 /* DISABLED
04299 
04300     template<>
04301     std::size_t RawSize<SemanticChangeStructureDataType>(const SemanticChangeStructureDataType& data)
04302     {
04303         size_t size = 0;
04304         size += RawSize(data.Affected);
04305         size += RawSize(data.AffectedType);
04306         return size;
04307     }
04308 
04309 */
04310 
04311 /* DISABLED
04312 
04313     template<>
04314     std::size_t RawSize<Range>(const Range& data)
04315     {
04316         size_t size = 0;
04317         size += RawSize(data.Low);
04318         size += RawSize(data.High);
04319         return size;
04320     }
04321 
04322 */
04323 
04324 /* DISABLED
04325 
04326     template<>
04327     std::size_t RawSize<EUInformation>(const EUInformation& data)
04328     {
04329         size_t size = 0;
04330         size += RawSize(data.NamespaceUri);
04331         size += RawSize(data.UnitId);
04332         size += RawSize(data.DisplayName);
04333         size += RawSize(data.Description);
04334         return size;
04335     }
04336 
04337 */
04338 
04339 /* DISABLED
04340 
04341     template<>
04342     std::size_t RawSize<ComplexNumberType>(const ComplexNumberType& data)
04343     {
04344         size_t size = 0;
04345         size += RawSize(data.Real);
04346         size += RawSize(data.Imaginary);
04347         return size;
04348     }
04349 
04350 */
04351 
04352 /* DISABLED
04353 
04354     template<>
04355     std::size_t RawSize<DoubleComplexNumberType>(const DoubleComplexNumberType& data)
04356     {
04357         size_t size = 0;
04358         size += RawSize(data.Real);
04359         size += RawSize(data.Imaginary);
04360         return size;
04361     }
04362 
04363 */
04364 
04365 /* DISABLED
04366 
04367     template<>
04368     std::size_t RawSize<AxisInformation>(const AxisInformation& data)
04369     {
04370         size_t size = 0;
04371         size += RawSize(data.EngineeringUnits);
04372         size += RawSize(data.EURange);
04373         size += RawSize(data.Title);
04374         size += RawSize(data.AxisScaleType);
04375         size += RawSizeContainer(data.AxisSteps);
04376         return size;
04377     }
04378 
04379 */
04380 
04381 /* DISABLED
04382 
04383     template<>
04384     std::size_t RawSize<XVType>(const XVType& data)
04385     {
04386         size_t size = 0;
04387         size += RawSize(data.X);
04388         size += RawSize(data.Value);
04389         return size;
04390     }
04391 
04392 */
04393 
04394 /* DISABLED
04395 
04396     template<>
04397     std::size_t RawSize<ProgramDiagnosticDataType>(const ProgramDiagnosticDataType& data)
04398     {
04399         size_t size = 0;
04400         size += RawSize(data.CreateSessionId);
04401         size += RawSize(data.CreateClientName);
04402         size += RawSize(data.InvocationCreationTime);
04403         size += RawSize(data.LastTransitionTime);
04404         size += RawSize(data.LastMethodCall);
04405         size += RawSize(data.LastMethodSessionId);
04406         size += RawSizeContainer(data.LastMethodInputArguments);
04407         size += RawSizeContainer(data.LastMethodOutputArguments);
04408         size += RawSize(data.LastMethodCallTime);
04409         size += RawSize(data.LastMethodReturnStatus);
04410         return size;
04411     }
04412 
04413 */
04414 
04415     template<>
04416     std::size_t RawSize<Annotation>(const Annotation& data)
04417     {
04418         size_t size = 0;
04419         size += RawSize(data.Message);
04420         size += RawSize(data.UserName);
04421         size += RawSize(data.AnnotationTime);
04422         return size;
04423     }
04424 
04425 
04426    }
04427 
04428 } // namespace
04429