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