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