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