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