1 karl 1.4 //%2005////////////////////////////////////////////////////////////////////////
|
2 schuur 1.1 //
|
3 karl 1.2 // 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 schuur 1.1 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.2 // 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.4 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 schuur 1.1 //
12 // Permission is hereby granted, free of charge, to any person obtaining a copy
13 // of this software and associated documentation files (the "Software"), to
14 // deal in the Software without restriction, including without limitation the
15 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
16 // sell copies of the Software, and to permit persons to whom the Software is
17 // furnished to do so, subject to the following conditions:
|
18 chip 1.5 //
|
19 schuur 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
20 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
21 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
22 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
23 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
24 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
25 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28 //==============================================================================
29 //
30 // Author: Chip Vincent (cvincent@us.ibm.com)
31 //
32 // Modified By:
|
33 brian.campbell 1.3 // Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2
|
34 schuur 1.1 //
35 //%/////////////////////////////////////////////////////////////////////////////
36
|
37 chip 1.5 #include "SimpleResponseHandler.h"
38
39 #include <Pegasus/ProviderManager2/OperationResponseHandler.h>
40
41 #include <Pegasus/Common/Logger.h>
|
42 schuur 1.1
43 PEGASUS_NAMESPACE_BEGIN
44
|
45 chip 1.5 //
46 // SimpleResponseHandler
47 //
48
49 SimpleResponseHandler::SimpleResponseHandler(void)
50 {
51 }
52
53 SimpleResponseHandler::~SimpleResponseHandler(void)
54 {
55 }
56
57 void SimpleResponseHandler::processing(void)
58 {
59 Logger::put(
60 Logger::STANDARD_LOG,
61 System::CIMSERVER,
62 Logger::TRACE,
63 "SimpleResponseHandler::processing()");
64
65 // do nothing
66 chip 1.5 }
67
68 void SimpleResponseHandler::complete(void)
|
69 brian.campbell 1.3 {
|
70 chip 1.5 Logger::put(
71 Logger::STANDARD_LOG,
72 System::CIMSERVER,
73 Logger::TRACE,
74 "SimpleResponseHandler::complete()");
|
75 brian.campbell 1.3
|
76 chip 1.5 send(true);
77 }
|
78 brian.campbell 1.3
|
79 chip 1.5 // return the number of objects in this handler
80 Uint32 SimpleResponseHandler::size(void) const
81 {
82 return(0);
|
83 brian.campbell 1.3 }
84
|
85 chip 1.5 // clear any objects in this handler
86 void SimpleResponseHandler::clear(void)
87 {
88 }
|
89 brian.campbell 1.3
|
90 a.dunfey 1.6.4.1 ContentLanguageList SimpleResponseHandler::getLanguages(void)
|
91 brian.campbell 1.3 {
|
92 chip 1.5 Logger::put(
93 Logger::STANDARD_LOG,
94 System::CIMSERVER,
95 Logger::TRACE,
96 "SimpleResponseHandler: getLanguages()");
97
|
98 a.dunfey 1.6.4.1 ContentLanguageList langs;
|
99 chip 1.5
100 try
|
101 brian.campbell 1.3 {
|
102 a.dunfey 1.6.4.1 // Try to get the ContentLanguageList out of the
103 // OperationContext in the base ResponseHandler.
|
104 brian.campbell 1.3 OperationContext context = getContext();
|
105 chip 1.5
106 ContentLanguageListContainer cntr = context.get(
107 ContentLanguageListContainer::NAME);
108
109 langs = cntr.getLanguages();
|
110 brian.campbell 1.3 }
111 catch (const Exception &)
112 {
113 // The content language container must not exist.
|
114 a.dunfey 1.6.4.1 // Return the empty ContentLanguageList.
|
115 brian.campbell 1.3 }
|
116 chip 1.5
117 return(langs);
118 }
119
120 void SimpleResponseHandler::send(Boolean isComplete)
121 {
122 // If this was NOT instantiated as a derived OperationResponseHandle class,
123 // then this will be null but is NOT an error. In this case, there is no
124 // response attached, hence no data,so there is nothing to send. else we have
125 // a valid "cross-cast" to the operation side
126
127 OperationResponseHandler *operation =
128 dynamic_cast<OperationResponseHandler*>(this);
129
130 if (operation)
131 {
132 operation->send(isComplete);
133 }
134 }
135
136 //
137 chip 1.5 // SimpleInstanceResponseHandler
138 //
139
140 SimpleInstanceResponseHandler::SimpleInstanceResponseHandler(void)
141 {
142 }
143
144 void SimpleInstanceResponseHandler::processing(void)
145 {
146 SimpleResponseHandler::processing();
147 }
148
149 void SimpleInstanceResponseHandler::complete(void)
150 {
151 SimpleResponseHandler::complete();
152 }
153
154 Uint32 SimpleInstanceResponseHandler::size(void) const
155 {
156 return(_objects.size());
157 }
158 chip 1.5
159 void SimpleInstanceResponseHandler::clear(void)
160 {
161 _objects.clear();
162 }
163
164 void SimpleInstanceResponseHandler::deliver(const CIMInstance & instance)
165 {
|
166 mike 1.6 PEG_LOGGER_TRACE((
|
167 chip 1.5 Logger::STANDARD_LOG,
168 System::CIMSERVER,
169 Logger::TRACE,
|
170 mike 1.6 "SimpleInstanceResponseHandler::deliver()"));
|
171 chip 1.5
172 _objects.append(instance);
173
174 send(false);
175 }
176
177 void SimpleInstanceResponseHandler::deliver(const Array<CIMInstance> & instances)
178 {
179 // call deliver for each object in the array
180 for(Uint32 i = 0, n = instances.size(); i < n; i++)
181 {
182 deliver(instances[i]);
183 }
184 }
185
186 const Array<CIMInstance> SimpleInstanceResponseHandler::getObjects(void) const
187 {
188 return(_objects);
189 }
190
191 //
192 chip 1.5 // SimpleObjectPathResponseHandler
193 //
194
195 SimpleObjectPathResponseHandler::SimpleObjectPathResponseHandler(void)
196 {
197 }
198
199 void SimpleObjectPathResponseHandler::processing(void)
200 {
201 SimpleResponseHandler::processing();
202 }
203
204 void SimpleObjectPathResponseHandler::complete(void)
205 {
206 SimpleResponseHandler::complete();
207 }
208
209 Uint32 SimpleObjectPathResponseHandler::size(void) const
210 {
211 return(_objects.size());
212 }
213 chip 1.5
214 void SimpleObjectPathResponseHandler::clear(void)
215 {
216 _objects.clear();
217 }
218
219 void SimpleObjectPathResponseHandler::deliver(const CIMObjectPath & objectPath)
220 {
221 Logger::put(
222 Logger::STANDARD_LOG,
223 System::CIMSERVER,
224 Logger::TRACE,
225 "SimpleObjectPathResponseHandler::deliver()");
226
227 _objects.append(objectPath);
228
229 send(false);
230 }
231
232 void SimpleObjectPathResponseHandler::deliver(const Array<CIMObjectPath> & objectPaths)
233 {
234 chip 1.5 // call deliver for each object in the array
235 for(Uint32 i = 0, n = objectPaths.size(); i < n; i++)
236 {
237 deliver(objectPaths[i]);
238 }
239 }
240
241 const Array<CIMObjectPath> SimpleObjectPathResponseHandler::getObjects(void) const
242 {
243 return(_objects);
244 }
245
246 //
247 // SimpleMethodResultResponseHandler
248 //
249
250 SimpleMethodResultResponseHandler::SimpleMethodResultResponseHandler(void)
251 {
252 }
253
254 void SimpleMethodResultResponseHandler::processing(void)
255 chip 1.5 {
256 SimpleResponseHandler::processing();
257 }
258
259 void SimpleMethodResultResponseHandler::complete(void)
260 {
261 SimpleResponseHandler::complete();
262 }
263
264 Uint32 SimpleMethodResultResponseHandler::size(void) const
265 {
266 return(_objects.size());
267 }
268
269 void SimpleMethodResultResponseHandler::clear(void)
270 {
271 _objects.clear();
272
273 _returnValue.clear();
274 }
275
276 chip 1.5 void SimpleMethodResultResponseHandler::deliverParamValue(const CIMParamValue & outParamValue)
277 {
278 _objects.append(outParamValue);
279
280 // async delivers not yet supported for parameters
281 //send(false);
282 }
283
284 void SimpleMethodResultResponseHandler::deliverParamValue(const Array<CIMParamValue> & outParamValues)
285 {
286 // call deliver for each object in the array
287 for(Uint32 i = 0, n = outParamValues.size(); i < n; i++)
288 {
289 deliverParamValue(outParamValues[i]);
290 }
291 }
292
293 void SimpleMethodResultResponseHandler::deliver(const CIMValue & returnValue)
294 {
295 Logger::put(
296 Logger::STANDARD_LOG,
297 chip 1.5 System::CIMSERVER,
298 Logger::TRACE,
299 "SimpleMethodResultResponseHandler::deliver()");
300
301 _returnValue = returnValue;
302
303 send(false);
304 }
305
306 const Array<CIMParamValue> SimpleMethodResultResponseHandler::getParamValues(void) const
307 {
308 return(_objects);
309 }
310
311 const CIMValue SimpleMethodResultResponseHandler::getReturnValue(void) const
312 {
313 return(_returnValue);
314 }
315
316 //
317 // SimpleIndicationResponseHandler
318 chip 1.5 //
319
320 SimpleIndicationResponseHandler::SimpleIndicationResponseHandler(void)
321 {
322 }
323
324 void SimpleIndicationResponseHandler::processing(void)
325 {
326 SimpleResponseHandler::processing();
327 }
328
329 void SimpleIndicationResponseHandler::complete(void)
330 {
331 SimpleResponseHandler::complete();
332 }
333
334 Uint32 SimpleIndicationResponseHandler::size(void) const
335 {
336 return(_objects.size());
337 }
338
339 chip 1.5 void SimpleIndicationResponseHandler::clear(void)
340 {
341 _objects.clear();
342 }
343
344 void SimpleIndicationResponseHandler::deliver(const CIMIndication & indication)
345 {
346 Logger::put(
347 Logger::STANDARD_LOG,
348 System::CIMSERVER,
349 Logger::TRACE,
350 "SimpleIndicationResponseHandler::deliver()");
351
352 _objects.append(indication);
353
354 send(false);
355 }
356
357 void SimpleIndicationResponseHandler::deliver(const Array<CIMIndication> & indications)
358 {
359 // call deliver for each object in the array
360 chip 1.5 for(Uint32 i = 0, n = indications.size(); i < n; i++)
361 {
362 deliver(indications[i]);
363 }
364 }
365
366 void SimpleIndicationResponseHandler::deliver(
367 const OperationContext & context,
368 const CIMIndication & indication)
369 {
370 Logger::put(
371 Logger::STANDARD_LOG,
372 System::CIMSERVER,
373 Logger::TRACE,
374 "SimpleIndicationResponseHandler::deliver()");
375
376 _objects.append(indication);
377 }
378
379 void SimpleIndicationResponseHandler::deliver(
380 const OperationContext & context,
381 chip 1.5 const Array<CIMIndication> & indications)
382 {
383 // call deliver for each object in the array
384 for(Uint32 i = 0, n = indications.size(); i < n; i++)
385 {
386 deliver(indications[i]);
387 }
388 }
389
390 const Array<CIMIndication> SimpleIndicationResponseHandler::getObjects(void) const
391 {
392 return(_objects);
393 }
394
395
396 //
397 // SimpleObjectResponseHandler
398 //
399
400 SimpleObjectResponseHandler::SimpleObjectResponseHandler(void)
401 {
402 chip 1.5 }
403
404 void SimpleObjectResponseHandler::processing(void)
405 {
406 SimpleResponseHandler::processing();
407 }
408
409 void SimpleObjectResponseHandler::complete(void)
410 {
411 SimpleResponseHandler::complete();
412 }
413
414 Uint32 SimpleObjectResponseHandler::size(void) const
415 {
416 return(_objects.size());
417 }
418
419 void SimpleObjectResponseHandler::clear(void)
420 {
421 _objects.clear();
422 }
423 chip 1.5
424 void SimpleObjectResponseHandler::deliver(const CIMObject & object)
425 {
426 Logger::put(
427 Logger::STANDARD_LOG,
428 System::CIMSERVER,
429 Logger::TRACE,
430 "SimpleObjectResponseHandler::deliver()");
431
432 _objects.append(object);
433
434 send(false);
435 }
436
437 void SimpleObjectResponseHandler::deliver(const Array<CIMObject> & objects)
438 {
439 // call deliver for each object in the array
440 for(Uint32 i = 0, n = objects.size(); i < n; i++)
441 {
442 deliver(objects[i]);
443 }
444 chip 1.5 }
445
446 const Array<CIMObject> SimpleObjectResponseHandler::getObjects(void) const
447 {
448 return(_objects);
449 }
450
451 //
452 // SimpleInstance2ObjectResponseHandler
453 //
454
455 SimpleInstance2ObjectResponseHandler::SimpleInstance2ObjectResponseHandler(void)
456 {
457 }
458
459 void SimpleInstance2ObjectResponseHandler::processing(void)
460 {
461 SimpleResponseHandler::processing();
462 }
463
464 void SimpleInstance2ObjectResponseHandler::complete(void)
465 chip 1.5 {
466 SimpleResponseHandler::complete();
467 }
468
469 Uint32 SimpleInstance2ObjectResponseHandler::size(void) const
470 {
471 return(_objects.size());
472 }
473
474 void SimpleInstance2ObjectResponseHandler::clear(void)
475 {
476 _objects.clear();
477 }
478
479 void SimpleInstance2ObjectResponseHandler::deliver(const CIMInstance & object)
480 {
481 Logger::put(
482 Logger::STANDARD_LOG,
483 System::CIMSERVER,
484 Logger::TRACE,
485 "SimpleInstance2ObjectResponseHandler::deliver()");
486 chip 1.5
487 _objects.append(CIMObject(object));
488
489 // async delivers not yet supported
490 //send(false);
491 }
492
493 void SimpleInstance2ObjectResponseHandler::deliver(const Array<CIMInstance> & objects)
494 {
495 // call deliver for each object in the array
496 for(Uint32 i = 0, n = objects.size(); i < n; i++)
497 {
498 deliver(objects[i]);
499 }
500 }
501
502 const Array<CIMObject> SimpleInstance2ObjectResponseHandler::getObjects(void) const
503 {
504 return(_objects);
505 }
506
507 chip 1.5 //
508 // SimpleValueResponseHandler
509 //
510
511 SimpleValueResponseHandler::SimpleValueResponseHandler(void)
512 {
513 }
514
515 void SimpleValueResponseHandler::processing(void)
516 {
517 SimpleResponseHandler::processing();
518 }
519
520 void SimpleValueResponseHandler::complete(void)
521 {
522 SimpleResponseHandler::complete();
523 }
524
525 Uint32 SimpleValueResponseHandler::size(void) const
526 {
527 return(_objects.size());
528 chip 1.5 }
529
530 void SimpleValueResponseHandler::clear(void)
531 {
532 _objects.clear();
533 }
534
535 void SimpleValueResponseHandler::deliver(const CIMValue & value)
536 {
537 Logger::put(
538 Logger::STANDARD_LOG,
539 System::CIMSERVER,
540 Logger::TRACE,
541 "SimpleValueResponseHandler::deliver()");
542
543 _objects.append(value);
544
545 send(false);
546 }
547
548 void SimpleValueResponseHandler::deliver(const Array<CIMValue> & values)
549 chip 1.5 {
550 // call deliver for each object in the array
551 for(Uint32 i = 0, n = values.size(); i < n; i++)
552 {
553 deliver(values[i]);
554 }
555 }
556
557 const Array<CIMValue> SimpleValueResponseHandler::getObjects(void) const
558 {
559 return(_objects);
|
560 brian.campbell 1.3 }
561
|
562 schuur 1.1 PEGASUS_NAMESPACE_END
|
Return to
SimpleResponseHandler.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2