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