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