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