1 karl 1.26 //%2006////////////////////////////////////////////////////////////////////////
|
2 kumpf 1.1 //
|
3 karl 1.16 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 kumpf 1.1 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.16 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.20 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.26 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 kumpf 1.1 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
15 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
18 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
20 //
21 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
|
34 kumpf 1.9 #include <Pegasus/Common/XmlWriter.h>
35 #include <Pegasus/Common/OperationContextInternal.h>
36
|
37 kumpf 1.1 #include "CIMMessageSerializer.h"
38
39 PEGASUS_NAMESPACE_BEGIN
40
|
41 mike 1.22 void CIMMessageSerializer::serialize(Buffer& out, CIMMessage* cimMessage)
|
42 kumpf 1.1 {
43 if (cimMessage == 0)
44 {
45 // No message to serialize
46 return;
47 }
48
49 // ATTN: Need to serialize the Message class members?
50
51 XmlWriter::append(out, "<PGMESSAGE ID=\"");
52 XmlWriter::append(out, cimMessage->messageId);
53 XmlWriter::append(out, "\" TYPE=\"");
54 XmlWriter::append(out, cimMessage->getType());
55 XmlWriter::append(out, "\">");
56
|
57 kumpf 1.23 #ifndef PEGASUS_DISABLE_PERFINST
58 // Serialize the statistics data
59
60 XmlWriter::appendValueElement(
|
61 kumpf 1.34 out, cimMessage->getServerStartTime());
|
62 kumpf 1.23 XmlWriter::appendValueElement(
|
63 kumpf 1.34 out, cimMessage->getProviderTime());
|
64 kumpf 1.23 #endif
65
|
66 kumpf 1.29 XmlWriter::appendValueElement(out, cimMessage->isComplete());
|
67 kumpf 1.30 XmlWriter::appendValueElement(out, cimMessage->getIndex());
|
68 kumpf 1.29
|
69 kumpf 1.11 _serializeOperationContext(out, cimMessage->operationContext);
|
70 kumpf 1.1
71 CIMRequestMessage* cimReqMessage;
72 cimReqMessage = dynamic_cast<CIMRequestMessage*>(cimMessage);
73
74 CIMResponseMessage* cimRespMessage;
75 cimRespMessage = dynamic_cast<CIMResponseMessage*>(cimMessage);
76
77 if (cimReqMessage)
78 {
79 _serializeCIMRequestMessage(out, cimReqMessage);
80 }
|
81 kumpf 1.27 else
|
82 kumpf 1.1 {
|
83 kumpf 1.27 PEGASUS_ASSERT(cimRespMessage != 0);
|
84 kumpf 1.1 _serializeCIMResponseMessage(out, cimRespMessage);
85 }
86
87 XmlWriter::append(out, "</PGMESSAGE>");
88 }
89
90 //
91 // _serializeCIMRequestMessage
92 //
93 void CIMMessageSerializer::_serializeCIMRequestMessage(
|
94 mike 1.22 Buffer& out,
|
95 kumpf 1.1 CIMRequestMessage* cimMessage)
96 {
97 PEGASUS_ASSERT(cimMessage != 0);
98
99 XmlWriter::append(out, "<PGREQ>");
100
101 _serializeQueueIdStack(out, cimMessage->queueIds);
102
103 CIMOperationRequestMessage* cimOpReqMessage;
104 cimOpReqMessage = dynamic_cast<CIMOperationRequestMessage*>(cimMessage);
105
106 CIMIndicationRequestMessage* cimIndReqMessage;
107 cimIndReqMessage = dynamic_cast<CIMIndicationRequestMessage*>(cimMessage);
108
109 if (cimOpReqMessage)
110 {
111 XmlWriter::append(out, "<PGOPREQ>\n");
112
|
113 kumpf 1.32 _serializeUserInfo(
114 out, cimOpReqMessage->authType, cimOpReqMessage->userName);
|
115 kumpf 1.1 _serializeCIMNamespaceName(out, cimOpReqMessage->nameSpace);
116 _serializeCIMName(out, cimOpReqMessage->className);
117
118 // Encode cimOpReqMessage->providerType as an integer
119 XmlWriter::appendValueElement(out, cimOpReqMessage->providerType);
120
121 switch (cimMessage->getType())
122 {
|
123 kumpf 1.27 // A provider cannot implement these operation types, so the
124 // serialization of these messages is not implemented.
125 //case CIM_GET_CLASS_REQUEST_MESSAGE:
126 //case CIM_DELETE_CLASS_REQUEST_MESSAGE:
127 //case CIM_CREATE_CLASS_REQUEST_MESSAGE:
128 //case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
129 //case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:
130 //case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
131 //case CIM_GET_QUALIFIER_REQUEST_MESSAGE:
132 //case CIM_SET_QUALIFIER_REQUEST_MESSAGE:
133 //case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE:
134 //case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE:
|
135 kumpf 1.1
136 // Instance operations
137 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
138 _serializeCIMGetInstanceRequestMessage(
139 out, (CIMGetInstanceRequestMessage*)cimMessage);
140 break;
141 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
142 _serializeCIMDeleteInstanceRequestMessage(
143 out, (CIMDeleteInstanceRequestMessage*)cimMessage);
144 break;
145 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
146 _serializeCIMCreateInstanceRequestMessage(
147 out, (CIMCreateInstanceRequestMessage*)cimMessage);
148 break;
149 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
150 _serializeCIMModifyInstanceRequestMessage(
151 out, (CIMModifyInstanceRequestMessage*)cimMessage);
152 break;
153 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
154 _serializeCIMEnumerateInstancesRequestMessage(
155 out, (CIMEnumerateInstancesRequestMessage*)cimMessage);
156 kumpf 1.1 break;
157 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
158 _serializeCIMEnumerateInstanceNamesRequestMessage(
159 out, (CIMEnumerateInstanceNamesRequestMessage*)cimMessage);
160 break;
161 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
162 _serializeCIMExecQueryRequestMessage(
163 out, (CIMExecQueryRequestMessage*)cimMessage);
164 break;
165
166 // Property operations
167 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
168 _serializeCIMGetPropertyRequestMessage(
169 out, (CIMGetPropertyRequestMessage*)cimMessage);
170 break;
171 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
172 _serializeCIMSetPropertyRequestMessage(
173 out, (CIMSetPropertyRequestMessage*)cimMessage);
174 break;
175
176 // Association operations
177 kumpf 1.1 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
178 _serializeCIMAssociatorsRequestMessage(
179 out, (CIMAssociatorsRequestMessage*)cimMessage);
180 break;
181 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
182 _serializeCIMAssociatorNamesRequestMessage(
183 out, (CIMAssociatorNamesRequestMessage*)cimMessage);
184 break;
185 case CIM_REFERENCES_REQUEST_MESSAGE:
186 _serializeCIMReferencesRequestMessage(
187 out, (CIMReferencesRequestMessage*)cimMessage);
188 break;
189 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
190 _serializeCIMReferenceNamesRequestMessage(
191 out, (CIMReferenceNamesRequestMessage*)cimMessage);
192 break;
193
194 // Method operations
195 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
196 _serializeCIMInvokeMethodRequestMessage(
197 out, (CIMInvokeMethodRequestMessage*)cimMessage);
198 kumpf 1.1 break;
199
200 default:
201 PEGASUS_ASSERT(0);
202 }
203
204 XmlWriter::append(out, "</PGOPREQ>");
205 }
206 else if (cimIndReqMessage)
207 {
208 XmlWriter::append(out, "<PGINDREQ>");
209
|
210 kumpf 1.32 _serializeUserInfo(
211 out, cimIndReqMessage->authType, cimIndReqMessage->userName);
212
|
213 kumpf 1.1 switch (cimMessage->getType())
214 {
215 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
216 _serializeCIMCreateSubscriptionRequestMessage(
217 out, (CIMCreateSubscriptionRequestMessage*)cimMessage);
218 break;
219 case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
220 _serializeCIMModifySubscriptionRequestMessage(
221 out, (CIMModifySubscriptionRequestMessage*)cimMessage);
222 break;
223 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
224 _serializeCIMDeleteSubscriptionRequestMessage(
225 out, (CIMDeleteSubscriptionRequestMessage*)cimMessage);
226 break;
227 default:
228 PEGASUS_ASSERT(0);
229 }
230
231 XmlWriter::append(out, "</PGINDREQ>");
232 }
233 else // Other message types
234 kumpf 1.1 {
235 XmlWriter::append(out, "<PGOTHERREQ>");
236
237 switch (cimMessage->getType())
238 {
239 case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
240 _serializeCIMExportIndicationRequestMessage(
241 out, (CIMExportIndicationRequestMessage*)cimMessage);
242 break;
243 case CIM_PROCESS_INDICATION_REQUEST_MESSAGE:
244 _serializeCIMProcessIndicationRequestMessage(
245 out, (CIMProcessIndicationRequestMessage*)cimMessage);
246 break;
|
247 kumpf 1.27 //case CIM_NOTIFY_PROVIDER_REGISTRATION_REQUEST_MESSAGE:
|
248 kumpf 1.1 // ATTN: No need to serialize this yet
249 //_serializeCIMNotifyProviderRegistrationRequestMessage(
|
250 kumpf 1.35 // out,
251 // (CIMNotifyProviderRegistrationRequestMessage*)cimMessage);
|
252 kumpf 1.1 break;
|
253 kumpf 1.27 //case CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE:
|
254 kumpf 1.1 // ATTN: No need to serialize this yet
255 //_serializeCIMNotifyProviderTerminationRequestMessage(
256 // out, (CIMNotifyProviderTerminationRequestMessage*)cimMessage);
257 break;
|
258 kumpf 1.27 //case CIM_HANDLE_INDICATION_REQUEST_MESSAGE:
|
259 kumpf 1.1 // ATTN: No need to serialize this yet
260 //_serializeCIMHandleIndicationRequestMessage(
261 // out, (CIMHandleIndicationRequestMessage*)cimMessage);
262 break;
263 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
264 _serializeCIMDisableModuleRequestMessage(
265 out, (CIMDisableModuleRequestMessage*)cimMessage);
266 break;
267 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
268 _serializeCIMEnableModuleRequestMessage(
269 out, (CIMEnableModuleRequestMessage*)cimMessage);
270 break;
|
271 kumpf 1.27 //case CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE:
|
272 kumpf 1.1 // ATTN: No need to serialize this yet
273 //_serializeCIMNotifyProviderEnableRequestMessage(
274 // out, (CIMNotifyProviderEnableRequestMessage*)cimMessage);
275 break;
|
276 carolann.graves 1.31 //case CIM_NOTIFY_PROVIDER_FAIL_REQUEST_MESSAGE:
277 // ATTN: No need to serialize this yet
278 //_serializeCIMNotifyProviderFailRequestMessage(
279 // out, (CIMNotifyProviderFailRequestMessage*)cimMessage);
280 //break;
|
281 kumpf 1.1 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
282 _serializeCIMStopAllProvidersRequestMessage(
283 out, (CIMStopAllProvidersRequestMessage*)cimMessage);
284 break;
|
285 kumpf 1.2 case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:
286 _serializeCIMInitializeProviderRequestMessage(
287 out, (CIMInitializeProviderRequestMessage*)cimMessage);
288 break;
|
289 kumpf 1.7 case CIM_INITIALIZE_PROVIDER_AGENT_REQUEST_MESSAGE:
290 _serializeCIMInitializeProviderAgentRequestMessage(
291 out, (CIMInitializeProviderAgentRequestMessage*)cimMessage);
292 break;
|
293 kumpf 1.2
|
294 kumpf 1.8 case CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE:
295 _serializeCIMNotifyConfigChangeRequestMessage(
296 out, (CIMNotifyConfigChangeRequestMessage*)cimMessage);
297 break;
298
|
299 carolann.graves 1.21 case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
300 _serializeCIMSubscriptionInitCompleteRequestMessage(
|
301 kumpf 1.35 out,
|
302 carolann.graves 1.21 (CIMSubscriptionInitCompleteRequestMessage *)
303 cimMessage);
304 break;
305
|
306 kumpf 1.1 default:
307 PEGASUS_ASSERT(0);
308 }
309
310 XmlWriter::append(out, "</PGOTHERREQ>");
311 }
312
313 XmlWriter::append(out, "</PGREQ>");
314 }
315
316 //
317 // _serializeCIMResponseMessage
318 //
319 void CIMMessageSerializer::_serializeCIMResponseMessage(
|
320 mike 1.22 Buffer& out,
|
321 kumpf 1.1 CIMResponseMessage* cimMessage)
322 {
323 PEGASUS_ASSERT(cimMessage != 0);
324
325 XmlWriter::append(out, "<PGRESP>\n");
326
327 _serializeQueueIdStack(out, cimMessage->queueIds);
328 _serializeCIMException(out, cimMessage->cimException);
329
330 switch (cimMessage->getType())
331 {
332 //
333 // CIM Operation Response Messages
334 //
335
|
336 kumpf 1.27 // A provider cannot implement these operation types, so the
337 // serialization of these messages is not implemented.
338 //case CIM_GET_CLASS_RESPONSE_MESSAGE:
339 //case CIM_DELETE_CLASS_RESPONSE_MESSAGE:
340 //case CIM_CREATE_CLASS_RESPONSE_MESSAGE:
341 //case CIM_MODIFY_CLASS_RESPONSE_MESSAGE:
342 //case CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE:
343 //case CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE:
344 //case CIM_GET_QUALIFIER_RESPONSE_MESSAGE:
345 //case CIM_SET_QUALIFIER_RESPONSE_MESSAGE:
346 //case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:
347 //case CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE:
|
348 kumpf 1.1
349 // Instance operations
350 case CIM_GET_INSTANCE_RESPONSE_MESSAGE:
351 _serializeCIMGetInstanceResponseMessage(
352 out, (CIMGetInstanceResponseMessage*)cimMessage);
353 break;
354 case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE:
355 _serializeCIMDeleteInstanceResponseMessage(
356 out, (CIMDeleteInstanceResponseMessage*)cimMessage);
357 break;
358 case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE:
359 _serializeCIMCreateInstanceResponseMessage(
360 out, (CIMCreateInstanceResponseMessage*)cimMessage);
361 break;
362 case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE:
363 _serializeCIMModifyInstanceResponseMessage(
364 out, (CIMModifyInstanceResponseMessage*)cimMessage);
365 break;
366 case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
367 _serializeCIMEnumerateInstancesResponseMessage(
368 out, (CIMEnumerateInstancesResponseMessage*)cimMessage);
369 kumpf 1.1 break;
370 case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:
371 _serializeCIMEnumerateInstanceNamesResponseMessage(
372 out, (CIMEnumerateInstanceNamesResponseMessage*)cimMessage);
373 break;
374 case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
375 _serializeCIMExecQueryResponseMessage(
376 out, (CIMExecQueryResponseMessage*)cimMessage);
377 break;
378
379 // Property operations
380 case CIM_GET_PROPERTY_RESPONSE_MESSAGE:
381 _serializeCIMGetPropertyResponseMessage(
382 out, (CIMGetPropertyResponseMessage*)cimMessage);
383 break;
384 case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
385 _serializeCIMSetPropertyResponseMessage(
386 out, (CIMSetPropertyResponseMessage*)cimMessage);
387 break;
388
389 // Association operations
390 kumpf 1.1 case CIM_ASSOCIATORS_RESPONSE_MESSAGE:
391 _serializeCIMAssociatorsResponseMessage(
392 out, (CIMAssociatorsResponseMessage*)cimMessage);
393 break;
394 case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:
395 _serializeCIMAssociatorNamesResponseMessage(
396 out, (CIMAssociatorNamesResponseMessage*)cimMessage);
397 break;
398 case CIM_REFERENCES_RESPONSE_MESSAGE:
399 _serializeCIMReferencesResponseMessage(
400 out, (CIMReferencesResponseMessage*)cimMessage);
401 break;
402 case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:
403 _serializeCIMReferenceNamesResponseMessage(
404 out, (CIMReferenceNamesResponseMessage*)cimMessage);
405 break;
406
407 // Method operations
408 case CIM_INVOKE_METHOD_RESPONSE_MESSAGE:
409 _serializeCIMInvokeMethodResponseMessage(
410 out, (CIMInvokeMethodResponseMessage*)cimMessage);
411 kumpf 1.1 break;
412
413 //
414 // CIM Indication Response Messages
415 //
416
417 case CIM_CREATE_SUBSCRIPTION_RESPONSE_MESSAGE:
418 _serializeCIMCreateSubscriptionResponseMessage(
419 out, (CIMCreateSubscriptionResponseMessage*)cimMessage);
420 break;
421 case CIM_MODIFY_SUBSCRIPTION_RESPONSE_MESSAGE:
422 _serializeCIMModifySubscriptionResponseMessage(
423 out, (CIMModifySubscriptionResponseMessage*)cimMessage);
424 break;
425 case CIM_DELETE_SUBSCRIPTION_RESPONSE_MESSAGE:
426 _serializeCIMDeleteSubscriptionResponseMessage(
427 out, (CIMDeleteSubscriptionResponseMessage*)cimMessage);
428 break;
429
430 //
431 // Other CIM Response Messages
432 kumpf 1.1 //
433
434 case CIM_EXPORT_INDICATION_RESPONSE_MESSAGE:
435 _serializeCIMExportIndicationResponseMessage(
436 out, (CIMExportIndicationResponseMessage*)cimMessage);
437 break;
438 case CIM_PROCESS_INDICATION_RESPONSE_MESSAGE:
439 _serializeCIMProcessIndicationResponseMessage(
440 out, (CIMProcessIndicationResponseMessage*)cimMessage);
441 break;
|
442 kumpf 1.27 //case CIM_NOTIFY_PROVIDER_REGISTRATION_RESPONSE_MESSAGE:
|
443 kumpf 1.1 // ATTN: No need to serialize this yet
444 //_serializeCIMNotifyProviderRegistrationResponseMessage(
|
445 kumpf 1.35 // out,
446 // (CIMNotifyProviderRegistrationResponseMessage*)cimMessage);
|
447 kumpf 1.1 break;
|
448 kumpf 1.27 //case CIM_NOTIFY_PROVIDER_TERMINATION_RESPONSE_MESSAGE:
|
449 kumpf 1.1 // ATTN: No need to serialize this yet
450 //_serializeCIMNotifyProviderTerminationResponseMessage(
|
451 kumpf 1.35 // out,
452 // (CIMNotifyProviderTerminationResponseMessage*)cimMessage);
|
453 kumpf 1.1 break;
|
454 kumpf 1.27 //case CIM_HANDLE_INDICATION_RESPONSE_MESSAGE:
|
455 kumpf 1.1 // ATTN: No need to serialize this yet
456 //_serializeCIMHandleIndicationResponseMessage(
457 // out, (CIMHandleIndicationResponseMessage*)cimMessage);
458 break;
459 case CIM_DISABLE_MODULE_RESPONSE_MESSAGE:
460 _serializeCIMDisableModuleResponseMessage(
461 out, (CIMDisableModuleResponseMessage*)cimMessage);
462 break;
463 case CIM_ENABLE_MODULE_RESPONSE_MESSAGE:
464 _serializeCIMEnableModuleResponseMessage(
465 out, (CIMEnableModuleResponseMessage*)cimMessage);
466 break;
|
467 kumpf 1.27 //case CIM_NOTIFY_PROVIDER_ENABLE_RESPONSE_MESSAGE:
|
468 kumpf 1.1 // ATTN: No need to serialize this yet
469 //_serializeCIMNotifyProviderEnableResponseMessage(
470 // out, (CIMNotifyProviderEnableResponseMessage*)cimMessage);
471 break;
|
472 carolann.graves 1.31 //case CIM_NOTIFY_PROVIDER_FAIL_RESPONSE_MESSAGE:
473 // ATTN: No need to serialize this yet
474 //_serializeCIMNotifyProviderFailResponseMessage(
475 // out, (CIMNotifyProviderFailResponseMessage*)cimMessage);
476 //break;
|
477 kumpf 1.1 case CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE:
478 _serializeCIMStopAllProvidersResponseMessage(
479 out, (CIMStopAllProvidersResponseMessage*)cimMessage);
480 break;
|
481 kumpf 1.2 case CIM_INITIALIZE_PROVIDER_RESPONSE_MESSAGE:
482 _serializeCIMInitializeProviderResponseMessage(
483 out, (CIMInitializeProviderResponseMessage*)cimMessage);
484 break;
|
485 kumpf 1.7 case CIM_INITIALIZE_PROVIDER_AGENT_RESPONSE_MESSAGE:
486 _serializeCIMInitializeProviderAgentResponseMessage(
487 out, (CIMInitializeProviderAgentResponseMessage*)cimMessage);
488 break;
|
489 kumpf 1.8 case CIM_NOTIFY_CONFIG_CHANGE_RESPONSE_MESSAGE:
490 _serializeCIMNotifyConfigChangeResponseMessage(
491 out, (CIMNotifyConfigChangeResponseMessage*)cimMessage);
492 break;
|
493 carolann.graves 1.21 case CIM_SUBSCRIPTION_INIT_COMPLETE_RESPONSE_MESSAGE:
494 _serializeCIMSubscriptionInitCompleteResponseMessage(
|
495 kumpf 1.35 out,
|
496 carolann.graves 1.21 (CIMSubscriptionInitCompleteResponseMessage *)
497 cimMessage);
498 break;
|
499 kumpf 1.2
|
500 kumpf 1.1 default:
501 PEGASUS_ASSERT(0);
502 }
503
504 XmlWriter::append(out, "</PGRESP>");
505 }
506
507
508 //
509 // Utility Methods
510 //
511
512 //
513 // _serializeUserInfo consolidates encoding of these common message attributes
514 //
515 void CIMMessageSerializer::_serializeUserInfo(
|
516 mike 1.22 Buffer& out,
|
517 kumpf 1.1 const String& authType,
518 const String& userName)
519 {
520 XmlWriter::appendValueElement(out, authType);
521 XmlWriter::appendValueElement(out, userName);
522 }
523
524 //
525 // _serializeQueueIdStack
526 //
527 void CIMMessageSerializer::_serializeQueueIdStack(
|
528 mike 1.22 Buffer& out,
|
529 kumpf 1.1 const QueueIdStack& queueIdStack)
530 {
531 QueueIdStack stackCopy = queueIdStack;
532
533 // Use a PGQIDSTACK element to encapsulate the QueueIdStack encoding
534 XmlWriter::append(out, "<PGQIDSTACK>\n");
535 while (!stackCopy.isEmpty())
536 {
537 Uint32 item = stackCopy.top();
538 stackCopy.pop();
539 XmlWriter::appendValueElement(out, item);
540 }
541 XmlWriter::append(out, "</PGQIDSTACK>\n");
542 }
543
544 //
545 // _serializeOperationContext
546 //
547 void CIMMessageSerializer::_serializeOperationContext(
|
548 mike 1.22 Buffer& out,
|
549 kumpf 1.1 const OperationContext& operationContext)
550 {
|
551 kumpf 1.13 // Use a PGOP element to encapsulate the OperationContext encoding
|
552 kumpf 1.1 XmlWriter::append(out, "<PGOC>\n");
553
554 // Note: OperationContext class does not allow iteration through Containers
555
|
556 kumpf 1.36 if (operationContext.contains(IdentityContainer::NAME))
|
557 kumpf 1.1 {
558 const IdentityContainer container =
559 operationContext.get(IdentityContainer::NAME);
560
561 XmlWriter::append(out, "<PGOCID>\n");
562 XmlWriter::appendValueElement(out, container.getUserName());
563 XmlWriter::append(out, "</PGOCID>\n");
564 }
565
|
566 kumpf 1.36 if (operationContext.contains(SubscriptionInstanceContainer::NAME))
|
567 kumpf 1.1 {
568 const SubscriptionInstanceContainer container =
569 operationContext.get(SubscriptionInstanceContainer::NAME);
570
571 XmlWriter::append(out, "<PGOCSI>\n");
572 _serializeCIMInstance(out, container.getInstance());
573 XmlWriter::append(out, "</PGOCSI>\n");
574 }
575
|
576 kumpf 1.36 if (operationContext.contains(SubscriptionFilterConditionContainer::NAME))
|
577 kumpf 1.1 {
578 const SubscriptionFilterConditionContainer container =
579 operationContext.get(SubscriptionFilterConditionContainer::NAME);
580
581 XmlWriter::append(out, "<PGOCSFC>\n");
582 XmlWriter::appendValueElement(out, container.getFilterCondition());
583 XmlWriter::appendValueElement(out, container.getQueryLanguage());
584 XmlWriter::append(out, "</PGOCSFC>\n");
585 }
586
|
587 kumpf 1.36 if (operationContext.contains(SubscriptionFilterQueryContainer::NAME))
|
588 kumpf 1.1 {
|
589 chuck 1.17 const SubscriptionFilterQueryContainer container =
590 operationContext.get(SubscriptionFilterQueryContainer::NAME);
591
592 XmlWriter::append(out, "<PGOCSFQ>\n");
593 XmlWriter::appendValueElement(out, container.getFilterQuery());
594 XmlWriter::appendValueElement(out, container.getQueryLanguage());
595 _serializeCIMNamespaceName(out, container.getSourceNameSpace());
596 XmlWriter::append(out, "</PGOCSFQ>\n");
597 }
598
|
599 kumpf 1.36 if (operationContext.contains(SubscriptionInstanceNamesContainer::NAME))
|
600 chuck 1.17 {
|
601 kumpf 1.1 const SubscriptionInstanceNamesContainer container =
602 operationContext.get(SubscriptionInstanceNamesContainer::NAME);
603
604 XmlWriter::append(out, "<PGOCSIN>\n");
605
606 Array<CIMObjectPath> cimObjectPaths = container.getInstanceNames();
607 for (Uint32 i=0; i < cimObjectPaths.size(); i++)
608 {
609 _serializeCIMObjectPath(out, cimObjectPaths[i]);
610 }
611
612 XmlWriter::append(out, "</PGOCSIN>\n");
613 }
614
|
615 kumpf 1.36 if (operationContext.contains(TimeoutContainer::NAME))
|
616 kumpf 1.1 {
617 const TimeoutContainer container =
618 operationContext.get(TimeoutContainer::NAME);
619
620 XmlWriter::append(out, "<PGOCTO>\n");
621 XmlWriter::appendValueElement(out, container.getTimeOut());
622 XmlWriter::append(out, "</PGOCTO>\n");
623 }
624
|
625 kumpf 1.36 if (operationContext.contains(AcceptLanguageListContainer::NAME))
|
626 kumpf 1.1 {
627 const AcceptLanguageListContainer container =
628 operationContext.get(AcceptLanguageListContainer::NAME);
629
630 XmlWriter::append(out, "<PGOCALL>\n");
|
631 kumpf 1.25 _serializeAcceptLanguageList(out, container.getLanguages());
|
632 kumpf 1.1 XmlWriter::append(out, "</PGOCALL>\n");
633 }
634
|
635 kumpf 1.36 if (operationContext.contains(ContentLanguageListContainer::NAME))
|
636 kumpf 1.1 {
637 const ContentLanguageListContainer container =
638 operationContext.get(ContentLanguageListContainer::NAME);
639
640 XmlWriter::append(out, "<PGOCCLL>\n");
|
641 kumpf 1.25 _serializeContentLanguageList(out, container.getLanguages());
|
642 kumpf 1.1 XmlWriter::append(out, "</PGOCCLL>\n");
643 }
644
|
645 kumpf 1.36 if (operationContext.contains(SnmpTrapOidContainer::NAME))
|
646 kumpf 1.1 {
647 const SnmpTrapOidContainer container =
648 operationContext.get(SnmpTrapOidContainer::NAME);
649
650 XmlWriter::append(out, "<PGOCSTO>\n");
651 XmlWriter::appendValueElement(out, container.getSnmpTrapOid());
652 XmlWriter::append(out, "</PGOCSTO>\n");
653 }
654
|
655 kumpf 1.36 if (operationContext.contains(LocaleContainer::NAME))
|
656 kumpf 1.1 {
657 const LocaleContainer container =
658 operationContext.get(LocaleContainer::NAME);
659
660 XmlWriter::append(out, "<PGOCL>\n");
661 XmlWriter::appendValueElement(out, container.getLanguageId());
662 XmlWriter::append(out, "</PGOCL>\n");
663 }
664
|
665 kumpf 1.36 if (operationContext.contains(ProviderIdContainer::NAME))
|
666 kumpf 1.1 {
667 const ProviderIdContainer container =
668 operationContext.get(ProviderIdContainer::NAME);
669
670 XmlWriter::append(out, "<PGOCPI>\n");
671 _serializeCIMInstance(out, container.getModule());
672 _serializeCIMInstance(out, container.getProvider());
|
673 kumpf 1.11 XmlWriter::appendValueElement(out, container.isRemoteNameSpace());
674 XmlWriter::appendValueElement(out, container.getRemoteInfo());
|
675 kumpf 1.1 XmlWriter::append(out, "</PGOCPI>\n");
676 }
677
678 XmlWriter::append(out, "</PGOC>\n");
679 }
680
681 //
|
682 kumpf 1.25 // _serializeContentLanguageList
|
683 kumpf 1.1 //
|
684 kumpf 1.25 void CIMMessageSerializer::_serializeContentLanguageList(
|
685 mike 1.22 Buffer& out,
|
686 kumpf 1.25 const ContentLanguageList& contentLanguages)
|
687 kumpf 1.1 {
|
688 kumpf 1.25 // Use a PGCONTLANGS element to encapsulate the ContentLanguageList
689 // encoding
|
690 kumpf 1.1 XmlWriter::append(out, "<PGCONTLANGS>\n");
|
691 kumpf 1.24 for (Uint32 i=0; i < contentLanguages.size(); i++)
|
692 kumpf 1.1 {
|
693 kumpf 1.24 XmlWriter::appendValueElement(
694 out, contentLanguages.getLanguageTag(i).toString());
|
695 kumpf 1.1 }
696 XmlWriter::append(out, "</PGCONTLANGS>\n");
697 }
698
699 //
|
700 kumpf 1.25 // _serializeAcceptLanguageList
|
701 kumpf 1.1 //
|
702 kumpf 1.25 void CIMMessageSerializer::_serializeAcceptLanguageList(
|
703 mike 1.22 Buffer& out,
|
704 kumpf 1.25 const AcceptLanguageList& acceptLanguages)
|
705 kumpf 1.1 {
|
706 kumpf 1.25 // Use a PGACCLANGS element to encapsulate the AcceptLanguageList encoding
|
707 kumpf 1.1 XmlWriter::append(out, "<PGACCLANGS>\n");
|
708 kumpf 1.24 for (Uint32 i=0; i < acceptLanguages.size(); i++)
|
709 kumpf 1.1 {
|
710 kumpf 1.24 XmlWriter::appendValueElement(
711 out, acceptLanguages.getLanguageTag(i).toString());
712 XmlWriter::appendValueElement(out, acceptLanguages.getQualityValue(i));
|
713 kumpf 1.1 }
714 XmlWriter::append(out, "</PGACCLANGS>\n");
715 }
716
717 //
718 // _serializeCIMException
719 //
720 void CIMMessageSerializer::_serializeCIMException(
|
721 mike 1.22 Buffer& out,
|
722 kumpf 1.1 const CIMException& cimException)
723 {
|
724 kumpf 1.9 TraceableCIMException e(cimException);
|
725 kumpf 1.1
726 // Use a PGCIMEXC element to encapsulate the CIMException encoding
|
727 kumpf 1.9 // (Note: This is not truly necessary and could be removed.)
|
728 kumpf 1.1 XmlWriter::append(out, "<PGCIMEXC>\n");
|
729 kumpf 1.9
730 XmlWriter::appendValueElement(out, Uint32(e.getCode()));
731 XmlWriter::appendValueElement(out, e.getMessage());
732 XmlWriter::appendValueElement(out, e.getCIMMessage());
733 XmlWriter::appendValueElement(out, e.getFile());
734 XmlWriter::appendValueElement(out, e.getLine());
|
735 kumpf 1.25 _serializeContentLanguageList(out, e.getContentLanguages());
|
736 kumpf 1.9
|
737 kumpf 1.1 XmlWriter::append(out, "</PGCIMEXC>\n");
738 }
739
740 //
|
741 jenny.yu 1.19 // _serializeCIMPropertyList
|
742 kumpf 1.1 //
743 void CIMMessageSerializer::_serializeCIMPropertyList(
|
744 mike 1.22 Buffer& out,
|
745 kumpf 1.1 const CIMPropertyList& cimPropertyList)
746 {
747 // Need IPARAMVALUE wrapper because the value can be null.
748 XmlWriter::appendPropertyListIParameter(out, cimPropertyList);
749 }
750
751 //
752 // _serializeCIMObjectPath
753 //
754 void CIMMessageSerializer::_serializeCIMObjectPath(
|
755 mike 1.22 Buffer& out,
|
756 kumpf 1.1 const CIMObjectPath& cimObjectPath)
757 {
758 // Use a PGPATH element to encapsulate the CIMObjectPath encoding
759 // to account for uninitialized objects
760 XmlWriter::append(out, "<PGPATH>\n");
761 if (!cimObjectPath.getClassName().isNull())
762 {
763 XmlWriter::appendValueReferenceElement(out, cimObjectPath, true);
764 }
765 XmlWriter::append(out, "</PGPATH>\n");
766 }
767
768 //
769 // _serializeCIMInstance
770 //
771 void CIMMessageSerializer::_serializeCIMInstance(
|
772 mike 1.22 Buffer& out,
|
773 kumpf 1.1 const CIMInstance& cimInstance)
774 {
775 // Use a PGINST element to encapsulate the CIMInstance encoding
776 // to account for uninitialized objects
777 XmlWriter::append(out, "<PGINST>\n");
778 if (!cimInstance.isUninitialized())
779 {
|
780 jenny.yu 1.19 XmlWriter::appendInstanceElement(out, cimInstance);
781 _serializeCIMObjectPath(out, cimInstance.getPath());
|
782 kumpf 1.1 }
783 XmlWriter::append(out, "</PGINST>\n");
784 }
785
786 //
787 // _serializeCIMNamespaceName
788 //
789 void CIMMessageSerializer::_serializeCIMNamespaceName(
|
790 mike 1.22 Buffer& out,
|
791 kumpf 1.1 const CIMNamespaceName& cimNamespaceName)
792 {
793 // Encode CIMNamespaceName as a String for efficiency and so that null
794 // values can be handled
795 XmlWriter::appendValueElement(out, cimNamespaceName.getString());
796 }
797
798 //
799 // _serializeCIMName
800 //
801 void CIMMessageSerializer::_serializeCIMName(
|
802 mike 1.22 Buffer& out,
|
803 kumpf 1.1 const CIMName& cimName)
804 {
805 // Encode CIMName as a String so that null values can be handled
806 XmlWriter::appendValueElement(out, cimName.getString());
807 }
808
|
809 jenny.yu 1.19 //
810 // _serializeCIMObject
811 //
812 void CIMMessageSerializer::_serializeCIMObject(
|
813 mike 1.22 Buffer& out,
|
814 jenny.yu 1.19 const CIMObject& object)
815 {
816 // Use a PGOBJ element to encapsulate the CIMObject encoding
817 // to account for uninitialized objects
818 XmlWriter::append(out, "<PGOBJ>\n");
819 if (!object.isUninitialized())
820 {
821 XmlWriter::appendObjectElement(out, object);
822 _serializeCIMObjectPath(out, object.getPath());
823 }
824 XmlWriter::append(out, "</PGOBJ>\n");
825 }
|
826 kumpf 1.1
827 //
828 //
829 // Request Messages
830 //
831 //
832
833 //
834 //
835 // CIMOperationRequestMessages
836 //
837 //
838
839 //
840 // _serializeCIMGetInstanceRequestMessage
841 //
842 void CIMMessageSerializer::_serializeCIMGetInstanceRequestMessage(
|
843 mike 1.22 Buffer& out,
|
844 kumpf 1.1 CIMGetInstanceRequestMessage* message)
845 {
846 _serializeCIMObjectPath(out, message->instanceName);
847 XmlWriter::appendValueElement(out, message->localOnly);
848 XmlWriter::appendValueElement(out, message->includeQualifiers);
849 XmlWriter::appendValueElement(out, message->includeClassOrigin);
850 _serializeCIMPropertyList(out, message->propertyList);
851 }
852
853 //
854 // _serializeCIMDeleteInstanceRequestMessage
855 //
856 void CIMMessageSerializer::_serializeCIMDeleteInstanceRequestMessage(
|
857 mike 1.22 Buffer& out,
|
858 kumpf 1.1 CIMDeleteInstanceRequestMessage* message)
859 {
860 _serializeCIMObjectPath(out, message->instanceName);
861 }
862
863 //
864 // _serializeCIMCreateInstanceRequestMessage
865 //
866 void CIMMessageSerializer::_serializeCIMCreateInstanceRequestMessage(
|
867 mike 1.22 Buffer& out,
|
868 kumpf 1.1 CIMCreateInstanceRequestMessage* message)
869 {
870 _serializeCIMInstance(out, message->newInstance);
871 }
872
873 //
874 // _serializeCIMModifyInstanceRequestMessage
875 //
876 void CIMMessageSerializer::_serializeCIMModifyInstanceRequestMessage(
|
877 mike 1.22 Buffer& out,
|
878 kumpf 1.1 CIMModifyInstanceRequestMessage* message)
879 {
880 _serializeCIMInstance(out, message->modifiedInstance);
881 XmlWriter::appendValueElement(out, message->includeQualifiers);
882 _serializeCIMPropertyList(out, message->propertyList);
883 }
884
885 //
886 // _serializeCIMEnumerateInstancesRequestMessage
887 //
888 void CIMMessageSerializer::_serializeCIMEnumerateInstancesRequestMessage(
|
889 mike 1.22 Buffer& out,
|
890 kumpf 1.1 CIMEnumerateInstancesRequestMessage* message)
891 {
892 XmlWriter::appendValueElement(out, message->deepInheritance);
893 XmlWriter::appendValueElement(out, message->localOnly);
894 XmlWriter::appendValueElement(out, message->includeQualifiers);
895 XmlWriter::appendValueElement(out, message->includeClassOrigin);
896 _serializeCIMPropertyList(out, message->propertyList);
897 }
898
899 //
900 // _serializeCIMEnumerateInstanceNamesRequestMessage
901 //
902 void CIMMessageSerializer::_serializeCIMEnumerateInstanceNamesRequestMessage(
|
903 mike 1.22 Buffer& out,
|
904 kumpf 1.1 CIMEnumerateInstanceNamesRequestMessage* message)
905 {
906 // No additional attributes to serialize!
907 }
908
909 //
910 // _serializeCIMExecQueryRequestMessage
911 //
912 void CIMMessageSerializer::_serializeCIMExecQueryRequestMessage(
|
913 mike 1.22 Buffer& out,
|
914 kumpf 1.1 CIMExecQueryRequestMessage* message)
915 {
916 XmlWriter::appendValueElement(out, message->queryLanguage);
917 XmlWriter::appendValueElement(out, message->query);
918 }
919
920 //
921 // _serializeCIMAssociatorsRequestMessage
922 //
923 void CIMMessageSerializer::_serializeCIMAssociatorsRequestMessage(
|
924 mike 1.22 Buffer& out,
|
925 kumpf 1.1 CIMAssociatorsRequestMessage* message)
926 {
927 _serializeCIMObjectPath(out, message->objectName);
928 _serializeCIMName(out, message->assocClass);
929 _serializeCIMName(out, message->resultClass);
930 XmlWriter::appendValueElement(out, message->role);
931 XmlWriter::appendValueElement(out, message->resultRole);
932 XmlWriter::appendValueElement(out, message->includeQualifiers);
933 XmlWriter::appendValueElement(out, message->includeClassOrigin);
934 _serializeCIMPropertyList(out, message->propertyList);
935 }
936
937 //
938 // _serializeCIMAssociatorNamesRequestMessage
939 //
940 void CIMMessageSerializer::_serializeCIMAssociatorNamesRequestMessage(
|
941 mike 1.22 Buffer& out,
|
942 kumpf 1.1 CIMAssociatorNamesRequestMessage* message)
943 {
944 _serializeCIMObjectPath(out, message->objectName);
945 _serializeCIMName(out, message->assocClass);
946 _serializeCIMName(out, message->resultClass);
947 XmlWriter::appendValueElement(out, message->role);
948 XmlWriter::appendValueElement(out, message->resultRole);
949 }
950
951 //
952 // _serializeCIMReferencesRequestMessage
953 //
954 void CIMMessageSerializer::_serializeCIMReferencesRequestMessage(
|
955 mike 1.22 Buffer& out,
|
956 kumpf 1.1 CIMReferencesRequestMessage* message)
957 {
958 _serializeCIMObjectPath(out, message->objectName);
959 _serializeCIMName(out, message->resultClass);
960 XmlWriter::appendValueElement(out, message->role);
961 XmlWriter::appendValueElement(out, message->includeQualifiers);
962 XmlWriter::appendValueElement(out, message->includeClassOrigin);
963 _serializeCIMPropertyList(out, message->propertyList);
964 }
965
966 //
967 // _serializeCIMReferenceNamesRequestMessage
968 //
969 void CIMMessageSerializer::_serializeCIMReferenceNamesRequestMessage(
|
970 mike 1.22 Buffer& out,
|
971 kumpf 1.1 CIMReferenceNamesRequestMessage* message)
972 {
973 _serializeCIMObjectPath(out, message->objectName);
974 _serializeCIMName(out, message->resultClass);
975 XmlWriter::appendValueElement(out, message->role);
976 }
977
978 //
979 // _serializeCIMGetPropertyRequestMessage
980 //
981 void CIMMessageSerializer::_serializeCIMGetPropertyRequestMessage(
|
982 mike 1.22 Buffer& out,
|
983 kumpf 1.1 CIMGetPropertyRequestMessage* message)
984 {
985 _serializeCIMObjectPath(out, message->instanceName);
986 _serializeCIMName(out, message->propertyName);
987 }
988
989 //
990 // _serializeCIMSetPropertyRequestMessage
991 //
992 void CIMMessageSerializer::_serializeCIMSetPropertyRequestMessage(
|
993 mike 1.22 Buffer& out,
|
994 kumpf 1.1 CIMSetPropertyRequestMessage* message)
995 {
996 _serializeCIMObjectPath(out, message->instanceName);
997
998 // Use PARAMVALUE element so we can preserve the CIMType information
999 XmlWriter::appendParamValueElement(
1000 out,
1001 CIMParamValue(
1002 message->propertyName.getString(), message->newValue, true));
1003 }
1004
1005 //
1006 // _serializeCIMInvokeMethodRequestMessage
1007 //
1008 void CIMMessageSerializer::_serializeCIMInvokeMethodRequestMessage(
|
1009 mike 1.22 Buffer& out,
|
1010 kumpf 1.1 CIMInvokeMethodRequestMessage* message)
1011 {
1012 _serializeCIMObjectPath(out, message->instanceName);
1013 _serializeCIMName(out, message->methodName);
1014
1015 // Use PGPARAMS element so we can find the end of the PARAMVALUE elements
1016 XmlWriter::append(out, "<PGPARAMS>\n");
1017 for (Uint32 i=0; i < message->inParameters.size(); i++)
1018 {
1019 XmlWriter::appendParamValueElement(out, message->inParameters[i]);
1020 }
1021 XmlWriter::append(out, "</PGPARAMS>\n");
1022 }
1023
1024
1025 //
1026 //
1027 // CIMIndicationRequestMessages
1028 //
1029 //
1030
1031 kumpf 1.1 //
1032 // _serializeCIMCreateSubscriptionRequestMessage
1033 //
1034 void CIMMessageSerializer::_serializeCIMCreateSubscriptionRequestMessage(
|
1035 mike 1.22 Buffer& out,
|
1036 kumpf 1.1 CIMCreateSubscriptionRequestMessage* message)
1037 {
1038 _serializeCIMNamespaceName(out, message->nameSpace);
1039
1040 _serializeCIMInstance(out, message->subscriptionInstance);
1041
1042 // Use PGNAMEARRAY element to encapsulate the CIMName elements
1043 XmlWriter::append(out, "<PGNAMEARRAY>\n");
1044 for (Uint32 i=0; i < message->classNames.size(); i++)
1045 {
1046 _serializeCIMName(out, message->classNames[i]);
1047 }
1048 XmlWriter::append(out, "</PGNAMEARRAY>\n");
1049
1050 _serializeCIMPropertyList(out, message->propertyList);
1051
1052 // Encode message->repeatNotificationPolicy as an integer
1053 XmlWriter::appendValueElement(out, message->repeatNotificationPolicy);
1054
|
1055 kumpf 1.3 XmlWriter::appendValueElement(out, message->query);
|
1056 kumpf 1.13 }
|
1057 kumpf 1.1
1058 //
1059 // _serializeCIMModifySubscriptionRequestMessage
1060 //
1061 void CIMMessageSerializer::_serializeCIMModifySubscriptionRequestMessage(
|
1062 mike 1.22 Buffer& out,
|
1063 kumpf 1.1 CIMModifySubscriptionRequestMessage* message)
1064 {
1065 _serializeCIMNamespaceName(out, message->nameSpace);
1066
1067 _serializeCIMInstance(out, message->subscriptionInstance);
1068
1069 // Use PGNAMEARRAY element to encapsulate the CIMName elements
1070 XmlWriter::append(out, "<PGNAMEARRAY>\n");
1071 for (Uint32 i=0; i < message->classNames.size(); i++)
1072 {
1073 _serializeCIMName(out, message->classNames[i]);
1074 }
1075 XmlWriter::append(out, "</PGNAMEARRAY>\n");
1076
1077 _serializeCIMPropertyList(out, message->propertyList);
1078
1079 // Encode message->repeatNotificationPolicy as an integer
1080 XmlWriter::appendValueElement(out, message->repeatNotificationPolicy);
1081
|
1082 kumpf 1.3 XmlWriter::appendValueElement(out, message->query);
|
1083 kumpf 1.1 }
1084
1085 //
1086 // _serializeCIMDeleteSubscriptionRequestMessage
1087 //
1088 void CIMMessageSerializer::_serializeCIMDeleteSubscriptionRequestMessage(
|
1089 mike 1.22 Buffer& out,
|
1090 kumpf 1.1 CIMDeleteSubscriptionRequestMessage* message)
1091 {
1092 _serializeCIMNamespaceName(out, message->nameSpace);
1093
1094 _serializeCIMInstance(out, message->subscriptionInstance);
1095
1096 // Use PGNAMEARRAY element to encapsulate the CIMName elements
1097 XmlWriter::append(out, "<PGNAMEARRAY>\n");
1098 for (Uint32 i=0; i < message->classNames.size(); i++)
1099 {
1100 _serializeCIMName(out, message->classNames[i]);
1101 }
1102 XmlWriter::append(out, "</PGNAMEARRAY>\n");
1103 }
1104
1105
1106 //
1107 //
1108 // Other CIMRequestMessages
1109 //
1110 //
1111 kumpf 1.1
1112 //
1113 // _serializeCIMExportIndicationRequestMessage
1114 //
1115 void CIMMessageSerializer::_serializeCIMExportIndicationRequestMessage(
|
1116 mike 1.22 Buffer& out,
|
1117 kumpf 1.1 CIMExportIndicationRequestMessage* message)
1118 {
1119 _serializeUserInfo(out, message->authType, message->userName);
1120
1121 XmlWriter::appendValueElement(out, message->destinationPath);
1122 _serializeCIMInstance(out, message->indicationInstance);
1123 }
1124
1125 //
1126 // _serializeCIMProcessIndicationRequestMessage
1127 //
1128 void CIMMessageSerializer::_serializeCIMProcessIndicationRequestMessage(
|
1129 mike 1.22 Buffer& out,
|
1130 kumpf 1.1 CIMProcessIndicationRequestMessage* message)
1131 {
1132 _serializeCIMNamespaceName(out, message->nameSpace);
1133
1134 _serializeCIMInstance(out, message->indicationInstance);
1135
1136 // Use PGPATHARRAY element to encapsulate the object path elements
1137 XmlWriter::append(out, "<PGPATHARRAY>\n");
1138 for (Uint32 i=0; i < message->subscriptionInstanceNames.size(); i++)
1139 {
1140 _serializeCIMObjectPath(out, message->subscriptionInstanceNames[i]);
1141 }
1142 XmlWriter::append(out, "</PGPATHARRAY>\n");
1143
1144 _serializeCIMInstance(out, message->provider);
1145 }
1146
1147 //
1148 // _serializeCIMDisableModuleRequestMessage
1149 //
1150 void CIMMessageSerializer::_serializeCIMDisableModuleRequestMessage(
|
1151 mike 1.22 Buffer& out,
|
1152 kumpf 1.1 CIMDisableModuleRequestMessage* message)
1153 {
1154 _serializeUserInfo(out, message->authType, message->userName);
1155
1156 _serializeCIMInstance(out, message->providerModule);
1157
1158 // Use PGINSTARRAY element to encapsulate the CIMInstance elements
1159 XmlWriter::append(out, "<PGINSTARRAY>\n");
1160 for (Uint32 i=0; i < message->providers.size(); i++)
1161 {
1162 _serializeCIMInstance(out, message->providers[i]);
1163 }
1164 XmlWriter::append(out, "</PGINSTARRAY>\n");
1165
1166 XmlWriter::appendValueElement(out, message->disableProviderOnly);
1167
1168 // Use PGBOOLARRAY element to encapsulate the Boolean elements
1169 XmlWriter::append(out, "<PGBOOLARRAY>\n");
1170 for (Uint32 i=0; i < message->indicationProviders.size(); i++)
1171 {
1172 XmlWriter::appendValueElement(out, message->indicationProviders[i]);
1173 kumpf 1.1 }
1174 XmlWriter::append(out, "</PGBOOLARRAY>\n");
1175 }
1176
1177 //
1178 // _serializeCIMEnableModuleRequestMessage
1179 //
1180 void CIMMessageSerializer::_serializeCIMEnableModuleRequestMessage(
|
1181 mike 1.22 Buffer& out,
|
1182 kumpf 1.1 CIMEnableModuleRequestMessage* message)
1183 {
1184 _serializeUserInfo(out, message->authType, message->userName);
1185
1186 _serializeCIMInstance(out, message->providerModule);
1187 }
1188
1189 //
1190 // _serializeCIMStopAllProvidersRequestMessage
1191 //
1192 void CIMMessageSerializer::_serializeCIMStopAllProvidersRequestMessage(
|
1193 mike 1.22 Buffer& out,
|
1194 kumpf 1.1 CIMStopAllProvidersRequestMessage* message)
1195 {
1196 // No additional attributes to serialize!
1197 }
1198
|
1199 kumpf 1.2 //
1200 // _serializeCIMInitializeProviderRequestMessage
1201 //
1202 void CIMMessageSerializer::_serializeCIMInitializeProviderRequestMessage(
|
1203 mike 1.22 Buffer& out,
|
1204 kumpf 1.2 CIMInitializeProviderRequestMessage* message)
1205 {
|
1206 kumpf 1.4 // No additional attributes to serialize!
|
1207 kumpf 1.2 }
1208
|
1209 kumpf 1.7 //
1210 // _serializeCIMInitializeProviderAgentRequestMessage
1211 //
1212 void CIMMessageSerializer::_serializeCIMInitializeProviderAgentRequestMessage(
|
1213 mike 1.22 Buffer& out,
|
1214 kumpf 1.7 CIMInitializeProviderAgentRequestMessage* message)
1215 {
1216 XmlWriter::appendValueElement(out, message->pegasusHome);
1217
1218 // Use PGCONFARRAY element to encapsulate the config property elements
1219 XmlWriter::append(out, "<PGCONFARRAY>\n");
1220 for (Uint32 i=0; i < message->configProperties.size(); i++)
1221 {
1222 XmlWriter::appendValueElement(out, message->configProperties[i].first);
1223 XmlWriter::appendValueElement(out, message->configProperties[i].second);
1224 }
1225 XmlWriter::append(out, "</PGCONFARRAY>\n");
1226
1227 XmlWriter::appendValueElement(out, message->bindVerbose);
|
1228 carolann.graves 1.21
1229 XmlWriter::appendValueElement(out, message->subscriptionInitComplete);
|
1230 kumpf 1.7 }
1231
|
1232 kumpf 1.8 //
1233 // _serializeCIMNotifyConfigChangeRequestMessage
1234 //
1235 void CIMMessageSerializer::_serializeCIMNotifyConfigChangeRequestMessage(
|
1236 mike 1.22 Buffer& out,
|
1237 kumpf 1.8 CIMNotifyConfigChangeRequestMessage* message)
1238 {
1239 XmlWriter::appendValueElement(out, message->propertyName);
1240 XmlWriter::appendValueElement(out, message->newPropertyValue);
1241 XmlWriter::appendValueElement(out, message->currentValueModified);
1242 }
|
1243 kumpf 1.1
1244 //
|
1245 carolann.graves 1.21 // _serializeCIMSubscriptionInitCompleteRequestMessage
1246 //
|
1247 kumpf 1.35 void CIMMessageSerializer::_serializeCIMSubscriptionInitCompleteRequestMessage(
|
1248 mike 1.22 Buffer& out,
|
1249 carolann.graves 1.21 CIMSubscriptionInitCompleteRequestMessage* message)
1250 {
1251 // No additional attributes to serialize!
1252 }
1253
1254 //
|
1255 kumpf 1.1 //
1256 // Response Messages
1257 //
1258 //
1259
1260 //
1261 //
1262 // CIM Operation Response Messages
1263 //
1264 //
1265
1266 //
1267 // _serializeCIMGetInstanceResponseMessage
1268 //
1269 void CIMMessageSerializer::_serializeCIMGetInstanceResponseMessage(
|
1270 mike 1.22 Buffer& out,
|
1271 kumpf 1.1 CIMGetInstanceResponseMessage* message)
1272 {
1273 _serializeCIMInstance(out, message->cimInstance);
1274 }
1275
1276 //
1277 // _serializeCIMDeleteInstanceResponseMessage
1278 //
1279 void CIMMessageSerializer::_serializeCIMDeleteInstanceResponseMessage(
|
1280 mike 1.22 Buffer& out,
|
1281 kumpf 1.1 CIMDeleteInstanceResponseMessage* message)
1282 {
1283 // No additional attributes to serialize!
1284 }
1285
1286 //
1287 // _serializeCIMCreateInstanceResponseMessage
1288 //
1289 void CIMMessageSerializer::_serializeCIMCreateInstanceResponseMessage(
|
1290 mike 1.22 Buffer& out,
|
1291 kumpf 1.1 CIMCreateInstanceResponseMessage* message)
1292 {
1293 _serializeCIMObjectPath(out, message->instanceName);
1294 }
1295
1296 //
1297 // _serializeCIMModifyInstanceResponseMessage
1298 //
1299 void CIMMessageSerializer::_serializeCIMModifyInstanceResponseMessage(
|
1300 mike 1.22 Buffer& out,
|
1301 kumpf 1.1 CIMModifyInstanceResponseMessage* message)
1302 {
1303 // No additional attributes to serialize!
1304 }
1305
1306 //
1307 // _serializeCIMEnumerateInstancesResponseMessage
1308 //
1309 void CIMMessageSerializer::_serializeCIMEnumerateInstancesResponseMessage(
|
1310 mike 1.22 Buffer& out,
|
1311 kumpf 1.1 CIMEnumerateInstancesResponseMessage* message)
1312 {
1313 // Use PGINSTARRAY element to encapsulate the CIMInstance elements
1314 XmlWriter::append(out, "<PGINSTARRAY>\n");
1315 for (Uint32 i=0; i < message->cimNamedInstances.size(); i++)
1316 {
1317 _serializeCIMInstance(out, message->cimNamedInstances[i]);
1318 }
1319 XmlWriter::append(out, "</PGINSTARRAY>\n");
1320 }
1321
1322 //
1323 // _serializeCIMEnumerateInstanceNamesResponseMessage
1324 //
1325 void CIMMessageSerializer::_serializeCIMEnumerateInstanceNamesResponseMessage(
|
1326 mike 1.22 Buffer& out,
|
1327 kumpf 1.1 CIMEnumerateInstanceNamesResponseMessage* message)
1328 {
1329 // Use PGPATHARRAY element to encapsulate the object path elements
1330 XmlWriter::append(out, "<PGPATHARRAY>\n");
1331 for (Uint32 i=0; i < message->instanceNames.size(); i++)
1332 {
1333 _serializeCIMObjectPath(out, message->instanceNames[i]);
1334 }
1335 XmlWriter::append(out, "</PGPATHARRAY>\n");
1336 }
1337
1338 //
1339 // _serializeCIMExecQueryResponseMessage
1340 //
1341 void CIMMessageSerializer::_serializeCIMExecQueryResponseMessage(
|
1342 mike 1.22 Buffer& out,
|
1343 kumpf 1.1 CIMExecQueryResponseMessage* message)
1344 {
|
1345 jenny.yu 1.19 // Use PGOBJARRAY element to encapsulate the CIMObject elements
|
1346 kumpf 1.1 XmlWriter::append(out, "<PGOBJARRAY>\n");
1347 for (Uint32 i=0; i < message->cimObjects.size(); i++)
1348 {
|
1349 jenny.yu 1.19 _serializeCIMObject(out, message->cimObjects[i]);
|
1350 kumpf 1.1 }
1351 XmlWriter::append(out, "</PGOBJARRAY>\n");
1352 }
1353
1354 //
1355 // _serializeCIMAssociatorsResponseMessage
1356 //
1357 void CIMMessageSerializer::_serializeCIMAssociatorsResponseMessage(
|
1358 mike 1.22 Buffer& out,
|
1359 kumpf 1.1 CIMAssociatorsResponseMessage* message)
1360 {
|
1361 jenny.yu 1.19 // Use PGOBJARRAY element to encapsulate the CIMObject elements
|
1362 kumpf 1.1 XmlWriter::append(out, "<PGOBJARRAY>\n");
1363 for (Uint32 i=0; i < message->cimObjects.size(); i++)
1364 {
|
1365 jenny.yu 1.19 _serializeCIMObject(out, message->cimObjects[i]);
|
1366 kumpf 1.1 }
1367 XmlWriter::append(out, "</PGOBJARRAY>\n");
1368 }
1369
1370 //
1371 // _serializeCIMAssociatorNamesResponseMessage
1372 //
1373 void CIMMessageSerializer::_serializeCIMAssociatorNamesResponseMessage(
|
1374 mike 1.22 Buffer& out,
|
1375 kumpf 1.1 CIMAssociatorNamesResponseMessage* message)
1376 {
1377 // Use PGPATHARRAY element to encapsulate the object path elements
1378 XmlWriter::append(out, "<PGPATHARRAY>\n");
1379 for (Uint32 i=0; i < message->objectNames.size(); i++)
1380 {
1381 _serializeCIMObjectPath(out, message->objectNames[i]);
1382 }
1383 XmlWriter::append(out, "</PGPATHARRAY>\n");
1384 }
1385
1386 //
1387 // _serializeCIMReferencesResponseMessage
1388 //
1389 void CIMMessageSerializer::_serializeCIMReferencesResponseMessage(
|
1390 mike 1.22 Buffer& out,
|
1391 kumpf 1.1 CIMReferencesResponseMessage* message)
1392 {
|
1393 jenny.yu 1.19 // Use PGOBJARRAY element to encapsulate the CIMObject elements
|
1394 kumpf 1.1 XmlWriter::append(out, "<PGOBJARRAY>\n");
1395 for (Uint32 i=0; i < message->cimObjects.size(); i++)
1396 {
|
1397 jenny.yu 1.19 _serializeCIMObject(out, message->cimObjects[i]);
|
1398 kumpf 1.1 }
1399 XmlWriter::append(out, "</PGOBJARRAY>\n");
1400 }
1401
1402 //
1403 // _serializeCIMReferenceNamesResponseMessage
1404 //
1405 void CIMMessageSerializer::_serializeCIMReferenceNamesResponseMessage(
|
1406 mike 1.22 Buffer& out,
|
1407 kumpf 1.1 CIMReferenceNamesResponseMessage* message)
1408 {
1409 // Use PGPATHARRAY element to encapsulate the object path elements
1410 XmlWriter::append(out, "<PGPATHARRAY>\n");
1411 for (Uint32 i=0; i < message->objectNames.size(); i++)
1412 {
1413 _serializeCIMObjectPath(out, message->objectNames[i]);
1414 }
1415 XmlWriter::append(out, "</PGPATHARRAY>\n");
1416 }
1417
1418 //
1419 // _serializeCIMGetPropertyResponseMessage
1420 //
1421 void CIMMessageSerializer::_serializeCIMGetPropertyResponseMessage(
|
1422 mike 1.22 Buffer& out,
|
1423 kumpf 1.1 CIMGetPropertyResponseMessage* message)
1424 {
1425 // Use PARAMVALUE element so we can preserve the CIMType information
1426 XmlWriter::appendParamValueElement(
1427 out,
1428 CIMParamValue(String("ignore"), message->value, true));
1429 }
1430
1431 //
1432 // _serializeCIMSetPropertyResponseMessage
1433 //
1434 void CIMMessageSerializer::_serializeCIMSetPropertyResponseMessage(
|
1435 mike 1.22 Buffer& out,
|
1436 kumpf 1.1 CIMSetPropertyResponseMessage* message)
1437 {
1438 // No additional attributes to serialize!
1439 }
1440
1441 //
1442 // _serializeCIMInvokeMethodResponseMessage
1443 //
1444 void CIMMessageSerializer::_serializeCIMInvokeMethodResponseMessage(
|
1445 mike 1.22 Buffer& out,
|
1446 kumpf 1.1 CIMInvokeMethodResponseMessage* message)
1447 {
1448 // Use PARAMVALUE element so we can preserve the CIMType information
1449 XmlWriter::appendParamValueElement(
1450 out,
1451 CIMParamValue(String("ignore"), message->retValue, true));
1452
1453 // Use PGPARAMS element so we can find the end of the PARAMVALUE elements
1454 XmlWriter::append(out, "<PGPARAMS>\n");
1455 for (Uint32 i=0; i < message->outParameters.size(); i++)
1456 {
1457 XmlWriter::appendParamValueElement(out, message->outParameters[i]);
1458 }
1459 XmlWriter::append(out, "</PGPARAMS>\n");
1460
1461 _serializeCIMName(out, message->methodName);
1462 }
1463
1464
1465 //
1466 //
1467 kumpf 1.1 // CIM Indication Response Messages
1468 //
1469 //
1470
1471 //
1472 // _serializeCIMCreateSubscriptionResponseMessage
1473 //
1474 void CIMMessageSerializer::_serializeCIMCreateSubscriptionResponseMessage(
|
1475 mike 1.22 Buffer& out,
|
1476 kumpf 1.1 CIMCreateSubscriptionResponseMessage* message)
1477 {
1478 // No additional attributes to serialize!
1479 }
1480
1481 //
1482 // _serializeCIMModifySubscriptionResponseMessage
1483 //
1484 void CIMMessageSerializer::_serializeCIMModifySubscriptionResponseMessage(
|
1485 mike 1.22 Buffer& out,
|
1486 kumpf 1.1 CIMModifySubscriptionResponseMessage* message)
1487 {
1488 // No additional attributes to serialize!
1489 }
1490
1491 //
1492 // _serializeCIMDeleteSubscriptionResponseMessage
1493 //
1494 void CIMMessageSerializer::_serializeCIMDeleteSubscriptionResponseMessage(
|
1495 mike 1.22 Buffer& out,
|
1496 kumpf 1.1 CIMDeleteSubscriptionResponseMessage* message)
1497 {
1498 // No additional attributes to serialize!
1499 }
1500
1501
1502 //
1503 //
1504 // Other CIMResponseMessages
1505 //
1506 //
1507
1508 //
1509 // _serializeCIMExportIndicationResponseMessage
1510 //
1511 void CIMMessageSerializer::_serializeCIMExportIndicationResponseMessage(
|
1512 mike 1.22 Buffer& out,
|
1513 kumpf 1.1 CIMExportIndicationResponseMessage* message)
1514 {
1515 // No additional attributes to serialize!
1516 }
1517
1518 //
1519 // _serializeCIMProcessIndicationResponseMessage
1520 //
1521 void CIMMessageSerializer::_serializeCIMProcessIndicationResponseMessage(
|
1522 mike 1.22 Buffer& out,
|
1523 kumpf 1.1 CIMProcessIndicationResponseMessage* message)
1524 {
1525 // No additional attributes to serialize!
1526 }
1527
1528 //
1529 // _serializeCIMDisableModuleResponseMessage
1530 //
1531 void CIMMessageSerializer::_serializeCIMDisableModuleResponseMessage(
|
1532 mike 1.22 Buffer& out,
|
1533 kumpf 1.1 CIMDisableModuleResponseMessage* message)
1534 {
1535 // Use PGUINT16ARRAY element to encapsulate the Uint16 elements
1536 XmlWriter::append(out, "<PGUINT16ARRAY>\n");
1537 for (Uint32 i=0; i < message->operationalStatus.size(); i++)
1538 {
1539 XmlWriter::appendValueElement(out, message->operationalStatus[i]);
1540 }
1541 XmlWriter::append(out, "</PGUINT16ARRAY>\n");
1542 }
1543
1544 //
1545 // _serializeCIMEnableModuleResponseMessage
1546 //
1547 void CIMMessageSerializer::_serializeCIMEnableModuleResponseMessage(
|
1548 mike 1.22 Buffer& out,
|
1549 kumpf 1.1 CIMEnableModuleResponseMessage* message)
1550 {
1551 // Use PGUINT16ARRAY element to encapsulate the Uint16 elements
1552 XmlWriter::append(out, "<PGUINT16ARRAY>\n");
1553 for (Uint32 i=0; i < message->operationalStatus.size(); i++)
1554 {
1555 XmlWriter::appendValueElement(out, message->operationalStatus[i]);
1556 }
1557 XmlWriter::append(out, "</PGUINT16ARRAY>\n");
1558 }
1559
1560 //
1561 // _serializeCIMStopAllProvidersResponseMessage
1562 //
1563 void CIMMessageSerializer::_serializeCIMStopAllProvidersResponseMessage(
|
1564 mike 1.22 Buffer& out,
|
1565 kumpf 1.1 CIMStopAllProvidersResponseMessage* message)
1566 {
1567 // No additional attributes to serialize!
1568 }
1569
|
1570 kumpf 1.2 //
1571 // _serializeCIMInitializeProviderResponseMessage
1572 //
1573 void CIMMessageSerializer::_serializeCIMInitializeProviderResponseMessage(
|
1574 mike 1.22 Buffer& out,
|
1575 kumpf 1.2 CIMInitializeProviderResponseMessage* message)
1576 {
1577 // No additional attributes to serialize!
1578 }
1579
|
1580 kumpf 1.7 //
1581 // _serializeCIMInitializeProviderAgentResponseMessage
1582 //
1583 void CIMMessageSerializer::_serializeCIMInitializeProviderAgentResponseMessage(
|
1584 mike 1.22 Buffer& out,
|
1585 kumpf 1.7 CIMInitializeProviderAgentResponseMessage* message)
1586 {
1587 // No additional attributes to serialize!
1588 }
1589
|
1590 kumpf 1.8 //
1591 // _serializeCIMNotifyConfigChangeResponseMessage
1592 //
1593 void CIMMessageSerializer::_serializeCIMNotifyConfigChangeResponseMessage(
|
1594 mike 1.22 Buffer& out,
|
1595 kumpf 1.8 CIMNotifyConfigChangeResponseMessage* message)
1596 {
1597 // No additional attributes to serialize!
1598 }
1599
|
1600 carolann.graves 1.21 //
1601 // _serializeCIMSubscriptionInitCompleteResponseMessage
1602 //
|
1603 kumpf 1.35 void CIMMessageSerializer::_serializeCIMSubscriptionInitCompleteResponseMessage(
1604 Buffer& out,
|
1605 carolann.graves 1.21 CIMSubscriptionInitCompleteResponseMessage* message)
1606 {
1607 // No additional attributes to serialize!
1608 }
1609
|
1610 kumpf 1.1 PEGASUS_NAMESPACE_END
|
Return to
CIMMessageSerializer.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common