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 //
19 // 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 schuur 1.1 // Modified By: Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
33 // Dave Rosckes (rosckes@us.ibm.com)
|
34 brian.campbell 1.6 // Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase2
|
35 schuur 1.1 //
36 //%/////////////////////////////////////////////////////////////////////////////
37
38 #ifndef Pegasus_SimpleResponseHandler_h
39 #define Pegasus_SimpleResponseHandler_h
40
41 #include <Pegasus/Common/Config.h>
42 #include <Pegasus/Common/ResponseHandler.h>
43 #include <Pegasus/Common/Logger.h>
44
45 #include <Pegasus/ProviderManager2/Linkage.h>
46
47 PEGASUS_NAMESPACE_BEGIN
48
|
49 kumpf 1.3 //
50 // ValueResponseHandler (used internally to implement property operations)
51 //
52 class PEGASUS_PPM_LINKAGE ValueResponseHandler : virtual public ResponseHandler
53 {
54 public:
55 virtual void deliver(const CIMValue & value) = 0;
56
57 virtual void deliver(const Array<CIMValue> & values) = 0;
58 };
59
60
61 //
62 // SimpleResponseHandler
63 //
|
64 schuur 1.1 class PEGASUS_PPM_LINKAGE SimpleResponseHandler : virtual public ResponseHandler
65 {
66 public:
67 SimpleResponseHandler(void)
68 {
69 }
70
71 virtual ~SimpleResponseHandler(void)
72 {
73 }
74
75 virtual void processing(void)
76 {
77 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
78 "SimpleResponseHandler: processing()");
79 // do nothing
80 }
81
82 virtual void complete(void)
83 {
84 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
85 schuur 1.1 "SimpleResponseHandler: complete()");
86
|
87 brian.campbell 1.6 send(true);
|
88 schuur 1.1 }
89
|
90 brian.campbell 1.6 // return the number of objects in this handler
91 virtual Uint32 size() const { return 0; }
92
93 // clear any objects in this handler
94 virtual void clear() {}
95
|
96 schuur 1.1 // l10n
|
97 brian.campbell 1.6 ContentLanguages getLanguages(void);
|
98 schuur 1.1
|
99 brian.campbell 1.6 protected:
100 // send (deliver) asynchronously with restrictions
101 virtual void send(Boolean isComplete);
|
102 schuur 1.1
103 };
104
105 class PEGASUS_PPM_LINKAGE SimpleInstanceResponseHandler : public SimpleResponseHandler, public InstanceResponseHandler
106 {
107 public:
108 SimpleInstanceResponseHandler(void)
109 {
110 }
111
|
112 brian.campbell 1.6 virtual void processing(void) { SimpleResponseHandler::processing(); }
113 virtual void complete(void) { SimpleResponseHandler::complete(); }
114 virtual Uint32 size() const { return _objects.size(); }
115 virtual void clear() { _objects.clear(); }
|
116 schuur 1.1
117 virtual void deliver(const CIMInstance & instance)
118 {
119 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
120 "SimpleResponseHandler: deliver()");
121
122 _objects.append(instance);
|
123 brian.campbell 1.6 send(false);
|
124 schuur 1.1 }
125
126 virtual void deliver(const Array<CIMInstance> & instances)
127 {
128 // call deliver for each object in the array
129 for(Uint32 i = 0, n = instances.size(); i < n; i++)
130 {
131 deliver(instances[i]);
132 }
133 }
134
135 const Array<CIMInstance> getObjects(void) const
136 {
137 return _objects;
138 }
139
140 private:
141 Array<CIMInstance> _objects;
142
143 };
144
145 schuur 1.1 class PEGASUS_PPM_LINKAGE SimpleObjectPathResponseHandler : public SimpleResponseHandler, public ObjectPathResponseHandler
146 {
147 public:
148 SimpleObjectPathResponseHandler(void)
149 {
150 }
151
|
152 brian.campbell 1.6 virtual void processing(void) { SimpleResponseHandler::processing(); }
153 virtual void complete(void) { SimpleResponseHandler::complete(); }
154 virtual Uint32 size() const { return _objects.size(); }
155 virtual void clear() { _objects.clear(); }
|
156 schuur 1.1
157 virtual void deliver(const CIMObjectPath & objectPath)
158 {
159 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
160 "SimpleResponseHandler: deliver()");
161 _objects.append(objectPath);
|
162 brian.campbell 1.6 send(false);
|
163 schuur 1.1 }
164
165 virtual void deliver(const Array<CIMObjectPath> & objectPaths)
166 {
167 // call deliver for each object in the array
168 for(Uint32 i = 0, n = objectPaths.size(); i < n; i++)
169 {
170 deliver(objectPaths[i]);
171 }
172 }
173
174 const Array<CIMObjectPath> getObjects(void) const
175 {
176 return _objects;
177 }
178
179 private:
180 Array<CIMObjectPath> _objects;
181
182 };
183
184 schuur 1.1 class PEGASUS_PPM_LINKAGE SimpleMethodResultResponseHandler : public SimpleResponseHandler, public MethodResultResponseHandler
185 {
186 public:
187 SimpleMethodResultResponseHandler(void)
188 {
189 }
190
|
191 brian.campbell 1.6 virtual void processing(void) { SimpleResponseHandler::processing(); }
192 virtual void complete(void) { SimpleResponseHandler::complete(); }
193 // NOTE: this is the total size (count) of ALL parameters!
194 virtual Uint32 size() const { return _objects.size(); }
195 virtual void clear() { _objects.clear(); _returnValue.clear(); }
|
196 schuur 1.1
197 virtual void deliverParamValue(const CIMParamValue & outParamValue)
198 {
199 _objects.append(outParamValue);
|
200 brian.campbell 1.6 // async delivers not yet supported for parameters
201 //send(false);
|
202 schuur 1.1 }
203
204 virtual void deliverParamValue(const Array<CIMParamValue> & outParamValues)
205 {
206 // call deliver for each object in the array
207 for(Uint32 i = 0, n = outParamValues.size(); i < n; i++)
208 {
209 deliverParamValue(outParamValues[i]);
210 }
211 }
212
213 virtual void deliver(const CIMValue & returnValue)
214 {
215 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
216 "SimpleResponseHandler: deliver()");
217 _returnValue = returnValue;
|
218 brian.campbell 1.6 send(false);
|
219 schuur 1.1 }
220
221 const Array<CIMParamValue> getParamValues(void) const
222 {
223 return _objects;
224 }
225
226 const CIMValue getReturnValue(void) const
227 {
228 return _returnValue;
229 }
230
231 private:
232 Array<CIMParamValue> _objects;
233
234 CIMValue _returnValue;
235
236 };
237
238 class PEGASUS_PPM_LINKAGE SimpleIndicationResponseHandler : public SimpleResponseHandler, public IndicationResponseHandler
239 {
240 schuur 1.1 public:
241 SimpleIndicationResponseHandler(void)
242 {
243 }
244
|
245 brian.campbell 1.6 virtual void processing(void) { SimpleResponseHandler::processing(); }
246 virtual void complete(void) { SimpleResponseHandler::complete(); }
247 virtual Uint32 size() const { return _objects.size(); }
248 virtual void clear() { _objects.clear(); }
|
249 schuur 1.1
250 virtual void deliver(const CIMIndication & indication)
251 {
252 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
253 "SimpleResponseHandler: deliver()");
254
255 _objects.append(indication);
|
256 brian.campbell 1.6 send(false);
|
257 schuur 1.1 }
258
259 virtual void deliver(const Array<CIMIndication> & indications)
260 {
261 // call deliver for each object in the array
262 for(Uint32 i = 0, n = indications.size(); i < n; i++)
263 {
264 deliver(indications[i]);
265 }
266 }
267
268 virtual void deliver(
269 const OperationContext & context,
270 const CIMIndication & indication)
271 {
272 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
273 "SimpleResponseHandler: deliver()");
274
275 _objects.append(indication);
276 }
277
278 schuur 1.1 virtual void deliver(
279 const OperationContext & context,
280 const Array<CIMIndication> & indications)
281 {
282 // call deliver for each object in the array
283 for(Uint32 i = 0, n = indications.size(); i < n; i++)
284 {
285 deliver(indications[i]);
286 }
287 }
288
289 const Array<CIMIndication> getObjects(void) const
290 {
291 return _objects;
292 }
293
294 CIMInstance _provider;
295
296 private:
297 Array<CIMIndication> _objects;
298
299 schuur 1.1 };
300
301 class PEGASUS_PPM_LINKAGE SimpleObjectResponseHandler : public SimpleResponseHandler, public ObjectResponseHandler
302 {
303 public:
304 SimpleObjectResponseHandler(void)
305 {
306 }
307
|
308 brian.campbell 1.6 virtual void processing(void) { SimpleResponseHandler::processing(); }
309 virtual void complete(void) { SimpleResponseHandler::complete(); }
310 virtual Uint32 size() const { return _objects.size(); }
311 virtual void clear() { _objects.clear(); }
|
312 schuur 1.1
313 virtual void deliver(const CIMObject & object)
314 {
315 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
316 "SimpleResponseHandler: deliver()");
317
318 _objects.append(object);
|
319 brian.campbell 1.6 send(false);
|
320 schuur 1.1 }
321
322 virtual void deliver(const Array<CIMObject> & objects)
323 {
324 // call deliver for each object in the array
325 for(Uint32 i = 0, n = objects.size(); i < n; i++)
326 {
327 deliver(objects[i]);
328 }
329 }
330
331 const Array<CIMObject> getObjects(void) const
332 {
333 return _objects;
334 }
335
336 private:
337 Array<CIMObject> _objects;
338
339 };
340
341 schuur 1.1 class PEGASUS_PPM_LINKAGE SimpleInstance2ObjectResponseHandler : public SimpleResponseHandler, public InstanceResponseHandler
342 {
343 public:
344 SimpleInstance2ObjectResponseHandler(void)
345 {
346 }
347
|
348 brian.campbell 1.6 virtual void processing(void) { SimpleResponseHandler::processing(); }
349 virtual void complete(void) { SimpleResponseHandler::complete(); }
350 virtual Uint32 size() const { return _objects.size(); }
351 virtual void clear() { _objects.clear(); }
|
352 schuur 1.1
353 virtual void deliver(const CIMInstance & object)
354 {
355 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
356 "SimpleResponseHandler: deliver()");
357
358 _objects.append(CIMObject(object));
|
359 brian.campbell 1.6 // async delivers not yet supported
360 //send(false);
|
361 schuur 1.1 }
362
363 virtual void deliver(const Array<CIMInstance> & objects)
364 {
365 // call deliver for each object in the array
366 for(Uint32 i = 0, n = objects.size(); i < n; i++)
367 {
368 deliver(objects[i]);
369 }
370 }
371
372 const Array<CIMObject> getObjects(void) const
373 {
374 return _objects;
375 }
376
377 private:
378 Array<CIMObject> _objects;
379
380 };
381
382 schuur 1.1 class PEGASUS_PPM_LINKAGE SimpleValueResponseHandler : public SimpleResponseHandler, public ValueResponseHandler
383 {
384 public:
385 SimpleValueResponseHandler(void)
386 {
387 }
388
|
389 brian.campbell 1.6 virtual void processing(void) { SimpleResponseHandler::processing(); }
390 virtual void complete(void) { SimpleResponseHandler::complete(); }
391 virtual Uint32 size() const { return _objects.size(); }
392 virtual void clear() { _objects.clear(); }
|
393 schuur 1.1
394 virtual void deliver(const CIMValue & value)
395 {
396 Logger::put(Logger::STANDARD_LOG, System::CIMSERVER, Logger::TRACE,
397 "SimpleResponseHandler: deliver()");
398
399 _objects.append(value);
|
400 brian.campbell 1.6 send(false);
|
401 schuur 1.1 }
402
403 virtual void deliver(const Array<CIMValue> & values)
404 {
405 // call deliver for each object in the array
406 for(Uint32 i = 0, n = values.size(); i < n; i++)
407 {
408 deliver(values[i]);
409 }
410 }
411
412 const Array<CIMValue> getObjects(void) const
413 {
414 return _objects;
415 }
416
417 private:
418 Array<CIMValue> _objects;
419
420 };
421
422 schuur 1.1 PEGASUS_NAMESPACE_END
423
424 #endif
|
Return to
SimpleResponseHandler.h
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2