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