1 r.kieninger 1.1 //%LICENSE////////////////////////////////////////////////////////////////
2 //
3 // Licensed to The Open Group (TOG) under one or more contributor license
4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
5 // this work for additional information regarding copyright ownership.
6 // Each contributor licenses this file to you under the OpenPegasus Open
7 // Source License; you may not use this file except in compliance with the
8 // License.
9 //
10 // Permission is hereby granted, free of charge, to any person obtaining a
11 // copy of this software and associated documentation files (the "Software"),
12 // to deal in the Software without restriction, including without limitation
13 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 // and/or sell copies of the Software, and to permit persons to whom the
15 // Software is furnished to do so, subject to the following conditions:
16 //
17 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
19 //
20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 r.kieninger 1.1 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28 //////////////////////////////////////////////////////////////////////////
29 //
30 //%/////////////////////////////////////////////////////////////////////////////
31
32 #include "CIMResponseData.h"
|
33 marek 1.2.2.5 #include <Pegasus/Common/Tracer.h>
34 #include <Pegasus/Common/XmlWriter.h>
35 #include <Pegasus/Common/SCMOXmlWriter.h>
36 #include <Pegasus/Common/XmlReader.h>
|
37 marek 1.2.2.15 #include <Pegasus/Common/CIMInternalXmlEncoder.h>
38 #include <Pegasus/Common/SCMOInternalXmlEncoder.h>
|
39 r.kieninger 1.1
40 PEGASUS_USING_STD;
41
42 PEGASUS_NAMESPACE_BEGIN
43
|
44 marek 1.2.2.5 // C++ objects interface handling
45
46 // Instance Names handling
47 Array<CIMObjectPath>& CIMResponseData::getInstanceNames()
48 {
49 PEGASUS_DEBUG_ASSERT(
50 (_dataType==RESP_INSTNAMES || _dataType==RESP_OBJECTPATHS));
51 _resolveToCIM();
|
52 marek 1.2.2.11 PEGASUS_DEBUG_ASSERT(_encoding==RESP_ENC_CIM || _encoding == 0);
|
53 marek 1.2.2.5 return _instanceNames;
54 }
55
56 // Instance handling
57 CIMInstance& CIMResponseData::getInstance()
58 {
59 PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCE);
60 _resolveToCIM();
|
61 marek 1.2.2.15 if (0 == _instances.size())
62 {
63 _instances.append(CIMInstance());
64 }
|
65 marek 1.2.2.5 return _instances[0];
66 }
67
68 // Instances handling
69 Array<CIMInstance>& CIMResponseData::getInstances()
70 {
71 PEGASUS_DEBUG_ASSERT(_dataType == RESP_INSTANCES);
72 _resolveToCIM();
73 return _instances;
74 }
75
76 // Objects handling
77 Array<CIMObject>& CIMResponseData::getObjects()
78 {
79 PEGASUS_DEBUG_ASSERT(_dataType == RESP_OBJECTS);
80 _resolveToCIM();
81 return _objects;
82 }
83
84 // SCMO representation, single instance stored as one element array
85 // object paths are represented as SCMOInstance
86 marek 1.2.2.5 Array<SCMOInstance>& CIMResponseData::getSCMO()
87 {
88 _resolveToSCMO();
89 return _scmoInstances;
90 }
91
|
92 marek 1.2.2.6 void CIMResponseData::setSCMO(const Array<SCMOInstance>& x)
93 {
|
94 marek 1.2.2.8 _scmoInstances=x;
|
95 marek 1.2.2.6 _encoding |= RESP_ENC_SCMO;
96 }
97
98
|
99 marek 1.2.2.5 // Binary data is just a data stream
100 Array<Uint8>& CIMResponseData::getBinary()
101 {
|
102 marek 1.2.2.11 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_BINARY || _encoding == 0);
|
103 marek 1.2.2.5 return _binaryData;
104 }
105
106 bool CIMResponseData::setBinary(CIMBuffer& in, bool hasLen)
|
107 r.kieninger 1.2.2.1 {
108 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
109 marek 1.2.2.5 "CIMResponseData::setBinary");
|
110 r.kieninger 1.2.2.1
111 if (hasLen)
112 {
113 if (!in.getUint8A(_binaryData))
114 {
115 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
116 "Failed to get binary object path data!");
117 PEG_METHOD_EXIT();
118 return false;
119 }
120 }
121 else
122 {
123 size_t remainingDataLength = in.capacity() - in.size();
124 _binaryData.append((Uint8*)in.getPtr(), remainingDataLength);
125 }
|
126 marek 1.2.2.5 _encoding |= RESP_ENC_BINARY;
|
127 r.kieninger 1.2.2.1 PEG_METHOD_EXIT();
128 return true;
|
129 marek 1.2.2.5 }
|
130 r.kieninger 1.2.2.1
|
131 marek 1.2.2.5 bool CIMResponseData::setXml(CIMBuffer& in)
|
132 r.kieninger 1.2.2.1 {
|
133 marek 1.2.2.15 switch (_dataType)
|
134 r.kieninger 1.2.2.1 {
|
135 marek 1.2.2.15 case RESP_INSTANCE:
|
136 r.kieninger 1.2.2.1 {
|
137 marek 1.2.2.15 Array<Sint8> inst;
|
138 marek 1.2.2.5 Array<Sint8> ref;
139 CIMNamespaceName ns;
140 String host;
|
141 marek 1.2.2.15 if (!in.getSint8A(inst))
142 {
143 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
144 "Failed to get XML instance data!");
145 return false;
146 }
147 _instanceData.insert(0,inst);
|
148 marek 1.2.2.5 if (!in.getSint8A(ref))
149 {
150 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
|
151 marek 1.2.2.15 "Failed to get XML instance data (reference)!");
|
152 marek 1.2.2.5 return false;
153 }
|
154 marek 1.2.2.15 _referencesData.insert(0,ref);
|
155 marek 1.2.2.5 if (!in.getString(host))
156 {
157 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
158 "Failed to get XML instance data (host)!");
159 return false;
160 }
|
161 marek 1.2.2.15 _hostsData.insert(0,host);
|
162 marek 1.2.2.5 if (!in.getNamespaceName(ns))
163 {
164 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
165 "Failed to get XML instance data (namespace)!");
166 return false;
167 }
|
168 marek 1.2.2.15 _nameSpacesData.insert(0,ns);
169 break;
170 }
171 case RESP_INSTANCES:
172 {
173 Uint32 count;
174 if (!in.getUint32(count))
175 {
176 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
177 "Failed to get XML instance data (number of instance)!");
178 return false;
179 }
180 for (Uint32 i = 0; i < count; i++)
181 {
182 Array<Sint8> inst;
183 Array<Sint8> ref;
184 CIMNamespaceName ns;
185 String host;
186 if (!in.getSint8A(inst))
187 {
188 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
189 marek 1.2.2.15 "Failed to get XML instance data (instances)!");
190 return false;
191 }
192 if (!in.getSint8A(ref))
193 {
194 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
195 "Failed to get XML instance data (references)!");
196 return false;
197 }
198 if (!in.getString(host))
199 {
200 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
201 "Failed to get XML instance data (host)!");
202 return false;
203 }
204 if (!in.getNamespaceName(ns))
205 {
206 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
207 "Failed to get XML instance data (namespace)!");
208 return false;
209 }
210 marek 1.2.2.15 _instanceData.append(inst);
211 _referencesData.append(ref);
212 _hostsData.append(host);
213 _nameSpacesData.append(ns);
214 }
215 break;
216 }
217 case RESP_OBJECTS:
218 {
219 Uint32 count;
220 if (!in.getUint32(count))
221 {
222 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
223 "Failed to get XML object data (number of objects)!");
224 return false;
225 }
226 for (Uint32 i = 0; i < count; i++)
227 {
228 Array<Sint8> obj;
229 Array<Sint8> ref;
230 CIMNamespaceName ns;
231 marek 1.2.2.15 String host;
232 if (!in.getSint8A(obj))
233 {
234 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
235 "Failed to get XML object data (object)!");
236 return false;
237 }
238 if (!in.getSint8A(ref))
239 {
240 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
241 "Failed to get XML object data (reference)!");
242 return false;
243 }
244 if (!in.getString(host))
245 {
246 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
247 "Failed to get XML object data (host)!");
248 return false;
249 }
250 if (!in.getNamespaceName(ns))
251 {
252 marek 1.2.2.15 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
253 "Failed to get XML object data (namespace)!");
254 return false;
255 }
256 _instanceData.append(obj);
257 _referencesData.append(ref);
258 _hostsData.append(host);
259 _nameSpacesData.append(ns);
260 }
261 break;
262 }
263 // internal xml encoding of instance names and object paths not
264 // done today
265 case RESP_INSTNAMES:
266 case RESP_OBJECTPATHS:
267 default:
268 {
269 PEGASUS_DEBUG_ASSERT(false);
|
270 r.kieninger 1.2.2.1 }
271 }
|
272 marek 1.2.2.5 _encoding |= RESP_ENC_XML;
|
273 r.kieninger 1.2.2.1 return true;
|
274 marek 1.2.2.5 }
275
276 // function used by OperationAggregator to aggregate response data in a
277 // single ResponseData object
278 void CIMResponseData::appendResponseData(const CIMResponseData & x)
279 {
280 // as the Messages set the data types, this should be impossible
281 PEGASUS_DEBUG_ASSERT(_dataType == x._dataType);
282 _encoding |= x._encoding;
283
284 // add all binary data
285 _binaryData.appendArray(x._binaryData);
|
286 r.kieninger 1.2.2.1
|
287 marek 1.2.2.5 // add all the C++ stuff
288 _instanceNames.appendArray(x._instanceNames);
289 _instances.appendArray(x._instances);
290 _objects.appendArray(x._objects);
|
291 r.kieninger 1.2.2.1
|
292 marek 1.2.2.5 // add the SCMO instances
293 _scmoInstances.appendArray(x._scmoInstances);
|
294 r.kieninger 1.2.2.1
|
295 marek 1.2.2.5 // add Xml encodings too
296 _referencesData.appendArray(x._referencesData);
297 _instanceData.appendArray(x._instanceData);
298 _hostsData.appendArray(x._hostsData);
299 _nameSpacesData.appendArray(x._nameSpacesData);
300 }
|
301 r.kieninger 1.2.2.1
|
302 marek 1.2.2.5 // Encoding responses into output format
303 void CIMResponseData::encodeBinaryResponse(CIMBuffer& out)
|
304 r.kieninger 1.2.2.1 {
305 PEG_METHOD_ENTER(TRC_DISPATCHER,
|
306 marek 1.2.2.5 "CIMResponseData::encodeBinaryResponse");
|
307 r.kieninger 1.2.2.1
|
308 marek 1.2.2.5 // Need to do a complete job here by transferring all contained data
309 // into binary format and handing it out in the CIMBuffer
310 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
311 r.kieninger 1.2.2.1 {
|
312 marek 1.2.2.5 // Binary does NOT need a marker as it consists of C++ and SCMO
|
313 r.kieninger 1.2.2.1 const Array<Uint8>& data = _binaryData;
314 out.putBytes(data.getData(), data.size());
315 }
|
316 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
317 r.kieninger 1.2.2.1 {
|
318 r.kieninger 1.2.2.16 out.putTypeMarker(BIN_TYPE_MARKER_CPPD);
|
319 marek 1.2.2.5 switch (_dataType)
|
320 r.kieninger 1.2.2.1 {
|
321 marek 1.2.2.5 case RESP_INSTNAMES:
322 {
323 out.putObjectPathA(_instanceNames, false);
324 break;
325 }
326 case RESP_INSTANCE:
327 {
|
328 marek 1.2.2.15 if (0 == _instances.size())
|
329 marek 1.2.2.5 {
|
330 marek 1.2.2.15 _instances.append(CIMInstance());
|
331 marek 1.2.2.5 }
|
332 marek 1.2.2.15 out.putInstance(_instances[0], false, false);
|
333 marek 1.2.2.5 break;
334 }
335 case RESP_INSTANCES:
336 {
337 out.putInstanceA(_instances, false);
338 break;
339 }
340 case RESP_OBJECTS:
341 {
342 out.putObjectA(_objects);
343 break;
344 }
345 case RESP_OBJECTPATHS:
346 {
|
347 r.kieninger 1.2.2.16 out.putObjectPathA(_instanceNames, false);
|
348 marek 1.2.2.5 break;
349 }
350 default:
351 {
|
352 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
353 marek 1.2.2.5 }
|
354 r.kieninger 1.2.2.1 }
355 }
|
356 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
357 r.kieninger 1.2.2.1 {
|
358 r.kieninger 1.2.2.16 out.putTypeMarker(BIN_TYPE_MARKER_SCMO);
359 out.putSCMOInstanceA(_scmoInstances);
|
360 marek 1.2.2.5 }
361 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
362 r.kieninger 1.2.2.1 {
|
363 marek 1.2.2.5 // This actually should not happen following general code logic
|
364 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
365 r.kieninger 1.2.2.1 }
366
367 PEG_METHOD_EXIT();
368 }
369
|
370 marek 1.2.2.13 void CIMResponseData::completeNamespace(const SCMOInstance * x)
|
371 marek 1.2.2.12 {
|
372 marek 1.2.2.13 const char * ns;
373 Uint64 len;
374 ns = x->getNameSpace_l(len);
|
375 marek 1.2.2.12 // Both internal XML as well as binary always contain a namespace
376 // don't have to do anything for those two encodings
377 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
378 {
379 CIMNamespaceName nsName(ns);
380 switch (_dataType)
381 {
382 case RESP_INSTANCE:
383 {
|
384 marek 1.2.2.15 if (_instances.size() > 0)
385 {
|
386 marek 1.2.2.12 const CIMInstance& inst = _instances[0];
387 CIMObjectPath& p =
388 const_cast<CIMObjectPath&>(inst.getPath());
389 if (p.getNameSpace().isNull())
390 {
391 p.setNameSpace(nsName);
392 }
|
393 marek 1.2.2.15 }
|
394 marek 1.2.2.12 }
395 case RESP_INSTANCES:
396 {
397 for (Uint32 j = 0, n = _instances.size(); j < n; j++)
398 {
399 const CIMInstance& inst = _instances[j];
400 CIMObjectPath& p =
401 const_cast<CIMObjectPath&>(inst.getPath());
402 if (p.getNameSpace().isNull())
403 {
404 p.setNameSpace(nsName);
405 }
406 }
407 break;
408 }
409 case RESP_OBJECTS:
410 {
411 for (Uint32 j = 0, n = _objects.size(); j < n; j++)
412 {
413 const CIMObject& object = _objects[j];
414 CIMObjectPath& p =
415 marek 1.2.2.12 const_cast<CIMObjectPath&>(object.getPath());
416 if (p.getNameSpace().isNull())
417 {
418 p.setNameSpace(nsName);
419 }
420 }
421 break;
422 }
423 case RESP_INSTNAMES:
424 case RESP_OBJECTPATHS:
425 {
426 for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++)
427 {
428 CIMObjectPath& p = _instanceNames[j];
429 if (p.getNameSpace().isNull())
430 {
431 p.setNameSpace(nsName);
432 }
433 }
434 break;
435 }
436 marek 1.2.2.12 default:
437 {
438 PEGASUS_DEBUG_ASSERT(false);
439 }
440 }
441 }
442 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
443 {
444 for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)
445 {
446 SCMOInstance & scmoInst=_scmoInstances[j];
447 if (0 == scmoInst.getNameSpace())
448 {
449 scmoInst.setNameSpace_l(ns,len);
450 }
451 }
452 }
453 }
454
455
|
456 marek 1.2.2.9 void CIMResponseData::completeHostNameAndNamespace(
457 const String & hn,
458 const CIMNamespaceName & ns)
459 {
460 // Internal XML always has host name and namespace
|
461 marek 1.2.2.12 // binary data should not ever be present here
|
462 marek 1.2.2.9 PEGASUS_DEBUG_ASSERT((RESP_ENC_BINARY != (_encoding & RESP_ENC_BINARY)));
463
464 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
465 {
466 switch (_dataType)
467 {
468 case RESP_OBJECTS:
469 {
470 for (Uint32 j = 0, n = _objects.size(); j < n; j++)
471 {
472 const CIMObject& object = _objects[j];
473 CIMObjectPath& p =
474 const_cast<CIMObjectPath&>(object.getPath());
475 if (p.getHost().size()==0)
476 {
477 p.setHost(hn);
478 }
479 if (p.getNameSpace().isNull())
480 {
481 p.setNameSpace(ns);
482 }
483 marek 1.2.2.9 }
484 break;
485 }
486 case RESP_OBJECTPATHS:
487 {
488 for (Uint32 j = 0, n = _instanceNames.size(); j < n; j++)
489 {
490 CIMObjectPath& p = _instanceNames[j];
491 if (p.getHost().size() == 0)
492 p.setHost(hn);
493 if (p.getNameSpace().isNull())
494 p.setNameSpace(ns);
495 }
496 break;
497 }
498 default:
499 {
500 PEGASUS_DEBUG_ASSERT(false);
501 }
502 }
503 }
504 marek 1.2.2.9 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
505 {
506 CString hnCString=hn.getCString();
507 const char* hnChars = hnCString;
508 Uint32 hnLen = strlen(hnChars);
509 CString nsCString=ns.getString().getCString();
510 const char* nsChars=nsCString;
511 Uint32 nsLen = strlen(nsChars);
512 switch (_dataType)
513 {
514 case RESP_OBJECTS:
515 case RESP_OBJECTPATHS:
516 {
517 for (Uint32 j = 0, n = _scmoInstances.size(); j < n; j++)
518 {
519 SCMOInstance & scmoInst=_scmoInstances[j];
520 if (0 == scmoInst.getHostName())
521 {
522 scmoInst.setHostName_l(hnChars,hnLen);
523 }
524 if (0 == scmoInst.getNameSpace())
525 marek 1.2.2.9 {
526 scmoInst.setNameSpace_l(nsChars,nsLen);
527 }
528 }
529 break;
530 }
531 default:
532 {
533 PEGASUS_DEBUG_ASSERT(false);
534 }
535 }
536 }
537 }
538
|
539 marek 1.2.2.5 void CIMResponseData::encodeXmlResponse(Buffer& out)
|
540 r.kieninger 1.2.2.1 {
|
541 marek 1.2.2.10 PEG_TRACE((TRC_XML, Tracer::LEVEL3,
542 "CIMResponseData::encodeXmlResponse(encoding=%X,content=%X)\n",
|
543 marek 1.2.2.5 _encoding,
|
544 marek 1.2.2.10 _dataType));
|
545 r.kieninger 1.2.2.1
|
546 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
547 r.kieninger 1.2.2.1 {
|
548 marek 1.2.2.5 switch (_dataType)
|
549 r.kieninger 1.2.2.1 {
|
550 marek 1.2.2.5 case RESP_INSTANCE:
551 {
|
552 marek 1.2.2.15 const Array<ArraySint8>& a = _instanceData;
553 out.append((char*)a[0].getData(), a[0].size() - 1);
|
554 marek 1.2.2.5 break;
555 }
556 case RESP_INSTANCES:
557 {
558 const Array<ArraySint8>& a = _instanceData;
559 const Array<ArraySint8>& b = _referencesData;
|
560 r.kieninger 1.2.2.1
|
561 marek 1.2.2.5 for (Uint32 i = 0, n = a.size(); i < n; i++)
562 {
563 out << STRLIT("<VALUE.NAMEDINSTANCE>\n");
564 out.append((char*)b[i].getData(), b[i].size() - 1);
565 out.append((char*)a[i].getData(), a[i].size() - 1);
566 out << STRLIT("</VALUE.NAMEDINSTANCE>\n");
567 }
568 break;
569 }
570 case RESP_OBJECTS:
|
571 r.kieninger 1.2.2.1 {
|
572 marek 1.2.2.5 const Array<ArraySint8>& a = _instanceData;
573 const Array<ArraySint8>& b = _referencesData;
|
574 r.kieninger 1.2.2.1
|
575 marek 1.2.2.5 for (Uint32 i = 0, n = a.size(); i < n; i++)
576 {
577 out << STRLIT("<VALUE.OBJECTWITHPATH>\n");
578 out.append((char*)b[i].getData(), b[i].size() - 1);
579 out.append((char*)a[i].getData(), a[i].size() - 1);
580 out << STRLIT("</VALUE.OBJECTWITHPATH>\n");
581 }
582 break;
583 }
|
584 marek 1.2.2.15 // internal xml encoding of instance names and object paths not
585 // done today
586 case RESP_INSTNAMES:
|
587 marek 1.2.2.5 case RESP_OBJECTPATHS:
588 default:
589 {
|
590 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
591 r.kieninger 1.2.2.1 }
592 }
593 }
594
|
595 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
596 r.kieninger 1.2.2.1 {
|
597 marek 1.2.2.5 switch (_dataType)
|
598 r.kieninger 1.2.2.1 {
|
599 marek 1.2.2.5 case RESP_INSTNAMES:
600 {
601 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
602 {
603 XmlWriter::appendInstanceNameElement(out,_instanceNames[i]);
604 }
605 break;
606 }
607 case RESP_INSTANCE:
608 {
|
609 marek 1.2.2.15 if (_instances.size() > 0)
|
610 marek 1.2.2.5 {
611 XmlWriter::appendInstanceElement(out, _instances[0]);
612 }
613 break;
614 }
615 case RESP_INSTANCES:
616 {
617 for (Uint32 i = 0, n = _instances.size(); i < n; i++)
618 {
619 XmlWriter::appendValueNamedInstanceElement(
620 out, _instances[i]);
621 }
622 break;
623 }
624 case RESP_OBJECTS:
625 {
626 for (Uint32 i = 0; i < _objects.size(); i++)
627 {
628 XmlWriter::appendValueObjectWithPathElement(
629 out,
630 _objects[i]);
631 marek 1.2.2.5 }
632 break;
633 }
634 case RESP_OBJECTPATHS:
635 {
636 for (Uint32 i = 0, n = _instanceNames.size(); i < n; i++)
637 {
638 out << "<OBJECTPATH>\n";
639 XmlWriter::appendValueReferenceElement(
640 out,
641 _instanceNames[i],
642 false);
643 out << "</OBJECTPATH>\n";
644 }
645 break;
646 }
647 default:
648 {
|
649 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
650 marek 1.2.2.5 }
|
651 r.kieninger 1.2.2.1 }
652 }
|
653 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
654 r.kieninger 1.2.2.1 {
|
655 marek 1.2.2.5 switch (_dataType)
|
656 r.kieninger 1.2 {
|
657 marek 1.2.2.5 case RESP_INSTNAMES:
658 {
659 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
660 {
661 SCMOXmlWriter::appendInstanceNameElement(
662 out,
663 _scmoInstances[i]);
664 }
665 break;
666 }
667 case RESP_INSTANCE:
668 {
669 if (_scmoInstances.size() > 0)
670 {
671 SCMOXmlWriter::appendInstanceElement(out,_scmoInstances[0]);
672 }
673 break;
674 }
675 case RESP_INSTANCES:
676 {
677 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
678 marek 1.2.2.5 {
679 SCMOXmlWriter::appendValueSCMOInstanceElement(
680 out,
681 _scmoInstances[i]);
682 }
683 break;
684 }
685 case RESP_OBJECTS:
686 {
687 for (Uint32 i = 0; i < _scmoInstances.size(); i++)
688 {
689 SCMOXmlWriter::appendValueObjectWithPathElement(
690 out,
691 _scmoInstances[i]);
692 }
693 break;
694 }
695 case RESP_OBJECTPATHS:
696 {
|
697 marek 1.2.2.7 for (Uint32 i = 0, n = _scmoInstances.size(); i < n; i++)
698 {
699 out << "<OBJECTPATH>\n";
700 SCMOXmlWriter::appendValueReferenceElement(
701 out,
702 _scmoInstances[i],
703 false);
704 out << "</OBJECTPATH>\n";
705 }
|
706 marek 1.2.2.5 break;
707 }
708 default:
709 {
|
710 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
711 marek 1.2.2.5 }
|
712 r.kieninger 1.2 }
|
713 r.kieninger 1.1 }
|
714 marek 1.2.2.5 }
|
715 r.kieninger 1.1
|
716 marek 1.2.2.5 // contrary to encodeXmlResponse this function encodes the Xml in a format
717 // not usable by clients
718 void CIMResponseData::encodeInternalXmlResponse(CIMBuffer& out)
719 {
|
720 marek 1.2.2.15 // already existing Internal XML does not need to be encoded further
721 // binary input is not actually impossible here, but we have an established
722 // fallback
723 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
724 {
725 _resolveBinary();
726 }
727 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
728 {
729 switch (_dataType)
730 {
731 case RESP_INSTANCE:
732 {
733 if (0 == _instances.size())
734 {
735 _instances.append(CIMInstance());
736 }
737 CIMInternalXmlEncoder::_putXMLInstance(out, _instances[0]);
738 break;
739 }
740 case RESP_INSTANCES:
741 marek 1.2.2.15 {
742 Uint32 n = _instances.size();
743 out.putUint32(n);
744 for (Uint32 i = 0; i < n; i++)
745 {
746 CIMInternalXmlEncoder::_putXMLNamedInstance(
747 out,
748 _instances[i]);
749 }
750 break;
751 }
752 case RESP_OBJECTS:
753 {
754 Uint32 n = _objects.size();
755 out.putUint32(n);
756 for (Uint32 i = 0; i < n; i++)
757 {
758 CIMInternalXmlEncoder::_putXMLObject(out, _objects[i]);
759 }
760 break;
761 }
762 marek 1.2.2.15 // internal xml encoding of instance names and object paths not
763 // done today
764 case RESP_INSTNAMES:
765 case RESP_OBJECTPATHS:
766 default:
767 {
768 PEGASUS_DEBUG_ASSERT(false);
769 }
770 }
771 }
772 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
773 {
774 switch (_dataType)
775 {
776 case RESP_INSTANCE:
777 {
778 if (0 == _scmoInstances.size())
779 {
780 _scmoInstances.append(SCMOInstance());
781 }
782 SCMOInternalXmlEncoder::_putXMLInstance(out, _scmoInstances[0]);
783 marek 1.2.2.15 break;
784 }
785 case RESP_INSTANCES:
786 {
787 Uint32 n = _scmoInstances.size();
788 out.putUint32(n);
789 for (Uint32 i = 0; i < n; i++)
790 {
791 SCMOInternalXmlEncoder::_putXMLNamedInstance(
792 out,
793 _scmoInstances[i]);
794 }
795 break;
796 }
797 case RESP_OBJECTS:
798 {
799 Uint32 n = _scmoInstances.size();
800 out.putUint32(n);
801 for (Uint32 i = 0; i < n; i++)
802 {
803 SCMOInternalXmlEncoder::_putXMLObject(
804 marek 1.2.2.15 out,
805 _scmoInstances[i]);
806 }
807 break;
808 }
809 // internal xml encoding of instance names and object paths not
810 // done today
811 case RESP_INSTNAMES:
812 case RESP_OBJECTPATHS:
813 default:
814 {
815 PEGASUS_DEBUG_ASSERT(false);
816 }
817 }
818 }
|
819 marek 1.2.2.5 }
|
820 r.kieninger 1.1
|
821 marek 1.2.2.5 void CIMResponseData::_resolveToCIM()
|
822 r.kieninger 1.1 {
|
823 marek 1.2.2.10 PEG_TRACE((TRC_XML, Tracer::LEVEL2,
824 "CIMResponseData::_resolveToCIM(encoding=%X,content=%X)\n",
|
825 marek 1.2.2.5 _encoding,
|
826 marek 1.2.2.10 _dataType));
827
|
828 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
829 r.kieninger 1.1 {
|
830 marek 1.2.2.5 _resolveXmlToCIM();
|
831 r.kieninger 1.1 }
|
832 marek 1.2.2.5 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
833 r.kieninger 1.1 {
|
834 marek 1.2.2.5 _resolveBinary();
|
835 r.kieninger 1.1 }
|
836 marek 1.2.2.5 if (RESP_ENC_SCMO == (_encoding & RESP_ENC_SCMO))
|
837 r.kieninger 1.1 {
|
838 marek 1.2.2.5 _resolveSCMOToCIM();
|
839 r.kieninger 1.1 }
|
840 r.kieninger 1.2.2.16
|
841 marek 1.2.2.11 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_CIM || _encoding == 0);
|
842 marek 1.2.2.5 }
|
843 r.kieninger 1.1
|
844 marek 1.2.2.5 void CIMResponseData::_resolveToSCMO()
845 {
|
846 marek 1.2.2.10 PEG_TRACE((TRC_XML, Tracer::LEVEL2,
847 "CIMResponseData::_resolveToSCMO(encoding=%X,content=%X)\n",
|
848 marek 1.2.2.5 _encoding,
|
849 marek 1.2.2.10 _dataType));
850
|
851 marek 1.2.2.5 if (RESP_ENC_XML == (_encoding & RESP_ENC_XML))
|
852 r.kieninger 1.1 {
|
853 marek 1.2.2.5 _resolveXmlToSCMO();
|
854 r.kieninger 1.1 }
|
855 marek 1.2.2.5 if (RESP_ENC_BINARY == (_encoding & RESP_ENC_BINARY))
|
856 r.kieninger 1.1 {
|
857 marek 1.2.2.5 _resolveBinary();
|
858 r.kieninger 1.1 }
|
859 marek 1.2.2.5 if (RESP_ENC_CIM == (_encoding & RESP_ENC_CIM))
|
860 r.kieninger 1.1 {
|
861 marek 1.2.2.5 _resolveCIMToSCMO();
|
862 r.kieninger 1.1 }
|
863 marek 1.2.2.11 PEGASUS_DEBUG_ASSERT(_encoding == RESP_ENC_SCMO || _encoding == 0);
|
864 r.kieninger 1.1 }
865
|
866 marek 1.2.2.5 // helper functions to transform different formats into one-another
867 // functions work on the internal data and calling of them should be
868 // avoided whenever possible
869 void CIMResponseData::_resolveBinary()
|
870 r.kieninger 1.1 {
|
871 r.kieninger 1.2.2.16 PEG_METHOD_ENTER(TRC_DISPATCHER,
872 "CIMResponseData::_resolveBinary");
|
873 r.kieninger 1.1
|
874 r.kieninger 1.2.2.16 CIMBuffer in((char*)_binaryData.getData(), _binaryData.size());
875
876 while (in.more())
|
877 r.kieninger 1.1 {
|
878 r.kieninger 1.2.2.16 Uint32 binaryTypeMarker=0;
879 if(!in.getTypeMarker(binaryTypeMarker))
|
880 marek 1.2.2.5 {
|
881 r.kieninger 1.2.2.16 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
882 "Failed to get type marker for binary objects!");
883 PEG_METHOD_EXIT();
884 in.release();
885 return;
|
886 marek 1.2.2.5 }
|
887 r.kieninger 1.2.2.16
888 if (BIN_TYPE_MARKER_SCMO==binaryTypeMarker)
|
889 marek 1.2.2.5 {
|
890 r.kieninger 1.2.2.16 if (!in.getSCMOInstanceA(_scmoInstances))
891 {
892 _encoding &=(~RESP_ENC_BINARY);
893 in.release();
894 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
895 "Failed to resolve binary SCMOInstances!");
896 PEG_METHOD_EXIT();
897 return;
898 }
899
900 _encoding |= RESP_ENC_SCMO;
|
901 marek 1.2.2.5 }
|
902 r.kieninger 1.2.2.16 else
|
903 marek 1.2.2.5 {
|
904 r.kieninger 1.2.2.16 switch (_dataType)
905 {
906 // TODO: Decide what to decode based on marker
907 case RESP_INSTNAMES:
908 case RESP_OBJECTPATHS:
909 {
910 if (!in.getObjectPathA(_instanceNames))
911 {
912 _encoding &=(~RESP_ENC_BINARY);
913 in.release();
914 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
915 "Failed to resolve binary CIMObjectPaths!");
916 PEG_METHOD_EXIT();
917 return;
918 }
919 break;
920 }
921 case RESP_INSTANCE:
922 {
923 CIMInstance instance;
924 if (!in.getInstance(instance))
925 r.kieninger 1.2.2.16 {
926 _encoding &=(~RESP_ENC_BINARY);
927 _encoding |= RESP_ENC_CIM;
928 _instances.append(instance);
929 in.release();
930 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
931 "Failed to resolve binary instance!");
932 PEG_METHOD_EXIT();
933 return;
934 }
935
936 _instances.append(instance);
937 break;
938 }
939 case RESP_INSTANCES:
940 {
941 if (!in.getInstanceA(_instances))
942 {
943 _encoding &=(~RESP_ENC_BINARY);
944 in.release();
945 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
946 r.kieninger 1.2.2.16 "Failed to resolve binary CIMInstances!");
947 PEG_METHOD_EXIT();
948 return;
949 }
950 break;
951 }
952 case RESP_OBJECTS:
953 {
954 if (!in.getObjectA(_objects))
955 {
956 in.release();
957 _encoding &=(~RESP_ENC_BINARY);
958 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
959 "Failed to resolve binary CIMObjects!");
960 PEG_METHOD_EXIT();
961 return;
962 }
963 break;
964 }
965 default:
966 {
967 r.kieninger 1.2.2.16 PEGASUS_DEBUG_ASSERT(false);
968 }
969 } // switch
970 _encoding |= RESP_ENC_CIM;
971 } // else SCMO
|
972 r.kieninger 1.1 }
|
973 r.kieninger 1.2.2.16
974 _encoding &=(~RESP_ENC_BINARY);
975
976 in.release();
977 PEG_METHOD_EXIT();
|
978 r.kieninger 1.1 }
979
|
980 marek 1.2.2.5 void CIMResponseData::_resolveXmlToCIM()
|
981 r.kieninger 1.1 {
|
982 marek 1.2.2.5 switch (_dataType)
983 {
|
984 marek 1.2.2.10 // same encoding for instance names and object paths
985 case RESP_OBJECTPATHS:
|
986 marek 1.2.2.5 case RESP_INSTNAMES:
987 {
988 for (Uint32 i = 0; i < _referencesData.size(); i++)
989 {
990 CIMObjectPath cop;
991 // Deserialize path:
992 {
993 XmlParser parser((char*)_referencesData[i].getData());
994
995 if (XmlReader::getInstanceNameElement(parser, cop))
996 {
997 if (!_nameSpacesData[i].isNull())
998 cop.setNameSpace(_nameSpacesData[i]);
999
1000 if (_hostsData[i].size())
1001 cop.setHost(_hostsData[i]);
1002 }
1003 }
1004 _instanceNames.append(cop);
1005 }
1006 break;
1007 marek 1.2.2.5 }
1008 case RESP_INSTANCE:
1009 {
1010 CIMInstance cimInstance;
1011 // Deserialize instance:
1012 {
1013 XmlParser parser((char*)_instanceData[0].getData());
|
1014 r.kieninger 1.1
|
1015 marek 1.2.2.5 if (!XmlReader::getInstanceElement(parser, cimInstance))
1016 {
1017 cimInstance = CIMInstance();
1018 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
1019 "Failed to resolve XML instance, parser error!");
1020 }
1021 }
1022 // Deserialize path:
1023 {
1024 XmlParser parser((char*)_referencesData[0].getData());
1025 CIMObjectPath cimObjectPath;
|
1026 r.kieninger 1.1
|
1027 marek 1.2.2.5 if (XmlReader::getValueReferenceElement(parser, cimObjectPath))
1028 {
1029 if (_hostsData.size())
1030 {
1031 cimObjectPath.setHost(_hostsData[0]);
1032 }
1033 if (!_nameSpacesData[0].isNull())
1034 {
1035 cimObjectPath.setNameSpace(_nameSpacesData[0]);
1036 }
1037 cimInstance.setPath(cimObjectPath);
1038 // only if everything works we add the CIMInstance to the
1039 // array
1040 _instances.append(cimInstance);
1041 }
1042 }
1043 break;
1044 }
1045 case RESP_INSTANCES:
1046 {
1047 for (Uint32 i = 0; i < _instanceData.size(); i++)
1048 marek 1.2.2.5 {
1049 CIMInstance cimInstance;
1050 // Deserialize instance:
1051 {
1052 XmlParser parser((char*)_instanceData[i].getData());
1053
1054 if (!XmlReader::getInstanceElement(parser, cimInstance))
1055 {
1056 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
1057 "Failed to resolve XML instance."
1058 " Creating empty instance!");
1059 cimInstance = CIMInstance();
1060 }
1061 }
1062
1063 // Deserialize path:
1064 {
1065 XmlParser parser((char*)_referencesData[i].getData());
1066 CIMObjectPath cimObjectPath;
1067
1068 if (XmlReader::getInstanceNameElement(parser,cimObjectPath))
1069 marek 1.2.2.5 {
1070 if (!_nameSpacesData[i].isNull())
1071 cimObjectPath.setNameSpace(_nameSpacesData[i]);
1072
1073 if (_hostsData[i].size())
1074 cimObjectPath.setHost(_hostsData[i]);
1075
1076 cimInstance.setPath(cimObjectPath);
1077 }
1078 }
|
1079 r.kieninger 1.1
|
1080 marek 1.2.2.5 _instances.append(cimInstance);
1081 }
1082 break;
1083 }
1084 case RESP_OBJECTS:
1085 {
1086 for (Uint32 i=0, n=_instanceData.size(); i<n; i++)
1087 {
1088 CIMObject cimObject;
1089
1090 // Deserialize Objects:
1091 {
1092 XmlParser parser((char*)_instanceData[i].getData());
1093
1094 CIMInstance cimInstance;
1095 CIMClass cimClass;
1096
1097 if (XmlReader::getInstanceElement(parser, cimInstance))
1098 {
1099 cimObject = CIMObject(cimInstance);
1100 }
1101 marek 1.2.2.5 else if (XmlReader::getClassElement(parser, cimClass))
1102 {
1103 cimObject = CIMObject(cimClass);
1104 }
1105 else
1106 {
1107 PEG_TRACE_CSTRING(TRC_DISCARDED_DATA, Tracer::LEVEL1,
1108 "Failed to get XML object data!");
1109 }
1110 }
1111
1112 // Deserialize paths:
1113 {
1114 XmlParser parser((char*)_referencesData[i].getData());
1115 CIMObjectPath cimObjectPath;
1116
1117 if (XmlReader::getValueReferenceElement(
1118 parser,
1119 cimObjectPath))
1120 {
1121 if (!_nameSpacesData[i].isNull())
1122 marek 1.2.2.5 cimObjectPath.setNameSpace(_nameSpacesData[i]);
1123
1124 if (_hostsData[i].size())
1125 cimObjectPath.setHost(_hostsData[i]);
1126
1127 cimObject.setPath(cimObjectPath);
1128 }
1129 }
1130 _objects.append(cimObject);
1131 }
1132 break;
1133 }
1134 default:
1135 {
|
1136 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
1137 marek 1.2.2.5 }
1138 }
1139 // Xml was resolved, release Xml content now
1140 _referencesData.clear();
1141 _hostsData.clear();
1142 _nameSpacesData.clear();
1143 _instanceData.clear();
1144 // remove Xml Encoding flag
|
1145 marek 1.2.2.8 _encoding &=(~RESP_ENC_XML);
|
1146 marek 1.2.2.5 // add CIM Encoding flag
1147 _encoding |=RESP_ENC_CIM;
|
1148 r.kieninger 1.1 }
1149
|
1150 marek 1.2.2.5 void CIMResponseData::_resolveXmlToSCMO()
|
1151 r.kieninger 1.2.2.4 {
|
1152 marek 1.2.2.5 // Not optimal, can probably be improved
1153 // but on the other hand, since using the binary format this case should
1154 // actually not ever happen.
1155 _resolveXmlToCIM();
1156 _resolveCIMToSCMO();
1157 }
|
1158 r.kieninger 1.2.2.4
|
1159 marek 1.2.2.5 void CIMResponseData::_resolveSCMOToCIM()
1160 {
1161 switch(_dataType)
|
1162 r.kieninger 1.2.2.4 {
|
1163 marek 1.2.2.5 case RESP_INSTNAMES:
1164 case RESP_OBJECTPATHS:
|
1165 r.kieninger 1.1 {
|
1166 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
1167 {
1168 CIMObjectPath newObjectPath;
1169 _scmoInstances[x].getCIMObjectPath(newObjectPath);
1170 _instanceNames.append(newObjectPath);
1171 }
1172 break;
|
1173 r.kieninger 1.1 }
|
1174 marek 1.2.2.5 case RESP_INSTANCE:
|
1175 r.kieninger 1.1 {
|
1176 marek 1.2.2.8 if (_scmoInstances.size() > 0)
1177 {
1178 CIMInstance newInstance;
1179 _scmoInstances[0].getCIMInstance(newInstance);
1180 _instances.append(newInstance);
1181 }
|
1182 marek 1.2.2.5 break;
|
1183 marek 1.2.2.2 }
|
1184 marek 1.2.2.5 case RESP_INSTANCES:
|
1185 r.kieninger 1.2 {
|
1186 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
|
1187 r.kieninger 1.1 {
|
1188 marek 1.2.2.5 CIMInstance newInstance;
1189 _scmoInstances[x].getCIMInstance(newInstance);
1190 _instances.append(newInstance);
|
1191 r.kieninger 1.1 }
|
1192 marek 1.2.2.5 break;
|
1193 r.kieninger 1.1 }
|
1194 marek 1.2.2.5 case RESP_OBJECTS:
|
1195 r.kieninger 1.1 {
|
1196 marek 1.2.2.5 for (Uint32 x=0, n=_scmoInstances.size(); x < n; x++)
|
1197 r.kieninger 1.1 {
|
1198 marek 1.2.2.5 CIMInstance newInstance;
1199 _scmoInstances[x].getCIMInstance(newInstance);
1200 _objects.append(CIMObject(newInstance));
|
1201 r.kieninger 1.1 }
|
1202 marek 1.2.2.5 break;
|
1203 r.kieninger 1.1 }
|
1204 marek 1.2.2.5 default:
|
1205 r.kieninger 1.2.2.1 {
|
1206 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
1207 r.kieninger 1.2.2.1 }
1208 }
|
1209 marek 1.2.2.5 _scmoInstances.clear();
1210 // remove CIM Encoding flag
|
1211 marek 1.2.2.8 _encoding &=(~RESP_ENC_SCMO);
|
1212 marek 1.2.2.5 // add SCMO Encoding flag
1213 _encoding |=RESP_ENC_CIM;
|
1214 r.kieninger 1.2.2.1 }
1215
|
1216 marek 1.2.2.5 void CIMResponseData::_resolveCIMToSCMO()
|
1217 r.kieninger 1.1 {
|
1218 marek 1.2.2.5 switch (_dataType)
|
1219 r.kieninger 1.2 {
|
1220 marek 1.2.2.5 case RESP_INSTNAMES:
|
1221 r.kieninger 1.2 {
|
1222 marek 1.2.2.5 for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
1223 {
|
1224 thilo.boehm 1.2.2.14 SCMOInstance addme(_instanceNames[i]);
|
1225 marek 1.2.2.5 _scmoInstances.append(addme);
1226 }
|
1227 marek 1.2.2.8 _instanceNames.clear();
|
1228 marek 1.2.2.5 break;
|
1229 r.kieninger 1.2 }
|
1230 marek 1.2.2.5 case RESP_INSTANCE:
|
1231 r.kieninger 1.1 {
|
1232 marek 1.2.2.8 if (_instances.size() > 0)
1233 {
|
1234 thilo.boehm 1.2.2.14 SCMOInstance addme(_instances[0]);
|
1235 marek 1.2.2.15 _scmoInstances.clear();
|
1236 marek 1.2.2.8 _scmoInstances.append(addme);
1237 _instances.clear();
1238 }
|
1239 marek 1.2.2.5 break;
|
1240 r.kieninger 1.1 }
|
1241 marek 1.2.2.5 case RESP_INSTANCES:
|
1242 r.kieninger 1.1 {
|
1243 marek 1.2.2.5 for (Uint32 i=0,n=_instances.size();i<n;i++)
1244 {
|
1245 thilo.boehm 1.2.2.14 SCMOInstance addme(_instances[i]);
|
1246 marek 1.2.2.5 _scmoInstances.append(addme);
1247 }
|
1248 marek 1.2.2.8 _instances.clear();
|
1249 marek 1.2.2.5 break;
|
1250 r.kieninger 1.1 }
|
1251 marek 1.2.2.5 case RESP_OBJECTS:
|
1252 r.kieninger 1.1 {
|
1253 marek 1.2.2.8 for (Uint32 i=0,n=_objects.size();i<n;i++)
1254 {
|
1255 thilo.boehm 1.2.2.14 SCMOInstance addme(_objects[i]);
|
1256 marek 1.2.2.8 _scmoInstances.append(addme);
1257 }
1258 _objects.clear();
|
1259 marek 1.2.2.5 break;
|
1260 r.kieninger 1.1 }
|
1261 marek 1.2.2.9 case RESP_OBJECTPATHS:
1262 {
1263 for (Uint32 i=0,n=_instanceNames.size();i<n;i++)
1264 {
|
1265 thilo.boehm 1.2.2.14 SCMOInstance addme(_instanceNames[i]);
1266 // TODO: More description about this.
|
1267 marek 1.2.2.9 if (0 == _instanceNames[i].getKeyBindings().size())
1268 {
1269 // if there is no keybinding, this is a class
1270 addme.setIsClassOnly(true);
1271 }
1272 _scmoInstances.append(addme);
1273 }
1274 _instanceNames.clear();
1275 break;
1276 }
|
1277 marek 1.2.2.5 default:
|
1278 r.kieninger 1.1 {
|
1279 marek 1.2.2.8 PEGASUS_DEBUG_ASSERT(false);
|
1280 r.kieninger 1.1 }
1281 }
1282
|
1283 marek 1.2.2.5 // remove CIM Encoding flag
|
1284 marek 1.2.2.8 _encoding &=(~RESP_ENC_CIM);
|
1285 marek 1.2.2.5 // add SCMO Encoding flag
1286 _encoding |=RESP_ENC_SCMO;
|
1287 r.kieninger 1.1 }
1288
1289 PEGASUS_NAMESPACE_END
|
Return to
CIMResponseData.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common