1 karl 1.28 //%2006////////////////////////////////////////////////////////////////////////
|
2 kumpf 1.1 //
|
3 karl 1.17 // 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.17 // 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.21 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.28 // 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/XmlReader.h>
35 #include <Pegasus/Common/OperationContextInternal.h>
36 #include <Pegasus/Common/System.h>
37
|
38 kumpf 1.1 #include "CIMMessageDeserializer.h"
39
40 PEGASUS_NAMESPACE_BEGIN
41
|
42 david.dillard 1.19 CIMMessage* CIMMessageDeserializer::deserialize(char* buffer)
|
43 kumpf 1.1 {
44 if (buffer[0] == 0)
45 {
46 // No message to deserialize
47 return 0;
48 }
49
50 XmlParser parser(buffer);
51 XmlEntry entry;
52
|
53 w.otsuka 1.23 CIMMessage* message = 0;
|
54 kumpf 1.1 String messageID;
55 String typeString;
|
56 kumpf 1.39 MessageType type;
|
57 kumpf 1.32 CIMValue genericValue;
|
58 kumpf 1.25 #ifndef PEGASUS_DISABLE_PERFINST
|
59 kumpf 1.36 Uint64 serverStartTimeMicroseconds;
60 Uint64 providerTimeMicroseconds;
|
61 kumpf 1.25 #endif
|
62 kumpf 1.31 Boolean isComplete;
|
63 kumpf 1.33 Uint32 index;
|
64 kumpf 1.11 OperationContext operationContext;
|
65 kumpf 1.1
66 XmlReader::expectStartTag(parser, entry, "PGMESSAGE");
67
|
68 kumpf 1.29 Boolean found = entry.getAttributeValue("ID", messageID);
69 PEGASUS_ASSERT(found);
|
70 kumpf 1.1
|
71 kumpf 1.29 found = entry.getAttributeValue("TYPE", typeString);
72 PEGASUS_ASSERT(found);
|
73 kumpf 1.39 type = MessageType(atoi(typeString.getCString()));
|
74 kumpf 1.1
|
75 kumpf 1.25 #ifndef PEGASUS_DISABLE_PERFINST
76 // Deserialize the performance statistics data
77
78 XmlReader::getValueElement(parser, CIMTYPE_UINT64, genericValue);
|
79 kumpf 1.36 genericValue.get(serverStartTimeMicroseconds);
|
80 kumpf 1.25 XmlReader::getValueElement(parser, CIMTYPE_UINT64, genericValue);
|
81 kumpf 1.36 genericValue.get(providerTimeMicroseconds);
|
82 kumpf 1.25 #endif
83
|
84 kumpf 1.31 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
85 genericValue.get(isComplete);
86
|
87 kumpf 1.33 XmlReader::getValueElement(parser, CIMTYPE_UINT32, genericValue);
88 genericValue.get(index);
89
|
90 kumpf 1.11 _deserializeOperationContext(parser, operationContext);
|
91 kumpf 1.1
92 if (XmlReader::testStartTag(parser, entry, "PGREQ"))
93 {
94 message = _deserializeCIMRequestMessage(parser, type);
95 XmlReader::expectEndTag(parser, "PGREQ");
96 }
|
97 kumpf 1.29 else
|
98 kumpf 1.1 {
|
99 kumpf 1.29 // CIMResponseMessage is the only other CIMMessage type defined
100 Boolean found = XmlReader::testStartTag(parser, entry, "PGRESP");
101 PEGASUS_ASSERT(found);
|
102 kumpf 1.1 message = _deserializeCIMResponseMessage(parser, type);
103 XmlReader::expectEndTag(parser, "PGRESP");
104 }
105
106 XmlReader::expectEndTag(parser, "PGMESSAGE");
107
108 message->messageId = messageID;
|
109 kumpf 1.25 #ifndef PEGASUS_DISABLE_PERFINST
|
110 kumpf 1.36 message->setServerStartTime(serverStartTimeMicroseconds);
111 message->setProviderTime(providerTimeMicroseconds);
|
112 kumpf 1.25 #endif
|
113 kumpf 1.31 message->setComplete(isComplete);
|
114 kumpf 1.33 message->setIndex(index);
|
115 kumpf 1.11 message->operationContext = operationContext;
|
116 kumpf 1.1
117 return message;
118 }
119
120 //
121 // _deserializeCIMRequestMessage
122 //
123 CIMRequestMessage* CIMMessageDeserializer::_deserializeCIMRequestMessage(
124 XmlParser& parser,
|
125 kumpf 1.39 MessageType type)
|
126 kumpf 1.1 {
127 CIMRequestMessage* message = 0;
128 XmlEntry entry;
129 QueueIdStack queueIdStack;
130
131 _deserializeQueueIdStack(parser, queueIdStack);
132
133 if (XmlReader::testStartTag(parser, entry, "PGOPREQ"))
134 {
|
135 w.otsuka 1.23 CIMOperationRequestMessage* cimOpReqMessage = 0;
|
136 kumpf 1.1 CIMValue genericValue;
|
137 kumpf 1.35 String authType;
138 String userName;
|
139 kumpf 1.1 CIMNamespaceName nameSpace;
140 CIMName className;
141 Uint32 providerType;
142
|
143 kumpf 1.35 _deserializeUserInfo(parser, authType, userName);
|
144 kumpf 1.1 _deserializeCIMNamespaceName(parser, nameSpace);
145 _deserializeCIMName(parser, className);
146
147 // Decode cimMessage->providerType
148 XmlReader::getValueElement(parser, CIMTYPE_UINT32, genericValue);
149 genericValue.get(providerType);
150
151 switch (type)
152 {
|
153 kumpf 1.29 // A provider cannot implement these operation types, so the
154 // serialization of these messages is not implemented.
155 //case CIM_GET_CLASS_REQUEST_MESSAGE:
156 //case CIM_DELETE_CLASS_REQUEST_MESSAGE:
157 //case CIM_CREATE_CLASS_REQUEST_MESSAGE:
158 //case CIM_MODIFY_CLASS_REQUEST_MESSAGE:
159 //case CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE:
160 //case CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE:
161 //case CIM_GET_QUALIFIER_REQUEST_MESSAGE:
162 //case CIM_SET_QUALIFIER_REQUEST_MESSAGE:
163 //case CIM_DELETE_QUALIFIER_REQUEST_MESSAGE:
164 //case CIM_ENUMERATE_QUALIFIERS_REQUEST_MESSAGE:
|
165 kumpf 1.1
166 // Instance operations
167 case CIM_GET_INSTANCE_REQUEST_MESSAGE:
168 cimOpReqMessage = _deserializeCIMGetInstanceRequestMessage(parser);
169 break;
170 case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
|
171 kumpf 1.37 cimOpReqMessage =
172 _deserializeCIMDeleteInstanceRequestMessage(parser);
|
173 kumpf 1.1 break;
174 case CIM_CREATE_INSTANCE_REQUEST_MESSAGE:
|
175 kumpf 1.37 cimOpReqMessage =
176 _deserializeCIMCreateInstanceRequestMessage(parser);
|
177 kumpf 1.1 break;
178 case CIM_MODIFY_INSTANCE_REQUEST_MESSAGE:
|
179 kumpf 1.37 cimOpReqMessage =
180 _deserializeCIMModifyInstanceRequestMessage(parser);
|
181 kumpf 1.1 break;
182 case CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE:
|
183 kumpf 1.37 cimOpReqMessage =
184 _deserializeCIMEnumerateInstancesRequestMessage(parser);
|
185 kumpf 1.1 break;
186 case CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE:
|
187 kumpf 1.37 cimOpReqMessage =
188 _deserializeCIMEnumerateInstanceNamesRequestMessage(parser);
|
189 kumpf 1.1 break;
190 case CIM_EXEC_QUERY_REQUEST_MESSAGE:
191 cimOpReqMessage = _deserializeCIMExecQueryRequestMessage(parser);
192 break;
193
194 // Property operations
195 case CIM_GET_PROPERTY_REQUEST_MESSAGE:
196 cimOpReqMessage = _deserializeCIMGetPropertyRequestMessage(parser);
197 break;
198 case CIM_SET_PROPERTY_REQUEST_MESSAGE:
199 cimOpReqMessage = _deserializeCIMSetPropertyRequestMessage(parser);
200 break;
201
202 // Association operations
203 case CIM_ASSOCIATORS_REQUEST_MESSAGE:
204 cimOpReqMessage = _deserializeCIMAssociatorsRequestMessage(parser);
205 break;
206 case CIM_ASSOCIATOR_NAMES_REQUEST_MESSAGE:
|
207 kumpf 1.37 cimOpReqMessage =
208 _deserializeCIMAssociatorNamesRequestMessage(parser);
|
209 kumpf 1.1 break;
210 case CIM_REFERENCES_REQUEST_MESSAGE:
211 cimOpReqMessage = _deserializeCIMReferencesRequestMessage(parser);
212 break;
213 case CIM_REFERENCE_NAMES_REQUEST_MESSAGE:
|
214 kumpf 1.37 cimOpReqMessage =
215 _deserializeCIMReferenceNamesRequestMessage(parser);
|
216 kumpf 1.1 break;
217
218 // Method operations
219 case CIM_INVOKE_METHOD_REQUEST_MESSAGE:
220 cimOpReqMessage = _deserializeCIMInvokeMethodRequestMessage(parser);
221 break;
|
222 kumpf 1.39
223 default:
224 // Unexpected message type
225 PEGASUS_ASSERT(0);
226 break;
|
227 kumpf 1.1 }
|
228 kumpf 1.29 PEGASUS_ASSERT(cimOpReqMessage != 0);
|
229 kumpf 1.1
230 XmlReader::expectEndTag(parser, "PGOPREQ");
231
|
232 kumpf 1.35 cimOpReqMessage->authType = authType;
233 cimOpReqMessage->userName = userName;
|
234 kumpf 1.1 cimOpReqMessage->nameSpace = CIMNamespaceName(nameSpace);
235 cimOpReqMessage->className = className;
236 cimOpReqMessage->providerType = providerType;
237
238 message = cimOpReqMessage;
239 }
240 else if (XmlReader::testStartTag(parser, entry, "PGINDREQ"))
241 {
|
242 kumpf 1.35 String authType;
243 String userName;
244
245 _deserializeUserInfo(parser, authType, userName);
246
|
247 w.otsuka 1.23 CIMIndicationRequestMessage* cimIndReqMessage = 0;
|
248 kumpf 1.1 switch (type)
249 {
250 case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
|
251 kumpf 1.37 cimIndReqMessage =
252 _deserializeCIMCreateSubscriptionRequestMessage(parser);
|
253 kumpf 1.1 break;
254 case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
|
255 kumpf 1.37 cimIndReqMessage =
256 _deserializeCIMModifySubscriptionRequestMessage(parser);
|
257 kumpf 1.1 break;
258 case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
|
259 kumpf 1.37 cimIndReqMessage =
260 _deserializeCIMDeleteSubscriptionRequestMessage(parser);
|
261 kumpf 1.1 break;
|
262 kumpf 1.39 default:
263 // Unexpected message type
264 PEGASUS_ASSERT(0);
265 break;
|
266 kumpf 1.1 }
|
267 kumpf 1.29 PEGASUS_ASSERT(cimIndReqMessage != 0);
|
268 kumpf 1.1
269 XmlReader::expectEndTag(parser, "PGINDREQ");
270
|
271 kumpf 1.35 cimIndReqMessage->authType = authType;
272 cimIndReqMessage->userName = userName;
273
|
274 kumpf 1.1 message = cimIndReqMessage;
275 }
276 else // Other message types
277 {
278 XmlReader::expectStartTag(parser, entry, "PGOTHERREQ");
279
280 switch (type)
281 {
282 case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
283 message = _deserializeCIMExportIndicationRequestMessage(parser);
284 break;
285 case CIM_PROCESS_INDICATION_REQUEST_MESSAGE:
286 message = _deserializeCIMProcessIndicationRequestMessage(parser);
287 break;
|
288 kumpf 1.29 //case CIM_NOTIFY_PROVIDER_REGISTRATION_REQUEST_MESSAGE:
|
289 kumpf 1.1 // ATTN: No need to serialize this yet
|
290 kumpf 1.37 //message =
291 // _deserializeCIMNotifyProviderRegistrationRequestMessage(parser);
|
292 kumpf 1.1 break;
|
293 kumpf 1.29 //case CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE:
|
294 kumpf 1.1 // ATTN: No need to serialize this yet
|
295 kumpf 1.37 //message =
296 // _deserializeCIMNotifyProviderTerminationRequestMessage(parser);
|
297 kumpf 1.1 break;
|
298 kumpf 1.29 //case CIM_HANDLE_INDICATION_REQUEST_MESSAGE:
|
299 kumpf 1.1 // ATTN: No need to serialize this yet
300 //message = _deserializeCIMHandleIndicationRequestMessage(parser);
301 break;
302 case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
303 message = _deserializeCIMDisableModuleRequestMessage(parser);
304 break;
305 case CIM_ENABLE_MODULE_REQUEST_MESSAGE:
306 message = _deserializeCIMEnableModuleRequestMessage(parser);
307 break;
|
308 kumpf 1.29 //case CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE:
|
309 kumpf 1.1 // ATTN: No need to serialize this yet
|
310 kumpf 1.37 //message =
311 // _deserializeCIMNotifyProviderEnableRequestMessage(parser);
|
312 kumpf 1.1 break;
|
313 carolann.graves 1.34 //case CIM_NOTIFY_PROVIDER_FAIL_REQUEST_MESSAGE:
314 // ATTN: No need to deserialize this yet
315 //message = _deserializeCIMNotifyProviderFailRequestMessage(parser);
316 //break;
|
317 kumpf 1.1 case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
318 message = _deserializeCIMStopAllProvidersRequestMessage(parser);
319 break;
|
320 kumpf 1.7 case CIM_INITIALIZE_PROVIDER_AGENT_REQUEST_MESSAGE:
321 message =
322 _deserializeCIMInitializeProviderAgentRequestMessage(parser);
323 break;
|
324 kumpf 1.8 case CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE:
325 message = _deserializeCIMNotifyConfigChangeRequestMessage(parser);
326 break;
|
327 carolann.graves 1.22 case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
|
328 kumpf 1.37 message =
|
329 carolann.graves 1.22 _deserializeCIMSubscriptionInitCompleteRequestMessage
330 (parser);
331 break;
|
332 kumpf 1.39 default:
333 // Unexpected message type
334 PEGASUS_ASSERT(0);
335 break;
|
336 kumpf 1.1 }
|
337 kumpf 1.29 PEGASUS_ASSERT(message != 0);
|
338 kumpf 1.1
339 XmlReader::expectEndTag(parser, "PGOTHERREQ");
340 }
341
342 message->queueIds = queueIdStack;
343
344 return message;
345 }
346
347 //
348 // _deserializeCIMResponseMessage
349 //
350 CIMResponseMessage* CIMMessageDeserializer::_deserializeCIMResponseMessage(
351 XmlParser& parser,
|
352 kumpf 1.39 MessageType type)
|
353 kumpf 1.1 {
354 CIMResponseMessage* message = 0;
355 QueueIdStack queueIdStack;
356 CIMException cimException;
357
358 _deserializeQueueIdStack(parser, queueIdStack);
359 _deserializeCIMException(parser, cimException);
360
361 switch (type)
362 {
363 //
364 // CIM Operation Response Messages
365 //
366
|
367 kumpf 1.29 // A provider cannot implement these operation types, so the
368 // serialization of these messages is not implemented.
369 //case CIM_GET_CLASS_RESPONSE_MESSAGE:
370 //case CIM_DELETE_CLASS_RESPONSE_MESSAGE:
371 //case CIM_CREATE_CLASS_RESPONSE_MESSAGE:
372 //case CIM_MODIFY_CLASS_RESPONSE_MESSAGE:
373 //case CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE:
374 //case CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE:
375 //case CIM_GET_QUALIFIER_RESPONSE_MESSAGE:
376 //case CIM_SET_QUALIFIER_RESPONSE_MESSAGE:
377 //case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:
378 //case CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE:
|
379 kumpf 1.1
380 // Instance operations
381 case CIM_GET_INSTANCE_RESPONSE_MESSAGE:
382 message = _deserializeCIMGetInstanceResponseMessage(parser);
383 break;
384 case CIM_DELETE_INSTANCE_RESPONSE_MESSAGE:
385 message = _deserializeCIMDeleteInstanceResponseMessage(parser);
386 break;
387 case CIM_CREATE_INSTANCE_RESPONSE_MESSAGE:
388 message = _deserializeCIMCreateInstanceResponseMessage(parser);
389 break;
390 case CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE:
391 message = _deserializeCIMModifyInstanceResponseMessage(parser);
392 break;
393 case CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE:
394 message = _deserializeCIMEnumerateInstancesResponseMessage(parser);
395 break;
396 case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:
|
397 kumpf 1.37 message =
398 _deserializeCIMEnumerateInstanceNamesResponseMessage(parser);
|
399 kumpf 1.1 break;
400 case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
401 message = _deserializeCIMExecQueryResponseMessage(parser);
402 break;
403
404 // Property operations
405 case CIM_GET_PROPERTY_RESPONSE_MESSAGE:
406 message = _deserializeCIMGetPropertyResponseMessage(parser);
407 break;
408 case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
409 message = _deserializeCIMSetPropertyResponseMessage(parser);
410 break;
411
412 // Association operations
413 case CIM_ASSOCIATORS_RESPONSE_MESSAGE:
414 message = _deserializeCIMAssociatorsResponseMessage(parser);
415 break;
416 case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:
417 message = _deserializeCIMAssociatorNamesResponseMessage(parser);
418 break;
419 case CIM_REFERENCES_RESPONSE_MESSAGE:
420 kumpf 1.1 message = _deserializeCIMReferencesResponseMessage(parser);
421 break;
422 case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:
423 message = _deserializeCIMReferenceNamesResponseMessage(parser);
424 break;
425
426 // Method operations
427 case CIM_INVOKE_METHOD_RESPONSE_MESSAGE:
428 message = _deserializeCIMInvokeMethodResponseMessage(parser);
429 break;
430
431 //
432 // CIM Indication Response Messages
433 //
434
435 case CIM_CREATE_SUBSCRIPTION_RESPONSE_MESSAGE:
436 message = _deserializeCIMCreateSubscriptionResponseMessage(parser);
437 break;
438 case CIM_MODIFY_SUBSCRIPTION_RESPONSE_MESSAGE:
439 message = _deserializeCIMModifySubscriptionResponseMessage(parser);
440 break;
441 kumpf 1.1 case CIM_DELETE_SUBSCRIPTION_RESPONSE_MESSAGE:
442 message = _deserializeCIMDeleteSubscriptionResponseMessage(parser);
443 break;
444
445 //
446 // Other CIM Response Messages
447 //
448
449 case CIM_EXPORT_INDICATION_RESPONSE_MESSAGE:
450 message = _deserializeCIMExportIndicationResponseMessage(parser);
451 break;
452 case CIM_PROCESS_INDICATION_RESPONSE_MESSAGE:
453 message = _deserializeCIMProcessIndicationResponseMessage(parser);
454 break;
|
455 kumpf 1.29 //case CIM_NOTIFY_PROVIDER_REGISTRATION_RESPONSE_MESSAGE:
|
456 kumpf 1.1 // ATTN: No need to serialize this yet
|
457 kumpf 1.37 //message =
458 // _deserializeCIMNotifyProviderRegistrationResponseMessage(
459 // parser);
|
460 kumpf 1.29 //break;
461 //case CIM_NOTIFY_PROVIDER_TERMINATION_RESPONSE_MESSAGE:
|
462 kumpf 1.1 // ATTN: No need to serialize this yet
|
463 kumpf 1.37 //message =
464 // _deserializeCIMNotifyProviderTerminationResponseMessage(parser);
|
465 kumpf 1.29 //break;
466 //case CIM_HANDLE_INDICATION_RESPONSE_MESSAGE:
|
467 kumpf 1.1 // ATTN: No need to serialize this yet
468 //message = _deserializeCIMHandleIndicationResponseMessage(parser);
|
469 kumpf 1.29 //break;
|
470 kumpf 1.1 case CIM_DISABLE_MODULE_RESPONSE_MESSAGE:
471 message = _deserializeCIMDisableModuleResponseMessage(parser);
472 break;
473 case CIM_ENABLE_MODULE_RESPONSE_MESSAGE:
474 message = _deserializeCIMEnableModuleResponseMessage(parser);
475 break;
|
476 kumpf 1.29 //case CIM_NOTIFY_PROVIDER_ENABLE_RESPONSE_MESSAGE:
|
477 kumpf 1.1 // ATTN: No need to serialize this yet
|
478 kumpf 1.37 //message =
479 // _deserializeCIMNotifyProviderEnableResponseMessage(parser);
|
480 kumpf 1.29 //break;
|
481 carolann.graves 1.34 //case CIM_NOTIFY_PROVIDER_FAIL_RESPONSE_MESSAGE:
482 // ATTN: No need to deserialize this yet
|
483 kumpf 1.37 //message =
484 // _deserializeCIMNotifyProviderFailResponseMessage(parser);
|
485 carolann.graves 1.34 //break;
|
486 kumpf 1.1 case CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE:
487 message = _deserializeCIMStopAllProvidersResponseMessage(parser);
488 break;
|
489 kumpf 1.7 case CIM_INITIALIZE_PROVIDER_AGENT_RESPONSE_MESSAGE:
490 message =
491 _deserializeCIMInitializeProviderAgentResponseMessage(parser);
492 break;
|
493 kumpf 1.8 case CIM_NOTIFY_CONFIG_CHANGE_RESPONSE_MESSAGE:
494 message = _deserializeCIMNotifyConfigChangeResponseMessage(parser);
495 break;
|
496 carolann.graves 1.22 case CIM_SUBSCRIPTION_INIT_COMPLETE_RESPONSE_MESSAGE:
|
497 kumpf 1.37 message =
|
498 carolann.graves 1.22 _deserializeCIMSubscriptionInitCompleteResponseMessage
499 (parser);
500 break;
|
501 kumpf 1.39
502 default:
503 // Unexpected message type
504 PEGASUS_ASSERT(0);
505 break;
|
506 kumpf 1.1 }
|
507 kumpf 1.29 PEGASUS_ASSERT(message != 0);
|
508 kumpf 1.1
509 message->queueIds = queueIdStack;
510 message->cimException = cimException;
511
512 return message;
513 }
514
515
516 //
517 // Utility Methods
518 //
519
520 //
521 // _deserializeUserInfo consolidates decoding of these common message attributes
522 //
523 void CIMMessageDeserializer::_deserializeUserInfo(
524 XmlParser& parser,
525 String& authType,
526 String& userName)
527 {
528 CIMValue genericValue;
529 kumpf 1.1
530 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
531 genericValue.get(authType);
532
533 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
534 genericValue.get(userName);
535 }
536
537 //
538 // _deserializeQueueIdStack
539 //
540 void CIMMessageDeserializer::_deserializeQueueIdStack(
541 XmlParser& parser,
542 QueueIdStack& queueIdStack)
543 {
544 // ATTN: Incoming queueIdStack is presumed to be empty
545
546 XmlEntry entry;
547 CIMValue genericValue;
548 Uint32 genericUint32;
549 Array<Uint32> items;
550 kumpf 1.1
551 XmlReader::expectStartTag(parser, entry, "PGQIDSTACK");
552 while (XmlReader::getValueElement(parser, CIMTYPE_UINT32, genericValue))
553 {
554 genericValue.get(genericUint32);
555 items.append(genericUint32);
556 }
557 XmlReader::expectEndTag(parser, "PGQIDSTACK");
558
559 for (Uint32 i=items.size(); i>0; i--)
560 {
561 queueIdStack.push(items[i-1]);
562 }
563 }
564
565 //
566 // _deserializeOperationContext
567 //
568 void CIMMessageDeserializer::_deserializeOperationContext(
569 XmlParser& parser,
570 OperationContext& operationContext)
571 kumpf 1.1 {
|
572 kumpf 1.29 operationContext.clear();
|
573 kumpf 1.1
574 XmlEntry entry;
575 CIMValue genericValue;
576 String genericString;
577
578 XmlReader::expectStartTag(parser, entry, "PGOC");
579
580 if (XmlReader::testStartTag(parser, entry, "PGOCID"))
581 {
582 String userName;
583
584 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
585 genericValue.get(userName);
586 operationContext.insert(IdentityContainer(userName));
587 XmlReader::expectEndTag(parser, "PGOCID");
588 }
589
590 if (XmlReader::testStartTag(parser, entry, "PGOCSI"))
591 {
592 CIMInstance subscriptionInstance;
593 _deserializeCIMInstance(parser, subscriptionInstance);
594 kumpf 1.1 operationContext.insert(
595 SubscriptionInstanceContainer(subscriptionInstance));
596 XmlReader::expectEndTag(parser, "PGOCSI");
597 }
598
599 if (XmlReader::testStartTag(parser, entry, "PGOCSFC"))
600 {
601 String filterCondition;
602 String queryLanguage;
603
604 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
605 genericValue.get(filterCondition);
606 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
607 genericValue.get(queryLanguage);
608 operationContext.insert(
609 SubscriptionFilterConditionContainer(
610 filterCondition, queryLanguage));
611 XmlReader::expectEndTag(parser, "PGOCSFC");
612 }
613
|
614 chuck 1.18 if (XmlReader::testStartTag(parser, entry, "PGOCSFQ"))
615 {
616 String filterQuery;
617 String queryLanguage;
618 CIMNamespaceName nameSpace;
619
620 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
621 genericValue.get(filterQuery);
622 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
623 genericValue.get(queryLanguage);
624 _deserializeCIMNamespaceName(parser, nameSpace);
625 operationContext.insert(
626 SubscriptionFilterQueryContainer(
627 filterQuery, queryLanguage, nameSpace));
628 XmlReader::expectEndTag(parser, "PGOCSFQ");
629 }
630
|
631 kumpf 1.1 if (XmlReader::testStartTag(parser, entry, "PGOCSIN"))
632 {
633 Array<CIMObjectPath> subscriptionInstanceNames;
634 CIMObjectPath genericObjectPath;
635
636 while (_deserializeCIMObjectPath(parser, genericObjectPath))
637 {
638 subscriptionInstanceNames.append(genericObjectPath);
639 }
640 operationContext.insert(
641 SubscriptionInstanceNamesContainer(subscriptionInstanceNames));
642 XmlReader::expectEndTag(parser, "PGOCSIN");
643 }
644
645 if (XmlReader::testStartTag(parser, entry, "PGOCTO"))
646 {
647 Uint32 timeout;
648
649 XmlReader::getValueElement(parser, CIMTYPE_UINT32, genericValue);
650 genericValue.get(timeout);
651 operationContext.insert(TimeoutContainer(timeout));
652 kumpf 1.1 XmlReader::expectEndTag(parser, "PGOCTO");
653 }
654
655 if (XmlReader::testStartTag(parser, entry, "PGOCALL"))
656 {
|
657 kumpf 1.27 AcceptLanguageList acceptLanguages;
|
658 kumpf 1.1
|
659 kumpf 1.27 _deserializeAcceptLanguageList(parser, acceptLanguages);
|
660 kumpf 1.1 operationContext.insert(AcceptLanguageListContainer(acceptLanguages));
661 XmlReader::expectEndTag(parser, "PGOCALL");
662 }
663
664 if (XmlReader::testStartTag(parser, entry, "PGOCCLL"))
665 {
|
666 kumpf 1.27 ContentLanguageList contentLanguages;
|
667 kumpf 1.1
|
668 kumpf 1.27 _deserializeContentLanguageList(parser, contentLanguages);
|
669 kumpf 1.1 operationContext.insert(
670 ContentLanguageListContainer(contentLanguages));
671 XmlReader::expectEndTag(parser, "PGOCCLL");
672 }
673
674 if (XmlReader::testStartTag(parser, entry, "PGOCSTO"))
675 {
676 String snmpTrapOid;
677
678 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
679 genericValue.get(snmpTrapOid);
680 operationContext.insert(SnmpTrapOidContainer(snmpTrapOid));
681 XmlReader::expectEndTag(parser, "PGOCSTO");
682 }
683
684 if (XmlReader::testStartTag(parser, entry, "PGOCL"))
685 {
686 String languageId;
687
688 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
689 genericValue.get(languageId);
690 kumpf 1.1 operationContext.insert(LocaleContainer(languageId));
691 XmlReader::expectEndTag(parser, "PGOCL");
692 }
693
694 if (XmlReader::testStartTag(parser, entry, "PGOCPI"))
695 {
|
696 kumpf 1.11 CIMValue genericValue;
|
697 kumpf 1.1 CIMInstance module;
698 CIMInstance provider;
|
699 kumpf 1.11 Boolean isRemoteNameSpace;
700 String remoteInfo;
|
701 b.whiteley 1.43 String provMgrPath;
|
702 kumpf 1.1
703 _deserializeCIMInstance(parser, module);
704 _deserializeCIMInstance(parser, provider);
|
705 kumpf 1.11
706 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
707 genericValue.get(isRemoteNameSpace);
708
709 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
710 genericValue.get(remoteInfo);
711
|
712 b.whiteley 1.43 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
713 genericValue.get(provMgrPath);
714
715 ProviderIdContainer pidc = ProviderIdContainer(module,
716 provider,
717 isRemoteNameSpace,
718 remoteInfo);
719 pidc.setProvMgrPath(provMgrPath);
720 operationContext.insert(pidc);
|
721 kumpf 1.1 XmlReader::expectEndTag(parser, "PGOCPI");
722 }
723
|
724 ouyang.jian 1.41 if (XmlReader::testStartTag(parser, entry, "PGOCCCD"))
725 {
726 CIMClass cimClass;
727
728 XmlReader::getClassElement(parser, cimClass);
729 operationContext.insert(CachedClassDefinitionContainer(cimClass));
730 XmlReader::expectEndTag(parser, "PGOCCCD");
731 }
732
|
733 kumpf 1.1 XmlReader::expectEndTag(parser, "PGOC");
734 }
735
736 //
|
737 kumpf 1.27 // _deserializeContentLanguageList
|
738 kumpf 1.1 //
|
739 kumpf 1.27 void CIMMessageDeserializer::_deserializeContentLanguageList(
|
740 kumpf 1.1 XmlParser& parser,
|
741 kumpf 1.27 ContentLanguageList& contentLanguages)
|
742 kumpf 1.1 {
|
743 kumpf 1.29 contentLanguages.clear();
|
744 kumpf 1.1
745 XmlEntry entry;
746 CIMValue genericValue;
747 String genericString;
748
749 XmlReader::expectStartTag(parser, entry, "PGCONTLANGS");
750 while (XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue))
751 {
752 genericValue.get(genericString);
|
753 kumpf 1.26 contentLanguages.append(LanguageTag(genericString));
|
754 kumpf 1.1 }
755 XmlReader::expectEndTag(parser, "PGCONTLANGS");
756 }
757
758 //
|
759 kumpf 1.27 // _deserializeAcceptLanguageList
|
760 kumpf 1.1 //
|
761 kumpf 1.27 void CIMMessageDeserializer::_deserializeAcceptLanguageList(
|
762 kumpf 1.1 XmlParser& parser,
|
763 kumpf 1.27 AcceptLanguageList& acceptLanguages)
|
764 kumpf 1.1 {
|
765 kumpf 1.29 acceptLanguages.clear();
|
766 kumpf 1.1
767 XmlEntry entry;
768 CIMValue genericValue;
769 String genericString;
770 Real32 genericReal32;
771
772 XmlReader::expectStartTag(parser, entry, "PGACCLANGS");
773 while (XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue))
774 {
775 genericValue.get(genericString);
776 XmlReader::getValueElement(parser, CIMTYPE_REAL32, genericValue);
777 genericValue.get(genericReal32);
|
778 kumpf 1.26 acceptLanguages.insert(LanguageTag(genericString), genericReal32);
|
779 kumpf 1.1 }
780 XmlReader::expectEndTag(parser, "PGACCLANGS");
781 }
782
783 //
784 // _deserializeCIMException
785 //
786 void CIMMessageDeserializer::_deserializeCIMException(
787 XmlParser& parser,
788 CIMException& cimException)
789 {
790 XmlEntry entry;
791 CIMValue genericValue;
|
792 kumpf 1.9 Uint32 statusCode;
793 String message;
794 String cimMessage;
795 String file;
796 Uint32 line;
|
797 kumpf 1.27 ContentLanguageList contentLanguages;
|
798 kumpf 1.1
799 XmlReader::expectStartTag(parser, entry, "PGCIMEXC");
800
801 XmlReader::getValueElement(parser, CIMTYPE_UINT32, genericValue);
|
802 kumpf 1.9 genericValue.get(statusCode);
803 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
804 genericValue.get(message);
|
805 kumpf 1.1 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
|
806 kumpf 1.9 genericValue.get(cimMessage);
807 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
808 genericValue.get(file);
809 XmlReader::getValueElement(parser, CIMTYPE_UINT32, genericValue);
810 genericValue.get(line);
|
811 kumpf 1.27 _deserializeContentLanguageList(parser, contentLanguages);
|
812 kumpf 1.1
813 XmlReader::expectEndTag(parser, "PGCIMEXC");
814
|
815 kumpf 1.9 TraceableCIMException e = TraceableCIMException(
816 contentLanguages,
817 CIMStatusCode(statusCode),
818 message,
819 file,
820 line);
821 e.setCIMMessage(cimMessage);
822 cimException = e;
|
823 kumpf 1.1 }
824
825 //
826 // _deserializeCIMPropertyList
827 //
828 void CIMMessageDeserializer::_deserializeCIMPropertyList(
829 XmlParser& parser,
830 CIMPropertyList& propertyList)
831 {
832 const char* name;
833 CIMValue genericValue;
|
834 kumpf 1.12 Boolean emptyTag;
|
835 kumpf 1.1
836 propertyList.clear();
|
837 kumpf 1.12 XmlReader::getIParamValueTag(parser, name, emptyTag);
838 PEGASUS_ASSERT(!emptyTag);
|
839 kumpf 1.1 PEGASUS_ASSERT(System::strcasecmp(name, "PropertyList") == 0);
840 if (XmlReader::getValueArrayElement(parser, CIMTYPE_STRING, genericValue))
841 {
842 Array<String> propertyListArray;
843 genericValue.get(propertyListArray);
844 Array<CIMName> cimNameArray;
845 for (Uint32 i = 0; i < propertyListArray.size(); i++)
846 {
847 cimNameArray.append(propertyListArray[i]);
848 }
849 propertyList.set(cimNameArray);
850 }
851 XmlReader::expectEndTag(parser, "IPARAMVALUE");
852 }
853
854 //
855 // _deserializeCIMObjectPath
856 //
857 Boolean CIMMessageDeserializer::_deserializeCIMObjectPath(
858 XmlParser& parser,
859 CIMObjectPath& cimObjectPath)
860 kumpf 1.1 {
861 XmlEntry entry;
862
863 if (!XmlReader::testStartTag(parser, entry, "PGPATH"))
864 {
865 return false;
866 }
867
868 // VALUE.REFERENCE element is absent when the object is uninitialized.
869 // In this case, XmlReader::getValueReferenceElement returns "false" and
870 // leaves cimObjectPath untouched.
871 if (!XmlReader::getValueReferenceElement(parser, cimObjectPath))
872 {
873 cimObjectPath = CIMObjectPath();
874 }
875
876 XmlReader::expectEndTag(parser, "PGPATH");
877
878 return true;
879 }
880
881 kumpf 1.1 //
882 // _deserializeCIMInstance
883 //
884 Boolean CIMMessageDeserializer::_deserializeCIMInstance(
885 XmlParser& parser,
886 CIMInstance& cimInstance)
887 {
888 XmlEntry entry;
889
890 if (!XmlReader::testStartTag(parser, entry, "PGINST"))
891 {
892 return false;
893 }
894
895 // INSTANCE element is absent when the object is uninitialized.
|
896 jenny.yu 1.20 // In this case, XmlReader::getInstanceElement returns "false" and
|
897 kumpf 1.1 // leaves cimInstance untouched.
|
898 jenny.yu 1.20 if (XmlReader::getInstanceElement(parser, cimInstance))
899 {
900 CIMObjectPath path;
901 _deserializeCIMObjectPath(parser, path);
902 cimInstance.setPath(path);
903 }
904 else
|
905 kumpf 1.1 {
906 cimInstance = CIMInstance();
907 }
908
909 XmlReader::expectEndTag(parser, "PGINST");
910
911 return true;
912 }
913
914 //
915 // _deserializeCIMNamespaceName
916 //
917 void CIMMessageDeserializer::_deserializeCIMNamespaceName(
918 XmlParser& parser,
919 CIMNamespaceName& cimNamespaceName)
920 {
921 CIMValue genericValue;
922 String genericString;
923
924 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
925 genericValue.get(genericString);
926 kumpf 1.1 if (genericString.size() > 0)
927 {
928 cimNamespaceName = CIMNamespaceName(genericString);
929 }
930 }
931
932 //
933 // _deserializeCIMName
934 //
935 Boolean CIMMessageDeserializer::_deserializeCIMName(
936 XmlParser& parser,
937 CIMName& cimName)
938 {
939 CIMValue genericValue;
940 String genericString;
941
942 if (!XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue))
943 {
944 return false;
945 }
946
947 kumpf 1.1 genericValue.get(genericString);
948 if (genericString.size() > 0)
949 {
950 cimName = CIMName(genericString);
951 }
952 else
953 {
954 cimName = CIMName();
955 }
956
957 return true;
958 }
959
|
960 jenny.yu 1.20 //
961 // _deserializeCIMObject
962 //
963 Boolean CIMMessageDeserializer::_deserializeCIMObject(
964 XmlParser& parser,
965 CIMObject& object)
966 {
967 XmlEntry entry;
968
969 if (!XmlReader::testStartTag(parser, entry, "PGOBJ"))
970 {
971 return false;
972 }
973
974 CIMInstance cimInstance;
975 CIMClass cimClass;
976 CIMObjectPath path;
977
978 // INSTANCE or CLASS element is absent when the object is uninitialized
979 if (XmlReader::getInstanceElement(parser, cimInstance))
980 {
981 jenny.yu 1.20 _deserializeCIMObjectPath(parser, path);
982 cimInstance.setPath(path);
983 object = CIMObject(cimInstance);
984 }
985 else if (XmlReader::getClassElement(parser, cimClass))
986 {
987 _deserializeCIMObjectPath(parser, path);
988 cimClass.setPath(path);
989 object = CIMObject(cimClass);
990 }
991 else
992 {
993 // Uninitialized object
994 object = CIMObject();
995 }
996
997 XmlReader::expectEndTag(parser, "PGOBJ");
998
999 return true;
1000 }
|
1001 kumpf 1.1
1002 //
|
1003 kumpf 1.40 // _deserializeCIMParamValue
1004 //
1005 Boolean CIMMessageDeserializer::_deserializeCIMParamValue(
1006 XmlParser& parser,
1007 CIMParamValue& paramValue)
1008 {
1009 XmlEntry entry;
1010
1011 if (XmlReader::getParamValueElement(parser, paramValue))
1012 {
1013 return true;
1014 }
1015
1016 if (XmlReader::testStartTagOrEmptyTag(parser, entry, "PGNULLPARAMVALUE"))
1017 {
1018 // The parameter value is null; set the correct type
1019
1020 CIMValue genericValue;
1021 CIMType type;
1022 String name;
1023 Boolean isArray;
1024 kumpf 1.40
1025 Boolean found = XmlReader::getCimTypeAttribute(
1026 parser.getLine(),
1027 entry,
1028 type,
1029 "PGNULLPARAMVALUE",
1030 "PARAMTYPE",
1031 false);
1032 PEGASUS_ASSERT(found);
1033
1034 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1035 genericValue.get(name);
1036
1037 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1038 genericValue.get(isArray);
1039
1040 XmlReader::expectEndTag(parser, "PGNULLPARAMVALUE");
1041
1042 paramValue = CIMParamValue(name, CIMValue(type, isArray), true);
1043 return true;
1044 }
1045 kumpf 1.40
1046 return false;
1047 }
1048
1049
1050 //
|
1051 kumpf 1.1 //
1052 // Response Messages
1053 //
1054 //
1055
1056 //
1057 //
1058 // CIMOperationRequestMessages
1059 //
1060 //
1061
1062 //
1063 // _deserializeCIMGetInstanceRequestMessage
1064 //
1065 CIMGetInstanceRequestMessage*
1066 CIMMessageDeserializer::_deserializeCIMGetInstanceRequestMessage(
1067 XmlParser& parser)
1068 {
1069 CIMValue genericValue;
1070 CIMObjectPath instanceName;
1071 Boolean localOnly;
1072 kumpf 1.1 Boolean includeQualifiers;
1073 Boolean includeClassOrigin;
1074 CIMPropertyList propertyList;
1075
1076 _deserializeCIMObjectPath(parser, instanceName);
1077
1078 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1079 genericValue.get(localOnly);
1080
1081 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1082 genericValue.get(includeQualifiers);
1083
1084 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1085 genericValue.get(includeClassOrigin);
1086
1087 _deserializeCIMPropertyList(parser, propertyList);
1088
1089 CIMGetInstanceRequestMessage* message =
1090 new CIMGetInstanceRequestMessage(
1091 String::EMPTY, // messageId
1092 CIMNamespaceName(), // nameSpace
1093 kumpf 1.1 instanceName,
1094 localOnly,
1095 includeQualifiers,
1096 includeClassOrigin,
1097 propertyList,
|
1098 kumpf 1.35 QueueIdStack());
|
1099 kumpf 1.1
|
1100 kumpf 1.38 return message;
|
1101 kumpf 1.1 }
1102
1103 //
1104 // _deserializeCIMDeleteInstanceRequestMessage
1105 //
1106 CIMDeleteInstanceRequestMessage*
1107 CIMMessageDeserializer::_deserializeCIMDeleteInstanceRequestMessage(
1108 XmlParser& parser)
1109 {
1110 CIMObjectPath instanceName;
1111
1112 _deserializeCIMObjectPath(parser, instanceName);
1113
1114 CIMDeleteInstanceRequestMessage* message =
1115 new CIMDeleteInstanceRequestMessage(
1116 String::EMPTY, // messageId
1117 CIMNamespaceName(), // nameSpace
1118 instanceName,
|
1119 kumpf 1.35 QueueIdStack());
|
1120 kumpf 1.1
|
1121 kumpf 1.38 return message;
|
1122 kumpf 1.1 }
1123
1124 //
1125 // _deserializeCIMCreateInstanceRequestMessage
1126 //
1127 CIMCreateInstanceRequestMessage*
1128 CIMMessageDeserializer::_deserializeCIMCreateInstanceRequestMessage(
1129 XmlParser& parser)
1130 {
1131 CIMInstance newInstance;
1132
1133 _deserializeCIMInstance(parser, newInstance);
1134
1135 CIMCreateInstanceRequestMessage* message =
1136 new CIMCreateInstanceRequestMessage(
1137 String::EMPTY, // messageId
1138 CIMNamespaceName(), // nameSpace
1139 newInstance,
|
1140 kumpf 1.35 QueueIdStack());
|
1141 kumpf 1.1
|
1142 kumpf 1.38 return message;
|
1143 kumpf 1.1 }
1144
1145 //
1146 // _deserializeCIMModifyInstanceRequestMessage
1147 //
1148 CIMModifyInstanceRequestMessage*
1149 CIMMessageDeserializer::_deserializeCIMModifyInstanceRequestMessage(
1150 XmlParser& parser)
1151 {
1152 CIMValue genericValue;
1153 CIMInstance modifiedInstance;
1154 Boolean includeQualifiers;
1155 CIMPropertyList propertyList;
1156
1157 _deserializeCIMInstance(parser, modifiedInstance);
1158
1159 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1160 genericValue.get(includeQualifiers);
1161
1162 _deserializeCIMPropertyList(parser, propertyList);
1163
1164 kumpf 1.1 CIMModifyInstanceRequestMessage* message =
1165 new CIMModifyInstanceRequestMessage(
1166 String::EMPTY, // messageId
1167 CIMNamespaceName(), // nameSpace
1168 modifiedInstance,
1169 includeQualifiers,
1170 propertyList,
|
1171 kumpf 1.35 QueueIdStack());
|
1172 kumpf 1.1
|
1173 kumpf 1.38 return message;
|
1174 kumpf 1.1 }
1175
1176 //
1177 // _deserializeCIMEnumerateInstancesRequestMessage
1178 //
1179 CIMEnumerateInstancesRequestMessage*
1180 CIMMessageDeserializer::_deserializeCIMEnumerateInstancesRequestMessage(
1181 XmlParser& parser)
1182 {
1183 CIMValue genericValue;
1184 CIMObjectPath instanceName;
1185 Boolean deepInheritance;
1186 Boolean localOnly;
1187 Boolean includeQualifiers;
1188 Boolean includeClassOrigin;
1189 CIMPropertyList propertyList;
1190
1191 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1192 genericValue.get(deepInheritance);
1193
1194 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1195 kumpf 1.1 genericValue.get(localOnly);
1196
1197 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1198 genericValue.get(includeQualifiers);
1199
1200 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1201 genericValue.get(includeClassOrigin);
1202
1203 _deserializeCIMPropertyList(parser, propertyList);
1204
1205 CIMEnumerateInstancesRequestMessage* message =
1206 new CIMEnumerateInstancesRequestMessage(
1207 String::EMPTY, // messageId
1208 CIMNamespaceName(), // nameSpace
1209 CIMName(), // className
1210 deepInheritance,
1211 localOnly,
1212 includeQualifiers,
1213 includeClassOrigin,
1214 propertyList,
|
1215 kumpf 1.35 QueueIdStack());
|
1216 kumpf 1.1
|
1217 kumpf 1.38 return message;
|
1218 kumpf 1.1 }
1219
1220 //
1221 // _deserializeCIMEnumerateInstanceNamesRequestMessage
1222 //
1223 CIMEnumerateInstanceNamesRequestMessage*
1224 CIMMessageDeserializer::_deserializeCIMEnumerateInstanceNamesRequestMessage(
1225 XmlParser& parser)
1226 {
1227 CIMEnumerateInstanceNamesRequestMessage* message =
1228 new CIMEnumerateInstanceNamesRequestMessage(
1229 String::EMPTY, // messageId
1230 CIMNamespaceName(), // nameSpace
1231 CIMName(), // className
|
1232 kumpf 1.35 QueueIdStack());
|
1233 kumpf 1.1
|
1234 kumpf 1.38 return message;
|
1235 kumpf 1.1 }
1236
1237 //
1238 // _deserializeCIMExecQueryRequestMessage
1239 //
1240 CIMExecQueryRequestMessage*
1241 CIMMessageDeserializer::_deserializeCIMExecQueryRequestMessage(
1242 XmlParser& parser)
1243 {
1244 CIMValue genericValue;
1245 String queryLanguage;
1246 String query;
1247
1248 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1249 genericValue.get(queryLanguage);
1250
1251 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1252 genericValue.get(query);
1253
1254 CIMExecQueryRequestMessage* message =
1255 new CIMExecQueryRequestMessage(
1256 kumpf 1.1 String::EMPTY, // messageId
1257 CIMNamespaceName(), // nameSpace
1258 queryLanguage,
1259 query,
|
1260 kumpf 1.35 QueueIdStack());
|
1261 kumpf 1.1
|
1262 kumpf 1.38 return message;
|
1263 kumpf 1.1 }
1264
1265 //
1266 // _deserializeCIMAssociatorsRequestMessage
1267 //
1268 CIMAssociatorsRequestMessage*
1269 CIMMessageDeserializer::_deserializeCIMAssociatorsRequestMessage(
1270 XmlParser& parser)
1271 {
1272 CIMValue genericValue;
1273 CIMObjectPath objectName;
1274 CIMName assocClass;
1275 CIMName resultClass;
1276 String role;
1277 String resultRole;
1278 Boolean includeQualifiers;
1279 Boolean includeClassOrigin;
1280 CIMPropertyList propertyList;
1281
1282 _deserializeCIMObjectPath(parser, objectName);
1283 _deserializeCIMName(parser, assocClass);
1284 kumpf 1.1 _deserializeCIMName(parser, resultClass);
1285
1286 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1287 genericValue.get(role);
1288
1289 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1290 genericValue.get(resultRole);
1291
1292 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1293 genericValue.get(includeQualifiers);
1294
1295 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1296 genericValue.get(includeClassOrigin);
1297
1298 _deserializeCIMPropertyList(parser, propertyList);
1299
1300 CIMAssociatorsRequestMessage* message =
1301 new CIMAssociatorsRequestMessage(
1302 String::EMPTY, // messageId
1303 CIMNamespaceName(), // nameSpace
1304 objectName,
1305 kumpf 1.1 assocClass,
1306 resultClass,
1307 role,
1308 resultRole,
1309 includeQualifiers,
1310 includeClassOrigin,
1311 propertyList,
|
1312 kumpf 1.35 QueueIdStack());
|
1313 kumpf 1.1
|
1314 kumpf 1.38 return message;
|
1315 kumpf 1.1 }
1316
1317 //
1318 // _deserializeCIMAssociatorNamesRequestMessage
1319 //
1320 CIMAssociatorNamesRequestMessage*
1321 CIMMessageDeserializer::_deserializeCIMAssociatorNamesRequestMessage(
1322 XmlParser& parser)
1323 {
1324 CIMValue genericValue;
1325 CIMObjectPath objectName;
1326 CIMName assocClass;
1327 CIMName resultClass;
1328 String role;
1329 String resultRole;
1330
1331 _deserializeCIMObjectPath(parser, objectName);
1332 _deserializeCIMName(parser, assocClass);
1333 _deserializeCIMName(parser, resultClass);
1334
1335 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1336 kumpf 1.1 genericValue.get(role);
1337
1338 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1339 genericValue.get(resultRole);
1340
1341 CIMAssociatorNamesRequestMessage* message =
1342 new CIMAssociatorNamesRequestMessage(
1343 String::EMPTY, // messageId
1344 CIMNamespaceName(), // nameSpace
1345 objectName,
1346 assocClass,
1347 resultClass,
1348 role,
1349 resultRole,
|
1350 kumpf 1.35 QueueIdStack());
|
1351 kumpf 1.1
|
1352 kumpf 1.38 return message;
|
1353 kumpf 1.1 }
1354
1355 //
1356 // _deserializeCIMReferencesRequestMessage
1357 //
1358 CIMReferencesRequestMessage*
1359 CIMMessageDeserializer::_deserializeCIMReferencesRequestMessage(
1360 XmlParser& parser)
1361 {
1362 CIMValue genericValue;
1363 CIMObjectPath objectName;
1364 CIMName resultClass;
1365 String role;
1366 Boolean includeQualifiers;
1367 Boolean includeClassOrigin;
1368 CIMPropertyList propertyList;
1369
1370 _deserializeCIMObjectPath(parser, objectName);
1371 _deserializeCIMName(parser, resultClass);
1372
1373 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1374 kumpf 1.1 genericValue.get(role);
1375
1376 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1377 genericValue.get(includeQualifiers);
1378
1379 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1380 genericValue.get(includeClassOrigin);
1381
1382 _deserializeCIMPropertyList(parser, propertyList);
1383
1384 CIMReferencesRequestMessage* message =
1385 new CIMReferencesRequestMessage(
1386 String::EMPTY, // messageId
1387 CIMNamespaceName(), // nameSpace
1388 objectName,
1389 resultClass,
1390 role,
1391 includeQualifiers,
1392 includeClassOrigin,
1393 propertyList,
|
1394 kumpf 1.35 QueueIdStack());
|
1395 kumpf 1.1
|
1396 kumpf 1.38 return message;
|
1397 kumpf 1.1 }
1398
1399 //
1400 // _deserializeCIMReferenceNamesRequestMessage
1401 //
1402 CIMReferenceNamesRequestMessage*
1403 CIMMessageDeserializer::_deserializeCIMReferenceNamesRequestMessage(
1404 XmlParser& parser)
1405 {
1406 CIMValue genericValue;
1407 CIMObjectPath objectName;
1408 CIMName resultClass;
1409 String role;
1410
1411 _deserializeCIMObjectPath(parser, objectName);
1412 _deserializeCIMName(parser, resultClass);
1413
1414 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1415 genericValue.get(role);
1416
1417 CIMReferenceNamesRequestMessage* message =
1418 kumpf 1.1 new CIMReferenceNamesRequestMessage(
1419 String::EMPTY, // messageId
1420 CIMNamespaceName(), // nameSpace
1421 objectName,
1422 resultClass,
1423 role,
|
1424 kumpf 1.35 QueueIdStack());
|
1425 kumpf 1.1
|
1426 kumpf 1.38 return message;
|
1427 kumpf 1.1 }
1428
1429 //
1430 // _deserializeCIMGetPropertyRequestMessage
1431 //
1432 CIMGetPropertyRequestMessage*
1433 CIMMessageDeserializer::_deserializeCIMGetPropertyRequestMessage(
1434 XmlParser& parser)
1435 {
1436 CIMObjectPath instanceName;
1437 CIMName propertyName;
1438
1439 _deserializeCIMObjectPath(parser, instanceName);
1440 _deserializeCIMName(parser, propertyName);
1441
1442 CIMGetPropertyRequestMessage* message =
1443 new CIMGetPropertyRequestMessage(
1444 String::EMPTY, // messageId
1445 CIMNamespaceName(), // nameSpace
1446 instanceName,
1447 propertyName,
|
1448 kumpf 1.35 QueueIdStack());
|
1449 kumpf 1.1
|
1450 kumpf 1.38 return message;
|
1451 kumpf 1.1 }
1452
1453 //
1454 // _deserializeCIMSetPropertyRequestMessage
1455 //
1456 CIMSetPropertyRequestMessage*
1457 CIMMessageDeserializer::_deserializeCIMSetPropertyRequestMessage(
1458 XmlParser& parser)
1459 {
1460 CIMObjectPath instanceName;
1461 CIMParamValue newValue;
1462
1463 _deserializeCIMObjectPath(parser, instanceName);
1464
|
1465 kumpf 1.40 _deserializeCIMParamValue(parser, newValue);
|
1466 kumpf 1.1
1467 CIMSetPropertyRequestMessage* message =
1468 new CIMSetPropertyRequestMessage(
1469 String::EMPTY, // messageId
1470 CIMNamespaceName(), // nameSpace
1471 instanceName,
1472 newValue.getParameterName(),
1473 newValue.getValue(),
|
1474 kumpf 1.35 QueueIdStack());
|
1475 kumpf 1.1
|
1476 kumpf 1.38 return message;
|
1477 kumpf 1.1 }
1478
1479 //
1480 // _deserializeCIMInvokeMethodRequestMessage
1481 //
1482 CIMInvokeMethodRequestMessage*
1483 CIMMessageDeserializer::_deserializeCIMInvokeMethodRequestMessage(
1484 XmlParser& parser)
1485 {
1486 XmlEntry entry;
1487 CIMParamValue genericParamValue;
1488 CIMObjectPath instanceName;
1489 CIMName methodName;
1490 Array<CIMParamValue> inParameters;
1491
1492 _deserializeCIMObjectPath(parser, instanceName);
1493 _deserializeCIMName(parser, methodName);
1494
1495 // Get inParameter array
1496 XmlReader::expectStartTag(parser, entry, "PGPARAMS");
|
1497 kumpf 1.40 while (_deserializeCIMParamValue(parser, genericParamValue))
|
1498 kumpf 1.1 {
1499 inParameters.append(genericParamValue);
1500 }
1501 XmlReader::expectEndTag(parser, "PGPARAMS");
1502
1503 CIMInvokeMethodRequestMessage* message =
1504 new CIMInvokeMethodRequestMessage(
1505 String::EMPTY, // messageId
1506 CIMNamespaceName(), // nameSpace
1507 instanceName,
1508 methodName,
1509 inParameters,
|
1510 kumpf 1.35 QueueIdStack());
|
1511 kumpf 1.1
|
1512 kumpf 1.38 return message;
|
1513 kumpf 1.1 }
1514
1515
1516 //
1517 //
1518 // CIMIndicationRequestMessages
1519 //
1520 //
1521
1522 //
1523 // _deserializeCIMCreateSubscriptionRequestMessage
1524 //
1525 CIMCreateSubscriptionRequestMessage*
1526 CIMMessageDeserializer::_deserializeCIMCreateSubscriptionRequestMessage(
1527 XmlParser& parser)
1528 {
1529 XmlEntry entry;
1530 CIMValue genericValue;
1531 CIMName genericName;
1532 CIMNamespaceName nameSpace;
1533 CIMInstance subscriptionInstance;
1534 kumpf 1.1 Array<CIMName> classNames;
1535 CIMPropertyList propertyList;
1536 Uint16 repeatNotificationPolicy;
|
1537 kumpf 1.3 String query;
|
1538 kumpf 1.1
1539 _deserializeCIMNamespaceName(parser, nameSpace);
1540 _deserializeCIMInstance(parser, subscriptionInstance);
1541
1542 // Get classNames array
1543 XmlReader::expectStartTag(parser, entry, "PGNAMEARRAY");
1544 while (_deserializeCIMName(parser, genericName))
1545 {
1546 classNames.append(genericName);
1547 }
1548 XmlReader::expectEndTag(parser, "PGNAMEARRAY");
1549
1550 _deserializeCIMPropertyList(parser, propertyList);
1551
1552 // Decode repeatNotificationPolicy
1553 XmlReader::getValueElement(parser, CIMTYPE_UINT16, genericValue);
1554 genericValue.get(repeatNotificationPolicy);
1555
1556 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
|
1557 kumpf 1.3 genericValue.get(query);
1558
|
1559 kumpf 1.1 CIMCreateSubscriptionRequestMessage* message =
1560 new CIMCreateSubscriptionRequestMessage(
1561 String::EMPTY, // messageId
1562 nameSpace,
1563 subscriptionInstance,
1564 classNames,
1565 propertyList,
1566 repeatNotificationPolicy,
|
1567 kumpf 1.3 query,
|
1568 kumpf 1.35 QueueIdStack());
|
1569 kumpf 1.1
|
1570 kumpf 1.38 return message;
|
1571 kumpf 1.1 }
1572
1573 //
1574 // _deserializeCIMModifySubscriptionRequestMessage
1575 //
1576 CIMModifySubscriptionRequestMessage*
1577 CIMMessageDeserializer::_deserializeCIMModifySubscriptionRequestMessage(
1578 XmlParser& parser)
1579 {
1580 XmlEntry entry;
1581 CIMValue genericValue;
1582 CIMName genericName;
1583 CIMNamespaceName nameSpace;
1584 CIMInstance subscriptionInstance;
1585 Array<CIMName> classNames;
1586 CIMPropertyList propertyList;
1587 Uint16 repeatNotificationPolicy;
|
1588 kumpf 1.3 String query;
|
1589 kumpf 1.1
1590 _deserializeCIMNamespaceName(parser, nameSpace);
1591 _deserializeCIMInstance(parser, subscriptionInstance);
1592
1593 // Get classNames array
1594 XmlReader::expectStartTag(parser, entry, "PGNAMEARRAY");
1595 while (_deserializeCIMName(parser, genericName))
1596 {
1597 classNames.append(genericName);
1598 }
1599 XmlReader::expectEndTag(parser, "PGNAMEARRAY");
1600
1601 _deserializeCIMPropertyList(parser, propertyList);
1602
1603 // Decode repeatNotificationPolicy
1604 XmlReader::getValueElement(parser, CIMTYPE_UINT16, genericValue);
1605 genericValue.get(repeatNotificationPolicy);
1606
1607 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
|
1608 kumpf 1.3 genericValue.get(query);
1609
|
1610 kumpf 1.1 CIMModifySubscriptionRequestMessage* message =
1611 new CIMModifySubscriptionRequestMessage(
1612 String::EMPTY, // messageId
1613 nameSpace,
1614 subscriptionInstance,
1615 classNames,
1616 propertyList,
1617 repeatNotificationPolicy,
|
1618 kumpf 1.3 query,
|
1619 kumpf 1.35 QueueIdStack());
|
1620 kumpf 1.1
|
1621 kumpf 1.38 return message;
|
1622 kumpf 1.1 }
1623
1624 //
1625 // _deserializeCIMDeleteSubscriptionRequestMessage
1626 //
1627 CIMDeleteSubscriptionRequestMessage*
1628 CIMMessageDeserializer::_deserializeCIMDeleteSubscriptionRequestMessage(
1629 XmlParser& parser)
1630 {
1631 XmlEntry entry;
1632 CIMName genericName;
1633 CIMNamespaceName nameSpace;
1634 CIMInstance subscriptionInstance;
1635 Array<CIMName> classNames;
1636
1637 _deserializeCIMNamespaceName(parser, nameSpace);
1638 _deserializeCIMInstance(parser, subscriptionInstance);
1639
1640 // Get classNames array
1641 XmlReader::expectStartTag(parser, entry, "PGNAMEARRAY");
1642 while (_deserializeCIMName(parser, genericName))
1643 kumpf 1.1 {
1644 classNames.append(genericName);
1645 }
1646 XmlReader::expectEndTag(parser, "PGNAMEARRAY");
1647
1648 CIMDeleteSubscriptionRequestMessage* message =
1649 new CIMDeleteSubscriptionRequestMessage(
1650 String::EMPTY, // messageId
1651 nameSpace,
1652 subscriptionInstance,
1653 classNames,
|
1654 kumpf 1.35 QueueIdStack());
|
1655 kumpf 1.1
|
1656 kumpf 1.38 return message;
|
1657 kumpf 1.1 }
1658
1659
1660 //
1661 //
1662 // Other CIMRequestMessages
1663 //
1664 //
1665
1666 //
1667 // _deserializeCIMExportIndicationRequestMessage
1668 //
1669 CIMExportIndicationRequestMessage*
1670 CIMMessageDeserializer::_deserializeCIMExportIndicationRequestMessage(
1671 XmlParser& parser)
1672 {
1673 CIMValue genericValue;
1674 String authType;
1675 String userName;
1676 String destinationPath;
1677 CIMInstance indicationInstance;
1678 kumpf 1.1
1679 _deserializeUserInfo(parser, authType, userName);
1680
1681 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1682 genericValue.get(destinationPath);
1683
1684 _deserializeCIMInstance(parser, indicationInstance);
1685
1686 CIMExportIndicationRequestMessage* message =
1687 new CIMExportIndicationRequestMessage(
1688 String::EMPTY, // messageId
1689 destinationPath,
1690 indicationInstance,
1691 QueueIdStack(), // queueIds
1692 authType,
1693 userName);
1694
|
1695 kumpf 1.38 return message;
|
1696 kumpf 1.1 }
1697
1698 //
1699 // _deserializeCIMProcessIndicationRequestMessage
1700 //
1701 CIMProcessIndicationRequestMessage*
1702 CIMMessageDeserializer::_deserializeCIMProcessIndicationRequestMessage(
1703 XmlParser& parser)
1704 {
1705 XmlEntry entry;
1706 CIMObjectPath genericObjectPath;
1707 CIMNamespaceName nameSpace;
1708 CIMInstance indicationInstance;
1709 Array<CIMObjectPath> subscriptionInstanceNames;
1710 CIMInstance provider;
1711
1712 _deserializeCIMNamespaceName(parser, nameSpace);
1713 _deserializeCIMInstance(parser, indicationInstance);
1714
1715 // Get subscriptionInstanceNames array
1716 XmlReader::expectStartTag(parser, entry, "PGPATHARRAY");
1717 kumpf 1.1 while (_deserializeCIMObjectPath(parser, genericObjectPath))
1718 {
1719 subscriptionInstanceNames.append(genericObjectPath);
1720 }
1721 XmlReader::expectEndTag(parser, "PGPATHARRAY");
1722
1723 _deserializeCIMInstance(parser, provider);
1724
1725 CIMProcessIndicationRequestMessage* message =
1726 new CIMProcessIndicationRequestMessage(
1727 String::EMPTY, // messageId
1728 nameSpace,
1729 indicationInstance,
1730 subscriptionInstanceNames,
1731 provider,
1732 QueueIdStack()); // queueIds
1733
|
1734 kumpf 1.38 return message;
|
1735 kumpf 1.1 }
1736
1737 //
1738 // _deserializeCIMDisableModuleRequestMessage
1739 //
1740 CIMDisableModuleRequestMessage*
1741 CIMMessageDeserializer::_deserializeCIMDisableModuleRequestMessage(
1742 XmlParser& parser)
1743 {
1744 XmlEntry entry;
1745 CIMValue genericValue;
1746 CIMInstance genericInstance;
1747 Boolean genericBoolean;
1748 String authType;
1749 String userName;
1750 CIMInstance providerModule;
1751 Array<CIMInstance> providers;
1752 Boolean disableProviderOnly;
1753 Array<Boolean> indicationProviders;
1754
1755 _deserializeUserInfo(parser, authType, userName);
1756 kumpf 1.1
1757 _deserializeCIMInstance(parser, providerModule);
1758
1759 // Get providers array
1760 XmlReader::expectStartTag(parser, entry, "PGINSTARRAY");
1761 while (_deserializeCIMInstance(parser, genericInstance))
1762 {
1763 providers.append(genericInstance);
1764 }
1765 XmlReader::expectEndTag(parser, "PGINSTARRAY");
1766
1767 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1768 genericValue.get(disableProviderOnly);
1769
1770 // Get indicationProviders array
1771 XmlReader::expectStartTag(parser, entry, "PGBOOLARRAY");
1772 while (XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue))
1773 {
1774 genericValue.get(genericBoolean);
1775 indicationProviders.append(genericBoolean);
1776 }
1777 kumpf 1.1 XmlReader::expectEndTag(parser, "PGBOOLARRAY");
1778
1779 CIMDisableModuleRequestMessage* message =
1780 new CIMDisableModuleRequestMessage(
1781 String::EMPTY, // messageId
1782 providerModule,
1783 providers,
1784 disableProviderOnly,
1785 indicationProviders,
1786 QueueIdStack(), // queueIds
1787 authType,
1788 userName);
1789
|
1790 kumpf 1.38 return message;
|
1791 kumpf 1.1 }
1792
1793 //
1794 // _deserializeCIMEnableModuleRequestMessage
1795 //
1796 CIMEnableModuleRequestMessage*
1797 CIMMessageDeserializer::_deserializeCIMEnableModuleRequestMessage(
1798 XmlParser& parser)
1799 {
1800 String authType;
1801 String userName;
1802 CIMInstance providerModule;
1803
1804 _deserializeUserInfo(parser, authType, userName);
1805
1806 _deserializeCIMInstance(parser, providerModule);
1807
1808 CIMEnableModuleRequestMessage* message =
1809 new CIMEnableModuleRequestMessage(
1810 String::EMPTY, // messageId
1811 providerModule,
1812 kumpf 1.1 QueueIdStack(), // queueIds
1813 authType,
1814 userName);
1815
|
1816 kumpf 1.38 return message;
|
1817 kumpf 1.1 }
1818
1819 //
1820 // _deserializeCIMStopAllProvidersRequestMessage
1821 //
1822 CIMStopAllProvidersRequestMessage*
1823 CIMMessageDeserializer::_deserializeCIMStopAllProvidersRequestMessage(
1824 XmlParser& parser)
1825 {
1826 CIMStopAllProvidersRequestMessage* message =
1827 new CIMStopAllProvidersRequestMessage(
1828 String::EMPTY, // messageId
1829 QueueIdStack()); // queueIds
1830
|
1831 kumpf 1.38 return message;
|
1832 kumpf 1.1 }
1833
|
1834 kumpf 1.2 //
|
1835 kumpf 1.7 // _deserializeCIMInitializeProviderAgentRequestMessage
1836 //
1837 CIMInitializeProviderAgentRequestMessage*
1838 CIMMessageDeserializer::_deserializeCIMInitializeProviderAgentRequestMessage(
1839 XmlParser& parser)
1840 {
1841 XmlEntry entry;
1842 CIMValue genericValue;
1843 String pegasusHome;
1844 Array<Pair<String, String> > configProperties;
1845 Boolean bindVerbose;
|
1846 carolann.graves 1.22 Boolean subscriptionInitComplete;
|
1847 kumpf 1.7
1848 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1849 genericValue.get(pegasusHome);
1850
1851 // Get configProperties array
1852 XmlReader::expectStartTag(parser, entry, "PGCONFARRAY");
1853 while (XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue))
1854 {
1855 String propertyName;
1856 String propertyValue;
1857
1858 genericValue.get(propertyName);
1859
1860 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1861 genericValue.get(propertyValue);
1862
1863 configProperties.append(
1864 Pair<String, String>(propertyName, propertyValue));
1865 }
1866 XmlReader::expectEndTag(parser, "PGCONFARRAY");
1867
1868 kumpf 1.7 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1869 genericValue.get(bindVerbose);
1870
|
1871 carolann.graves 1.22 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1872 genericValue.get(subscriptionInitComplete);
1873
|
1874 kumpf 1.7 CIMInitializeProviderAgentRequestMessage* message =
1875 new CIMInitializeProviderAgentRequestMessage(
1876 String::EMPTY, // messageId
1877 pegasusHome,
1878 configProperties,
1879 bindVerbose,
|
1880 carolann.graves 1.22 subscriptionInitComplete,
|
1881 kumpf 1.7 QueueIdStack()); // queueIds
1882
|
1883 kumpf 1.38 return message;
|
1884 kumpf 1.7 }
1885
|
1886 kumpf 1.8 //
1887 // _deserializeCIMNotifyConfigChangeRequestMessage
1888 //
1889 CIMNotifyConfigChangeRequestMessage*
1890 CIMMessageDeserializer::_deserializeCIMNotifyConfigChangeRequestMessage(
1891 XmlParser& parser)
1892 {
1893 CIMValue genericValue;
1894 String propertyName;
1895 String newPropertyValue;
1896 Boolean currentValueModified;
1897
1898 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1899 genericValue.get(propertyName);
1900
1901 XmlReader::getValueElement(parser, CIMTYPE_STRING, genericValue);
1902 genericValue.get(newPropertyValue);
1903
1904 XmlReader::getValueElement(parser, CIMTYPE_BOOLEAN, genericValue);
1905 genericValue.get(currentValueModified);
1906
1907 kumpf 1.8 CIMNotifyConfigChangeRequestMessage* message =
1908 new CIMNotifyConfigChangeRequestMessage(
1909 String::EMPTY, // messageId
1910 propertyName,
1911 newPropertyValue,
1912 currentValueModified,
1913 QueueIdStack()); // queueIds
1914
|
1915 kumpf 1.38 return message;
|
1916 kumpf 1.8 }
|
1917 kumpf 1.1
1918 //
|
1919 carolann.graves 1.22 // _deserializeCIMSubscriptionInitCompleteRequestMessage
1920 //
1921 CIMSubscriptionInitCompleteRequestMessage*
1922 CIMMessageDeserializer::_deserializeCIMSubscriptionInitCompleteRequestMessage(
1923 XmlParser& parser)
1924 {
1925 CIMSubscriptionInitCompleteRequestMessage* message =
1926 new CIMSubscriptionInitCompleteRequestMessage(
1927 String::EMPTY, // messageId
1928 QueueIdStack()); // queueIds
1929
|
1930 kumpf 1.38 return message;
|
1931 carolann.graves 1.22 }
1932
1933 //
|
1934 kumpf 1.1 //
1935 // Response Messages
1936 //
1937 //
1938
1939 //
1940 //
1941 // CIM Operation Response Messages
1942 //
1943 //
1944
1945 //
1946 // _deserializeCIMGetInstanceResponseMessage
1947 //
1948 CIMGetInstanceResponseMessage*
1949 CIMMessageDeserializer::_deserializeCIMGetInstanceResponseMessage(
1950 XmlParser& parser)
1951 {
1952 CIMInstance cimInstance;
1953
1954 _deserializeCIMInstance(parser, cimInstance);
1955 kumpf 1.1
1956 CIMGetInstanceResponseMessage* message =
1957 new CIMGetInstanceResponseMessage(
1958 String::EMPTY, // messageId
1959 CIMException(), // cimException
1960 QueueIdStack(), // queueIds
1961 cimInstance);
1962
|
1963 kumpf 1.38 return message;
|
1964 kumpf 1.1 }
1965
1966 //
1967 // _deserializeCIMDeleteInstanceResponseMessage
1968 //
1969 CIMDeleteInstanceResponseMessage*
1970 CIMMessageDeserializer::_deserializeCIMDeleteInstanceResponseMessage(
1971 XmlParser& parser)
1972 {
1973 CIMDeleteInstanceResponseMessage* message =
1974 new CIMDeleteInstanceResponseMessage(
1975 String::EMPTY, // messageId
1976 CIMException(), // cimException
1977 QueueIdStack()); // queueIds
1978
|
1979 kumpf 1.38 return message;
|
1980 kumpf 1.1 }
1981
1982 //
1983 // _deserializeCIMCreateInstanceResponseMessage
1984 //
1985 CIMCreateInstanceResponseMessage*
1986 CIMMessageDeserializer::_deserializeCIMCreateInstanceResponseMessage(
1987 XmlParser& parser)
1988 {
1989 CIMObjectPath instanceName;
1990
1991 _deserializeCIMObjectPath(parser, instanceName);
1992
1993 CIMCreateInstanceResponseMessage* message =
1994 new CIMCreateInstanceResponseMessage(
1995 String::EMPTY, // messageId
1996 CIMException(), // cimException
1997 QueueIdStack(), // queueIds
1998 instanceName);
1999
|
2000 kumpf 1.38 return message;
|
2001 kumpf 1.1 }
2002
2003 //
2004 // _deserializeCIMModifyInstanceResponseMessage
2005 //
2006 CIMModifyInstanceResponseMessage*
2007 CIMMessageDeserializer::_deserializeCIMModifyInstanceResponseMessage(
2008 XmlParser& parser)
2009 {
2010 CIMModifyInstanceResponseMessage* message =
2011 new CIMModifyInstanceResponseMessage(
2012 String::EMPTY, // messageId
2013 CIMException(), // cimException
2014 QueueIdStack()); // queueIds
2015
|
2016 kumpf 1.38 return message;
|
2017 kumpf 1.1 }
2018
2019 //
2020 // _deserializeCIMEnumerateInstancesResponseMessage
2021 //
2022 CIMEnumerateInstancesResponseMessage*
2023 CIMMessageDeserializer::_deserializeCIMEnumerateInstancesResponseMessage(
2024 XmlParser& parser)
2025 {
2026 XmlEntry entry;
2027 CIMInstance genericInstance;
2028 Array<CIMInstance> cimNamedInstances;
2029
2030 // Get cimNamedInstances array
2031 XmlReader::expectStartTag(parser, entry, "PGINSTARRAY");
2032 while (_deserializeCIMInstance(parser, genericInstance))
2033 {
2034 cimNamedInstances.append(genericInstance);
2035 }
2036 XmlReader::expectEndTag(parser, "PGINSTARRAY");
2037
2038 kumpf 1.1 CIMEnumerateInstancesResponseMessage* message =
2039 new CIMEnumerateInstancesResponseMessage(
2040 String::EMPTY, // messageId
2041 CIMException(), // cimException
2042 QueueIdStack(), // queueIds
2043 cimNamedInstances);
2044
|
2045 kumpf 1.38 return message;
|
2046 kumpf 1.1 }
2047
2048 //
2049 // _deserializeCIMEnumerateInstanceNamesResponseMessage
2050 //
2051 CIMEnumerateInstanceNamesResponseMessage*
2052 CIMMessageDeserializer::_deserializeCIMEnumerateInstanceNamesResponseMessage(
2053 XmlParser& parser)
2054 {
2055 XmlEntry entry;
2056 CIMObjectPath genericObjectPath;
2057 Array<CIMObjectPath> instanceNames;
2058
2059 // Get instanceNames array
2060 XmlReader::expectStartTag(parser, entry, "PGPATHARRAY");
2061 while (_deserializeCIMObjectPath(parser, genericObjectPath))
2062 {
2063 instanceNames.append(genericObjectPath);
2064 }
2065 XmlReader::expectEndTag(parser, "PGPATHARRAY");
2066
2067 kumpf 1.1 CIMEnumerateInstanceNamesResponseMessage* message =
2068 new CIMEnumerateInstanceNamesResponseMessage(
2069 String::EMPTY, // messageId
2070 CIMException(), // cimException
2071 QueueIdStack(), // queueIds
2072 instanceNames);
2073
|
2074 kumpf 1.38 return message;
|
2075 kumpf 1.1 }
2076
2077 //
2078 // _deserializeCIMExecQueryResponseMessage
2079 //
2080 CIMExecQueryResponseMessage*
2081 CIMMessageDeserializer::_deserializeCIMExecQueryResponseMessage(
2082 XmlParser& parser)
2083 {
2084 XmlEntry entry;
2085 CIMObject genericObject;
2086 Array<CIMObject> cimObjects;
2087
2088 // Get cimObjects array
2089 XmlReader::expectStartTag(parser, entry, "PGOBJARRAY");
|
2090 jenny.yu 1.20 while (_deserializeCIMObject(parser, genericObject))
|
2091 kumpf 1.1 {
2092 cimObjects.append(genericObject);
2093 }
2094 XmlReader::expectEndTag(parser, "PGOBJARRAY");
2095
2096 CIMExecQueryResponseMessage* message =
2097 new CIMExecQueryResponseMessage(
2098 String::EMPTY, // messageId
2099 CIMException(), // cimException
2100 QueueIdStack(), // queueIds
2101 cimObjects);
2102
|
2103 kumpf 1.38 return message;
|
2104 kumpf 1.1 }
2105
2106 //
2107 // _deserializeCIMAssociatorsResponseMessage
2108 //
2109 CIMAssociatorsResponseMessage*
2110 CIMMessageDeserializer::_deserializeCIMAssociatorsResponseMessage(
2111 XmlParser& parser)
2112 {
2113 XmlEntry entry;
2114 CIMObject genericObject;
2115 Array<CIMObject> cimObjects;
2116
2117 // Get cimObjects array
2118 XmlReader::expectStartTag(parser, entry, "PGOBJARRAY");
|
2119 jenny.yu 1.20 while (_deserializeCIMObject(parser, genericObject))
|
2120 kumpf 1.1 {
2121 cimObjects.append(genericObject);
2122 }
2123 XmlReader::expectEndTag(parser, "PGOBJARRAY");
2124
2125 CIMAssociatorsResponseMessage* message =
2126 new CIMAssociatorsResponseMessage(
2127 String::EMPTY, // messageId
2128 CIMException(), // cimException
2129 QueueIdStack(), // queueIds
2130 cimObjects);
2131
|
2132 kumpf 1.38 return message;
|
2133 kumpf 1.1 }
2134
2135 //
2136 // _deserializeCIMAssociatorNamesResponseMessage
2137 //
2138 CIMAssociatorNamesResponseMessage*
2139 CIMMessageDeserializer::_deserializeCIMAssociatorNamesResponseMessage(
2140 XmlParser& parser)
2141 {
2142 XmlEntry entry;
2143 CIMObjectPath genericObjectPath;
2144 Array<CIMObjectPath> objectNames;
2145
2146 // Get objectNames array
2147 XmlReader::expectStartTag(parser, entry, "PGPATHARRAY");
2148 while (_deserializeCIMObjectPath(parser, genericObjectPath))
2149 {
2150 objectNames.append(genericObjectPath);
2151 }
2152 XmlReader::expectEndTag(parser, "PGPATHARRAY");
2153
2154 kumpf 1.1 CIMAssociatorNamesResponseMessage* message =
2155 new CIMAssociatorNamesResponseMessage(
2156 String::EMPTY, // messageId
2157 CIMException(), // cimException
2158 QueueIdStack(), // queueIds
2159 objectNames);
2160
|
2161 kumpf 1.38 return message;
|
2162 kumpf 1.1 }
2163
2164 //
2165 // _deserializeCIMReferencesResponseMessage
2166 //
2167 CIMReferencesResponseMessage*
2168 CIMMessageDeserializer::_deserializeCIMReferencesResponseMessage(
2169 XmlParser& parser)
2170 {
2171 XmlEntry entry;
2172 CIMObject genericObject;
2173 Array<CIMObject> cimObjects;
2174
2175 // Get cimObjects array
2176 XmlReader::expectStartTag(parser, entry, "PGOBJARRAY");
|
2177 jenny.yu 1.20 while (_deserializeCIMObject(parser, genericObject))
|
2178 kumpf 1.1 {
2179 cimObjects.append(genericObject);
2180 }
2181 XmlReader::expectEndTag(parser, "PGOBJARRAY");
2182
2183 CIMReferencesResponseMessage* message =
2184 new CIMReferencesResponseMessage(
2185 String::EMPTY, // messageId
2186 CIMException(), // cimException
2187 QueueIdStack(), // queueIds
2188 cimObjects);
2189
|
2190 kumpf 1.38 return message;
|
2191 kumpf 1.1 }
2192
2193 //
2194 // _deserializeCIMReferenceNamesResponseMessage
2195 //
2196 CIMReferenceNamesResponseMessage*
2197 CIMMessageDeserializer::_deserializeCIMReferenceNamesResponseMessage(
2198 XmlParser& parser)
2199 {
2200 XmlEntry entry;
2201 CIMObjectPath genericObjectPath;
2202 Array<CIMObjectPath> objectNames;
2203
2204 // Get objectNames array
2205 XmlReader::expectStartTag(parser, entry, "PGPATHARRAY");
2206 while (_deserializeCIMObjectPath(parser, genericObjectPath))
2207 {
2208 objectNames.append(genericObjectPath);
2209 }
2210 XmlReader::expectEndTag(parser, "PGPATHARRAY");
2211
2212 kumpf 1.1 CIMReferenceNamesResponseMessage* message =
2213 new CIMReferenceNamesResponseMessage(
2214 String::EMPTY, // messageId
2215 CIMException(), // cimException
2216 QueueIdStack(), // queueIds
2217 objectNames);
2218
|
2219 kumpf 1.38 return message;
|
2220 kumpf 1.1 }
2221
2222 //
2223 // _deserializeCIMGetPropertyResponseMessage
2224 //
2225 CIMGetPropertyResponseMessage*
2226 CIMMessageDeserializer::_deserializeCIMGetPropertyResponseMessage(
2227 XmlParser& parser)
2228 {
2229 CIMParamValue value;
2230
|
2231 kumpf 1.40 _deserializeCIMParamValue(parser, value);
|
2232 kumpf 1.1
2233 CIMGetPropertyResponseMessage* message =
2234 new CIMGetPropertyResponseMessage(
2235 String::EMPTY, // messageId
2236 CIMException(), // cimException
2237 QueueIdStack(), // queueIds
2238 value.getValue());
2239
|
2240 kumpf 1.38 return message;
|
2241 kumpf 1.1 }
2242
2243 //
2244 // _deserializeCIMSetPropertyResponseMessage
2245 //
2246 CIMSetPropertyResponseMessage*
2247 CIMMessageDeserializer::_deserializeCIMSetPropertyResponseMessage(
2248 XmlParser& parser)
2249 {
2250 CIMSetPropertyResponseMessage* message =
2251 new CIMSetPropertyResponseMessage(
2252 String::EMPTY, // messageId
2253 CIMException(), // cimException
2254 QueueIdStack()); // queueIds
2255
|
2256 kumpf 1.38 return message;
|
2257 kumpf 1.1 }
2258
2259 //
2260 // _deserializeCIMInvokeMethodResponseMessage
2261 //
2262 CIMInvokeMethodResponseMessage*
2263 CIMMessageDeserializer::_deserializeCIMInvokeMethodResponseMessage(
2264 XmlParser& parser)
2265 {
2266 XmlEntry entry;
2267 CIMParamValue genericParamValue;
2268 CIMParamValue retValue;
2269 CIMName methodName;
2270 Array<CIMParamValue> outParameters;
2271
|
2272 kumpf 1.40 _deserializeCIMParamValue(parser, retValue);
|
2273 kumpf 1.1
2274 // Get outParameter array
2275 XmlReader::expectStartTag(parser, entry, "PGPARAMS");
|
2276 kumpf 1.40 while (_deserializeCIMParamValue(parser, genericParamValue))
|
2277 kumpf 1.1 {
2278 outParameters.append(genericParamValue);
2279 }
2280 XmlReader::expectEndTag(parser, "PGPARAMS");
2281
2282 _deserializeCIMName(parser, methodName);
2283
2284 CIMInvokeMethodResponseMessage* message =
2285 new CIMInvokeMethodResponseMessage(
2286 String::EMPTY, // messageId
2287 CIMException(), // cimException
2288 QueueIdStack(), // queueIds
2289 retValue.getValue(),
2290 outParameters,
2291 methodName);
2292
|
2293 kumpf 1.38 return message;
|
2294 kumpf 1.1 }
2295
2296
2297 //
2298 //
2299 // CIM Indication Response Messages
2300 //
2301 //
2302
2303 //
2304 // _deserializeCIMCreateSubscriptionResponseMessage
2305 //
2306 CIMCreateSubscriptionResponseMessage*
2307 CIMMessageDeserializer::_deserializeCIMCreateSubscriptionResponseMessage(
2308 XmlParser& parser)
2309 {
2310 CIMCreateSubscriptionResponseMessage* message =
2311 new CIMCreateSubscriptionResponseMessage(
2312 String::EMPTY, // messageId
2313 CIMException(), // cimException
2314 QueueIdStack()); // queueIds
2315 kumpf 1.1
|
2316 kumpf 1.38 return message;
|
2317 kumpf 1.1 }
2318
2319 //
2320 // _deserializeCIMModifySubscriptionResponseMessage
2321 //
2322 CIMModifySubscriptionResponseMessage*
2323 CIMMessageDeserializer::_deserializeCIMModifySubscriptionResponseMessage(
2324 XmlParser& parser)
2325 {
2326 CIMModifySubscriptionResponseMessage* message =
2327 new CIMModifySubscriptionResponseMessage(
2328 String::EMPTY, // messageId
2329 CIMException(), // cimException
2330 QueueIdStack()); // queueIds
2331
|
2332 kumpf 1.38 return message;
|
2333 kumpf 1.1 }
2334
2335 //
2336 // _deserializeCIMDeleteSubscriptionResponseMessage
2337 //
2338 CIMDeleteSubscriptionResponseMessage*
2339 CIMMessageDeserializer::_deserializeCIMDeleteSubscriptionResponseMessage(
2340 XmlParser& parser)
2341 {
2342 CIMDeleteSubscriptionResponseMessage* message =
2343 new CIMDeleteSubscriptionResponseMessage(
2344 String::EMPTY, // messageId
2345 CIMException(), // cimException
2346 QueueIdStack()); // queueIds
2347
|
2348 kumpf 1.38 return message;
|
2349 kumpf 1.1 }
2350
2351
2352 //
2353 //
2354 // Other CIMResponseMessages
2355 //
2356 //
2357
2358 //
2359 // _deserializeCIMExportIndicationResponseMessage
2360 //
2361 CIMExportIndicationResponseMessage*
2362 CIMMessageDeserializer::_deserializeCIMExportIndicationResponseMessage(
2363 XmlParser& parser)
2364 {
2365 CIMExportIndicationResponseMessage* message =
2366 new CIMExportIndicationResponseMessage(
2367 String::EMPTY, // messageId
2368 CIMException(), // cimException
2369 QueueIdStack()); // queueIds
2370 kumpf 1.1
|
2371 kumpf 1.38 return message;
|
2372 kumpf 1.1 }
2373
2374 //
2375 // _deserializeCIMProcessIndicationResponseMessage
2376 //
2377 CIMProcessIndicationResponseMessage*
2378 CIMMessageDeserializer::_deserializeCIMProcessIndicationResponseMessage(
2379 XmlParser& parser)
2380 {
2381 CIMProcessIndicationResponseMessage* message =
2382 new CIMProcessIndicationResponseMessage(
2383 String::EMPTY, // messageId
2384 CIMException(), // cimException
2385 QueueIdStack()); // queueIds
2386
|
2387 kumpf 1.38 return message;
|
2388 kumpf 1.1 }
2389
2390 //
2391 // _deserializeCIMDisableModuleResponseMessage
2392 //
2393 CIMDisableModuleResponseMessage*
2394 CIMMessageDeserializer::_deserializeCIMDisableModuleResponseMessage(
2395 XmlParser& parser)
2396 {
2397 XmlEntry entry;
2398 CIMValue genericValue;
2399 Uint16 genericUint16;
2400 Array<Uint16> operationalStatus;
2401
2402 // Get operationalStatus array
2403 XmlReader::expectStartTag(parser, entry, "PGUINT16ARRAY");
2404 while (XmlReader::getValueElement(parser, CIMTYPE_UINT16, genericValue))
2405 {
2406 genericValue.get(genericUint16);
2407 operationalStatus.append(genericUint16);
2408 }
2409 kumpf 1.1 XmlReader::expectEndTag(parser, "PGUINT16ARRAY");
2410
2411 CIMDisableModuleResponseMessage* message =
2412 new CIMDisableModuleResponseMessage(
2413 String::EMPTY, // messageId
2414 CIMException(), // cimException
2415 QueueIdStack(), // queueIds
2416 operationalStatus);
2417
|
2418 kumpf 1.38 return message;
|
2419 kumpf 1.1 }
2420
2421 //
2422 // _deserializeCIMEnableModuleResponseMessage
2423 //
2424 CIMEnableModuleResponseMessage*
2425 CIMMessageDeserializer::_deserializeCIMEnableModuleResponseMessage(
2426 XmlParser& parser)
2427 {
2428 XmlEntry entry;
2429 CIMValue genericValue;
2430 Uint16 genericUint16;
2431 Array<Uint16> operationalStatus;
2432
2433 // Get operationalStatus array
2434 XmlReader::expectStartTag(parser, entry, "PGUINT16ARRAY");
2435 while (XmlReader::getValueElement(parser, CIMTYPE_UINT16, genericValue))
2436 {
2437 genericValue.get(genericUint16);
2438 operationalStatus.append(genericUint16);
2439 }
2440 kumpf 1.1 XmlReader::expectEndTag(parser, "PGUINT16ARRAY");
2441
2442 CIMEnableModuleResponseMessage* message =
2443 new CIMEnableModuleResponseMessage(
2444 String::EMPTY, // messageId
2445 CIMException(), // cimException
2446 QueueIdStack(), // queueIds
2447 operationalStatus);
2448
|
2449 kumpf 1.38 return message;
|
2450 kumpf 1.1 }
2451
2452 //
2453 // _deserializeCIMStopAllProvidersResponseMessage
2454 //
2455 CIMStopAllProvidersResponseMessage*
2456 CIMMessageDeserializer::_deserializeCIMStopAllProvidersResponseMessage(
2457 XmlParser& parser)
2458 {
2459 CIMStopAllProvidersResponseMessage* message =
2460 new CIMStopAllProvidersResponseMessage(
2461 String::EMPTY, // messageId
2462 CIMException(), // cimException
2463 QueueIdStack()); // queueIds
2464
|
2465 kumpf 1.38 return message;
|
2466 kumpf 1.1 }
2467
|
2468 kumpf 1.2 //
|
2469 kumpf 1.7 // _deserializeCIMInitializeProviderAgentResponseMessage
2470 //
2471 CIMInitializeProviderAgentResponseMessage*
2472 CIMMessageDeserializer::_deserializeCIMInitializeProviderAgentResponseMessage(
2473 XmlParser& parser)
2474 {
2475 CIMInitializeProviderAgentResponseMessage* message =
2476 new CIMInitializeProviderAgentResponseMessage(
2477 String::EMPTY, // messageId
2478 CIMException(), // cimException
2479 QueueIdStack()); // queueIds
2480
|
2481 kumpf 1.38 return message;
|
2482 kumpf 1.7 }
2483
|
2484 kumpf 1.8 //
2485 // _deserializeCIMNotifyConfigChangeResponseMessage
2486 //
2487 CIMNotifyConfigChangeResponseMessage*
2488 CIMMessageDeserializer::_deserializeCIMNotifyConfigChangeResponseMessage(
2489 XmlParser& parser)
2490 {
2491 CIMNotifyConfigChangeResponseMessage* message =
2492 new CIMNotifyConfigChangeResponseMessage(
2493 String::EMPTY, // messageId
2494 CIMException(), // cimException
2495 QueueIdStack()); // queueIds
2496
|
2497 kumpf 1.38 return message;
|
2498 kumpf 1.8 }
2499
|
2500 carolann.graves 1.22 //
2501 // _deserializeCIMSubscriptionInitCompleteResponseMessage
2502 //
2503 CIMSubscriptionInitCompleteResponseMessage*
2504 CIMMessageDeserializer::_deserializeCIMSubscriptionInitCompleteResponseMessage(
2505 XmlParser& parser)
2506 {
2507 CIMSubscriptionInitCompleteResponseMessage* message =
2508 new CIMSubscriptionInitCompleteResponseMessage(
2509 String::EMPTY, // messageId
2510 CIMException(), // cimException
2511 QueueIdStack()); // queueIds
2512
|
2513 kumpf 1.38 return message;
|
2514 carolann.graves 1.22 }
|
2515 kumpf 1.1
2516 PEGASUS_NAMESPACE_END
|
Return to
CIMMessageDeserializer.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common