1
2
3 #include <CORBA.h>
4 #include <mico/throw.h>
5
6 #ifndef __AUKTION_H__
7 #define __AUKTION_H__
8
9
10
11
12 namespace Auktion
{
13
14 class Versteigerung;
15 typedef Versteigerung *Versteigerung_ptr;
16 typedef Versteigerung_ptr VersteigerungRef;
17 typedef ObjVar< Versteigerung > Versteigerung_var;
18 typedef ObjOut< Versteigerung > Versteigerung_out;
19
20 class Verkaeufer;
21 typedef Verkaeufer *Verkaeufer_ptr;
22 typedef Verkaeufer_ptr VerkaeuferRef;
23 typedef ObjVar< Verkaeufer > Verkaeufer_var;
24 typedef ObjOut< Verkaeufer > Verkaeufer_out;
25
26 class Kaeufer;
27 typedef Kaeufer *Kaeufer_ptr;
28 typedef Kaeufer_ptr KaeuferRef;
29 typedef ObjVar< Kaeufer > Kaeufer_var;
30 typedef ObjOut< Kaeufer > Kaeufer_out;
31
32 class CCM_Kaeufer;
33 typedef CCM_Kaeufer *CCM_Kaeufer_ptr;
34 typedef CCM_Kaeufer_ptr CCM_KaeuferRef;
35 typedef ObjVar< CCM_Kaeufer > CCM_Kaeufer_var;
36 typedef ObjOut< CCM_Kaeufer > CCM_Kaeufer_out;
37
38 class GebotConsumer;
39 typedef GebotConsumer *GebotConsumer_ptr;
40 typedef GebotConsumer_ptr GebotConsumerRef;
41 typedef ObjVar< GebotConsumer > GebotConsumer_var;
42 typedef ObjOut< GebotConsumer > GebotConsumer_out;
43
44 class Bieter;
45 typedef Bieter *Bieter_ptr;
46 typedef Bieter_ptr BieterRef;
47 typedef ObjVar< Bieter > Bieter_var;
48 typedef ObjOut< Bieter > Bieter_out;
49
50 class CCM_Bieter;
51 typedef CCM_Bieter *CCM_Bieter_ptr;
52 typedef CCM_Bieter_ptr CCM_BieterRef;
53 typedef ObjVar< CCM_Bieter > CCM_Bieter_var;
54 typedef ObjOut< CCM_Bieter > CCM_Bieter_out;
55
56 class CCM_Bieter_Executor;
57 typedef CCM_Bieter_Executor *CCM_Bieter_Executor_ptr;
58 typedef CCM_Bieter_Executor_ptr CCM_Bieter_ExecutorRef;
59 typedef ObjVar< CCM_Bieter_Executor > CCM_Bieter_Executor_var;
60 typedef ObjOut< CCM_Bieter_Executor > CCM_Bieter_Executor_out;
61
62 class CCM_Bieter_Context;
63 typedef CCM_Bieter_Context *CCM_Bieter_Context_ptr;
64 typedef CCM_Bieter_Context_ptr CCM_Bieter_ContextRef;
65 typedef ObjVar< CCM_Bieter_Context > CCM_Bieter_Context_var;
66 typedef ObjOut< CCM_Bieter_Context > CCM_Bieter_Context_out;
67
68 class CCM_GebotConsumer;
69 typedef CCM_GebotConsumer *CCM_GebotConsumer_ptr;
70 typedef CCM_GebotConsumer_ptr CCM_GebotConsumerRef;
71 typedef ObjVar< CCM_GebotConsumer > CCM_GebotConsumer_var;
72 typedef ObjOut< CCM_GebotConsumer > CCM_GebotConsumer_out;
73
74 class CCM_Versteigerung;
75 typedef CCM_Versteigerung *CCM_Versteigerung_ptr;
76 typedef CCM_Versteigerung_ptr CCM_VersteigerungRef;
77 typedef ObjVar< CCM_Versteigerung > CCM_Versteigerung_var;
78 typedef ObjOut< CCM_Versteigerung > CCM_Versteigerung_out;
79
80 class VersteigerungsFabrik;
81 typedef VersteigerungsFabrik *VersteigerungsFabrik_ptr;
82 typedef VersteigerungsFabrik_ptr VersteigerungsFabrikRef;
83 typedef ObjVar< VersteigerungsFabrik > VersteigerungsFabrik_var;
84 typedef ObjOut< VersteigerungsFabrik > VersteigerungsFabrik_out;
85
86 class KaufConsumer;
87 typedef KaufConsumer *KaufConsumer_ptr;
88 typedef KaufConsumer_ptr KaufConsumerRef;
89 typedef ObjVar< KaufConsumer > KaufConsumer_var;
90 typedef ObjOut< KaufConsumer > KaufConsumer_out;
91
92 class CCM_Verkaeufer;
93 typedef CCM_Verkaeufer *CCM_Verkaeufer_ptr;
94 typedef CCM_Verkaeufer_ptr CCM_VerkaeuferRef;
95 typedef ObjVar< CCM_Verkaeufer > CCM_Verkaeufer_var;
96 typedef ObjOut< CCM_Verkaeufer > CCM_Verkaeufer_out;
97
98 class CCM_Verkaeufer_Executor;
99 typedef CCM_Verkaeufer_Executor *CCM_Verkaeufer_Executor_ptr;
100 typedef CCM_Verkaeufer_Executor_ptr CCM_Verkaeufer_ExecutorRef;
101 typedef ObjVar< CCM_Verkaeufer_Executor > CCM_Verkaeufer_Executor_var;
102 typedef ObjOut< CCM_Verkaeufer_Executor > CCM_Verkaeufer_Executor_out;
103
104 class CCM_Verkaeufer_Context;
105 typedef CCM_Verkaeufer_Context *CCM_Verkaeufer_Context_ptr;
106 typedef CCM_Verkaeufer_Context_ptr CCM_Verkaeufer_ContextRef;
107 typedef ObjVar< CCM_Verkaeufer_Context > CCM_Verkaeufer_Context_var;
108 typedef ObjOut< CCM_Verkaeufer_Context > CCM_Verkaeufer_Context_out;
109
110 class CCM_VersteigerungsFabrik;
111 typedef CCM_VersteigerungsFabrik *CCM_VersteigerungsFabrik_ptr;
112 typedef CCM_VersteigerungsFabrik_ptr CCM_VersteigerungsFabrikRef;
113 typedef ObjVar< CCM_VersteigerungsFabrik > CCM_VersteigerungsFabrik_var;
114 typedef ObjOut< CCM_VersteigerungsFabrik > CCM_VersteigerungsFabrik_out;
115
116 class CCM_KaufConsumer;
117 typedef CCM_KaufConsumer *CCM_KaufConsumer_ptr;
118 typedef CCM_KaufConsumer_ptr CCM_KaufConsumerRef;
119 typedef ObjVar< CCM_KaufConsumer > CCM_KaufConsumer_var;
120 typedef ObjOut< CCM_KaufConsumer > CCM_KaufConsumer_out;
121
122 class Auktionshaus;
123 typedef Auktionshaus *Auktionshaus_ptr;
124 typedef Auktionshaus_ptr AuktionshausRef;
125 typedef ObjVar< Auktionshaus > Auktionshaus_var;
126 typedef ObjOut< Auktionshaus > Auktionshaus_out;
127
128 class CCM_Auktionshaus;
129 typedef CCM_Auktionshaus *CCM_Auktionshaus_ptr;
130 typedef CCM_Auktionshaus_ptr CCM_AuktionshausRef;
131 typedef ObjVar< CCM_Auktionshaus > CCM_Auktionshaus_var;
132 typedef ObjOut< CCM_Auktionshaus > CCM_Auktionshaus_out;
133
134 class CCM_Auktionshaus_Executor;
135 typedef CCM_Auktionshaus_Executor *CCM_Auktionshaus_Executor_ptr;
136 typedef CCM_Auktionshaus_Executor_ptr CCM_Auktionshaus_ExecutorRef;
137 typedef ObjVar< CCM_Auktionshaus_Executor > CCM_Auktionshaus_Executor_var;
138 typedef ObjOut< CCM_Auktionshaus_Executor > CCM_Auktionshaus_Executor_out;
139
140 class CCM_Auktionshaus_Context;
141 typedef CCM_Auktionshaus_Context *CCM_Auktionshaus_Context_ptr;
142 typedef CCM_Auktionshaus_Context_ptr CCM_Auktionshaus_ContextRef;
143 typedef ObjVar< CCM_Auktionshaus_Context > CCM_Auktionshaus_Context_var;
144 typedef ObjOut< CCM_Auktionshaus_Context > CCM_Auktionshaus_Context_out;
145
146 class WeltExplicit;
147 typedef WeltExplicit *WeltExplicit_ptr;
148 typedef WeltExplicit_ptr WeltExplicitRef;
149 typedef ObjVar< WeltExplicit > WeltExplicit_var;
150 typedef ObjOut< WeltExplicit > WeltExplicit_out;
151
152 class WeltImplicit;
153 typedef WeltImplicit *WeltImplicit_ptr;
154 typedef WeltImplicit_ptr WeltImplicitRef;
155 typedef ObjVar< WeltImplicit > WeltImplicit_var;
156 typedef ObjOut< WeltImplicit > WeltImplicit_out;
157
158 class Welt;
159 typedef Welt *Welt_ptr;
160 typedef Welt_ptr WeltRef;
161 typedef ObjVar< Welt > Welt_var;
162 typedef ObjOut< Welt > Welt_out;
163
164 class CCM_WeltExplicit;
165 typedef CCM_WeltExplicit *CCM_WeltExplicit_ptr;
166 typedef CCM_WeltExplicit_ptr CCM_WeltExplicitRef;
167 typedef ObjVar< CCM_WeltExplicit > CCM_WeltExplicit_var;
168 typedef ObjOut< CCM_WeltExplicit > CCM_WeltExplicit_out;
169
170 class CCM_WeltImplicit;
171 typedef CCM_WeltImplicit *CCM_WeltImplicit_ptr;
172 typedef CCM_WeltImplicit_ptr CCM_WeltImplicitRef;
173 typedef ObjVar< CCM_WeltImplicit > CCM_WeltImplicit_var;
174 typedef ObjOut< CCM_WeltImplicit > CCM_WeltImplicit_out;
175
176 class CCM_Welt;
177 typedef CCM_Welt *CCM_Welt_ptr;
178 typedef CCM_Welt_ptr CCM_WeltRef;
179 typedef ObjVar< CCM_Welt > CCM_Welt_var;
180 typedef ObjOut< CCM_Welt > CCM_Welt_out;
181
182 class ProduktFilter;
183 typedef ProduktFilter *ProduktFilter_ptr;
184 typedef ProduktFilter_ptr ProduktFilterRef;
185 typedef ObjVar< ProduktFilter > ProduktFilter_var;
186 typedef ObjOut< ProduktFilter > ProduktFilter_out;
187
188 class CCM_ProduktFilter;
189 typedef CCM_ProduktFilter *CCM_ProduktFilter_ptr;
190 typedef CCM_ProduktFilter_ptr CCM_ProduktFilterRef;
191 typedef ObjVar< CCM_ProduktFilter > CCM_ProduktFilter_var;
192 typedef ObjOut< CCM_ProduktFilter > CCM_ProduktFilter_out;
193
194 class CCM_ProduktFilter_Executor;
195 typedef CCM_ProduktFilter_Executor *CCM_ProduktFilter_Executor_ptr;
196 typedef CCM_ProduktFilter_Executor_ptr CCM_ProduktFilter_ExecutorRef;
197 typedef ObjVar< CCM_ProduktFilter_Executor > CCM_ProduktFilter_Executor_var;
198 typedef ObjOut< CCM_ProduktFilter_Executor > CCM_ProduktFilter_Executor_out;
199
200 class CCM_ProduktFilter_Context;
201 typedef CCM_ProduktFilter_Context *CCM_ProduktFilter_Context_ptr;
202 typedef CCM_ProduktFilter_Context_ptr CCM_ProduktFilter_ContextRef;
203 typedef ObjVar< CCM_ProduktFilter_Context > CCM_ProduktFilter_Context_var;
204 typedef ObjOut< CCM_ProduktFilter_Context > CCM_ProduktFilter_Context_out;
205
206 class FilterHomeExplicit;
207 typedef FilterHomeExplicit *FilterHomeExplicit_ptr;
208 typedef FilterHomeExplicit_ptr FilterHomeExplicitRef;
209 typedef ObjVar< FilterHomeExplicit > FilterHomeExplicit_var;
210 typedef ObjOut< FilterHomeExplicit > FilterHomeExplicit_out;
211
212 class FilterHomeImplicit;
213 typedef FilterHomeImplicit *FilterHomeImplicit_ptr;
214 typedef FilterHomeImplicit_ptr FilterHomeImplicitRef;
215 typedef ObjVar< FilterHomeImplicit > FilterHomeImplicit_var;
216 typedef ObjOut< FilterHomeImplicit > FilterHomeImplicit_out;
217
218 class FilterHome;
219 typedef FilterHome *FilterHome_ptr;
220 typedef FilterHome_ptr FilterHomeRef;
221 typedef ObjVar< FilterHome > FilterHome_var;
222 typedef ObjOut< FilterHome > FilterHome_out;
223
224 class CCM_FilterHomeExplicit;
225 typedef CCM_FilterHomeExplicit *CCM_FilterHomeExplicit_ptr;
226 typedef CCM_FilterHomeExplicit_ptr CCM_FilterHomeExplicitRef;
227 typedef ObjVar< CCM_FilterHomeExplicit > CCM_FilterHomeExplicit_var;
228 typedef ObjOut< CCM_FilterHomeExplicit > CCM_FilterHomeExplicit_out;
229
230 class CCM_FilterHomeImplicit;
231 typedef CCM_FilterHomeImplicit *CCM_FilterHomeImplicit_ptr;
232 typedef CCM_FilterHomeImplicit_ptr CCM_FilterHomeImplicitRef;
233 typedef ObjVar< CCM_FilterHomeImplicit > CCM_FilterHomeImplicit_var;
234 typedef ObjOut< CCM_FilterHomeImplicit > CCM_FilterHomeImplicit_out;
235
236 class CCM_FilterHome;
237 typedef CCM_FilterHome *CCM_FilterHome_ptr;
238 typedef CCM_FilterHome_ptr CCM_FilterHomeRef;
239 typedef ObjVar< CCM_FilterHome > CCM_FilterHome_var;
240 typedef ObjOut< CCM_FilterHome > CCM_FilterHome_out;
241
242 class BieterHomeExplicit;
243 typedef BieterHomeExplicit *BieterHomeExplicit_ptr;
244 typedef BieterHomeExplicit_ptr BieterHomeExplicitRef;
245 typedef ObjVar< BieterHomeExplicit > BieterHomeExplicit_var;
246 typedef ObjOut< BieterHomeExplicit > BieterHomeExplicit_out;
247
248 class BieterHomeImplicit;
249 typedef BieterHomeImplicit *BieterHomeImplicit_ptr;
250 typedef BieterHomeImplicit_ptr BieterHomeImplicitRef;
251 typedef ObjVar< BieterHomeImplicit > BieterHomeImplicit_var;
252 typedef ObjOut< BieterHomeImplicit > BieterHomeImplicit_out;
253
254 class BieterHome;
255 typedef BieterHome *BieterHome_ptr;
256 typedef BieterHome_ptr BieterHomeRef;
257 typedef ObjVar< BieterHome > BieterHome_var;
258 typedef ObjOut< BieterHome > BieterHome_out;
259
260 class CCM_BieterHomeExplicit;
261 typedef CCM_BieterHomeExplicit *CCM_BieterHomeExplicit_ptr;
262 typedef CCM_BieterHomeExplicit_ptr CCM_BieterHomeExplicitRef;
263 typedef ObjVar< CCM_BieterHomeExplicit > CCM_BieterHomeExplicit_var;
264 typedef ObjOut< CCM_BieterHomeExplicit > CCM_BieterHomeExplicit_out;
265
266 class CCM_BieterHomeImplicit;
267 typedef CCM_BieterHomeImplicit *CCM_BieterHomeImplicit_ptr;
268 typedef CCM_BieterHomeImplicit_ptr CCM_BieterHomeImplicitRef;
269 typedef ObjVar< CCM_BieterHomeImplicit > CCM_BieterHomeImplicit_var;
270 typedef ObjOut< CCM_BieterHomeImplicit > CCM_BieterHomeImplicit_out;
271
272 class CCM_BieterHome;
273 typedef CCM_BieterHome *CCM_BieterHome_ptr;
274 typedef CCM_BieterHome_ptr CCM_BieterHomeRef;
275 typedef ObjVar< CCM_BieterHome > CCM_BieterHome_var;
276 typedef ObjOut< CCM_BieterHome > CCM_BieterHome_out;
277
278 class VerkaeuferHomeExplicit;
279 typedef VerkaeuferHomeExplicit *VerkaeuferHomeExplicit_ptr;
280 typedef VerkaeuferHomeExplicit_ptr VerkaeuferHomeExplicitRef;
281 typedef ObjVar< VerkaeuferHomeExplicit > VerkaeuferHomeExplicit_var;
282 typedef ObjOut< VerkaeuferHomeExplicit > VerkaeuferHomeExplicit_out;
283
284 class VerkaeuferHomeImplicit;
285 typedef VerkaeuferHomeImplicit *VerkaeuferHomeImplicit_ptr;
286 typedef VerkaeuferHomeImplicit_ptr VerkaeuferHomeImplicitRef;
287 typedef ObjVar< VerkaeuferHomeImplicit > VerkaeuferHomeImplicit_var;
288 typedef ObjOut< VerkaeuferHomeImplicit > VerkaeuferHomeImplicit_out;
289
290 class VerkaeuferHome;
291 typedef VerkaeuferHome *VerkaeuferHome_ptr;
292 typedef VerkaeuferHome_ptr VerkaeuferHomeRef;
293 typedef ObjVar< VerkaeuferHome > VerkaeuferHome_var;
294 typedef ObjOut< VerkaeuferHome > VerkaeuferHome_out;
295
296 class CCM_VerkaeuferHomeExplicit;
297 typedef CCM_VerkaeuferHomeExplicit *CCM_VerkaeuferHomeExplicit_ptr;
298 typedef CCM_VerkaeuferHomeExplicit_ptr CCM_VerkaeuferHomeExplicitRef;
299 typedef ObjVar< CCM_VerkaeuferHomeExplicit > CCM_VerkaeuferHomeExplicit_var;
300 typedef ObjOut< CCM_VerkaeuferHomeExplicit > CCM_VerkaeuferHomeExplicit_out;
301
302 class CCM_VerkaeuferHomeImplicit;
303 typedef CCM_VerkaeuferHomeImplicit *CCM_VerkaeuferHomeImplicit_ptr;
304 typedef CCM_VerkaeuferHomeImplicit_ptr CCM_VerkaeuferHomeImplicitRef;
305 typedef ObjVar< CCM_VerkaeuferHomeImplicit > CCM_VerkaeuferHomeImplicit_var;
306 typedef ObjOut< CCM_VerkaeuferHomeImplicit > CCM_VerkaeuferHomeImplicit_out;
307
308 class CCM_VerkaeuferHome;
309 typedef CCM_VerkaeuferHome *CCM_VerkaeuferHome_ptr;
310 typedef CCM_VerkaeuferHome_ptr CCM_VerkaeuferHomeRef;
311 typedef ObjVar< CCM_VerkaeuferHome > CCM_VerkaeuferHome_var;
312 typedef ObjOut< CCM_VerkaeuferHome > CCM_VerkaeuferHome_out;
313
314 }
315
316
317
318 #include "C:/Studium/Übungen/Corba/mico/include/mico/CCM.h"
319
320
321
322 namespace Auktion
{
323
324
325
326
327 class Kaeufer :
328 virtual public CORBA::Object
{
329 public:
330 virtual ~Kaeufer();
331
332 #ifdef HAVE_TYPEDEF_OVERLOAD
333 typedef Kaeufer_ptr _ptr_type;
334 typedef Kaeufer_var _var_type;
335 #endif
336
337 static Kaeufer_ptr _narrow( CORBA::Object_ptr obj );
338 static Kaeufer_ptr _narrow( CORBA::AbstractBase_ptr obj );
339 static Kaeufer_ptr _duplicate( Kaeufer_ptr _obj )
340 {
341 CORBA::Object::_duplicate (_obj);
342 return _obj;
343 }
344
345 static Kaeufer_ptr _nil()
346 {
347 return 0;
348 }
349
350 virtual void *_narrow_helper( const char *repoid );
351
352 virtual void zuschlag( Versteigerung_ptr gegenstand, Verkaeufer_ptr v ) = 0;
353
354 protected:
355 Kaeufer() {};
356 private:
357 Kaeufer( const Kaeufer& );
358 void operator=( const Kaeufer& );
359 };
360
361
362 class Kaeufer_stub:
363 virtual public Kaeufer
{
364 public:
365 virtual ~Kaeufer_stub();
366 void zuschlag( Versteigerung_ptr gegenstand, Verkaeufer_ptr v );
367
368 private:
369 void operator=( const Kaeufer_stub& );
370 };
371
372 #ifndef MICO_CONF_NO_POA
373
374 class Kaeufer_stub_clp :
375 virtual public Kaeufer_stub,
376 virtual public PortableServer::StubBase
{
377 public:
378 Kaeufer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
379 virtual ~Kaeufer_stub_clp ();
380 void zuschlag( Versteigerung_ptr gegenstand, Verkaeufer_ptr v );
381
382 protected:
383 Kaeufer_stub_clp ();
384 private:
385 void operator=( const Kaeufer_stub_clp & );
386 };
387
388 #endif // MICO_CONF_NO_POA
389
390
391
392
393 class CCM_Kaeufer :
394 virtual public CORBA::LocalObject,
395 virtual public ::Auktion::Kaeufer
{
396 public:
397 virtual ~CCM_Kaeufer();
398
399 #ifdef HAVE_TYPEDEF_OVERLOAD
400 typedef CCM_Kaeufer_ptr _ptr_type;
401 typedef CCM_Kaeufer_var _var_type;
402 #endif
403
404 static CCM_Kaeufer_ptr _narrow( CORBA::Object_ptr obj );
405 static CCM_Kaeufer_ptr _narrow( CORBA::AbstractBase_ptr obj );
406 static CCM_Kaeufer_ptr _duplicate( CCM_Kaeufer_ptr _obj )
407 {
408 CORBA::Object::_duplicate (_obj);
409 return _obj;
410 }
411
412 static CCM_Kaeufer_ptr _nil()
413 {
414 return 0;
415 }
416
417 virtual void *_narrow_helper( const char *repoid );
418
419 protected:
420 CCM_Kaeufer() {};
421 private:
422 CCM_Kaeufer( const CCM_Kaeufer& );
423 void operator=( const CCM_Kaeufer& );
424 };
425
426
427
428
429
430 class Bieter :
431 virtual public ::Components::CCMObject,
432 virtual public ::Auktion::Kaeufer
{
433 public:
434 virtual ~Bieter();
435
436 #ifdef HAVE_TYPEDEF_OVERLOAD
437 typedef Bieter_ptr _ptr_type;
438 typedef Bieter_var _var_type;
439 #endif
440
441 static Bieter_ptr _narrow( CORBA::Object_ptr obj );
442 static Bieter_ptr _narrow( CORBA::AbstractBase_ptr obj );
443 static Bieter_ptr _duplicate( Bieter_ptr _obj )
444 {
445 CORBA::Object::_duplicate (_obj);
446 return _obj;
447 }
448
449 static Bieter_ptr _nil()
450 {
451 return 0;
452 }
453
454 virtual void *_narrow_helper( const char *repoid );
455
456 struct versteigerungenConnection;
457 typedef TVarVar< versteigerungenConnection > versteigerungenConnection_var;
458 typedef TVarOut< versteigerungenConnection > versteigerungenConnection_out;
459
460
461 struct versteigerungenConnection {
462 #ifdef HAVE_TYPEDEF_OVERLOAD
463 typedef versteigerungenConnection_var _var_type;
464 #endif
465 #ifdef HAVE_EXPLICIT_STRUCT_OPS
466 versteigerungenConnection();
467 ~versteigerungenConnection();
468 versteigerungenConnection( const versteigerungenConnection& s );
469 versteigerungenConnection& operator=( const versteigerungenConnection& s );
470 #endif //HAVE_EXPLICIT_STRUCT_OPS
471
472 Versteigerung_var objref;
473 ::Components::Cookie_var ck;
474
475 CORBA::Long _count_refs (CORBA::ValueBase::visited * = 0);
476 void _release_members ();
477 };
478
479 typedef SequenceTmpl< versteigerungenConnection,MICO_TID_DEF> versteigerungenConnections;
480 typedef TSeqVar< SequenceTmpl< versteigerungenConnection,MICO_TID_DEF> > versteigerungenConnections_var;
481 typedef TSeqOut< SequenceTmpl< versteigerungenConnection,MICO_TID_DEF> > versteigerungenConnections_out;
482
483 virtual GebotConsumer_ptr get_consumer_gebote() = 0;
484 virtual ::Components::Cookie* connect_versteigerungen( Versteigerung_ptr connection ) = 0;
485 virtual Versteigerung_ptr disconnect_versteigerungen( ::Components::Cookie* ck ) = 0;
486 virtual versteigerungenConnections* get_connections_versteigerungen() = 0;
487
488 protected:
489 Bieter() {};
490 private:
491 Bieter( const Bieter& );
492 void operator=( const Bieter& );
493 };
494
495
496 class Bieter_stub:
497 virtual public Bieter,
498 virtual public ::Components::CCMObject_stub,
499 virtual public ::Auktion::Kaeufer_stub
{
500 public:
501 virtual ~Bieter_stub();
502 GebotConsumer_ptr get_consumer_gebote();
503 ::Components::Cookie* connect_versteigerungen( Versteigerung_ptr connection );
504 Versteigerung_ptr disconnect_versteigerungen( ::Components::Cookie* ck );
505 versteigerungenConnections* get_connections_versteigerungen();
506
507 private:
508 void operator=( const Bieter_stub& );
509 };
510
511 #ifndef MICO_CONF_NO_POA
512
513 class Bieter_stub_clp :
514 virtual public Bieter_stub,
515 virtual public ::Components::CCMObject_stub_clp,
516 virtual public ::Auktion::Kaeufer_stub_clp
{
517 public:
518 Bieter_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
519 virtual ~Bieter_stub_clp ();
520 GebotConsumer_ptr get_consumer_gebote();
521 ::Components::Cookie* connect_versteigerungen( Versteigerung_ptr connection );
522 Versteigerung_ptr disconnect_versteigerungen( ::Components::Cookie* ck );
523 versteigerungenConnections* get_connections_versteigerungen();
524
525 protected:
526 Bieter_stub_clp ();
527 private:
528 void operator=( const Bieter_stub_clp & );
529 };
530
531 #endif // MICO_CONF_NO_POA
532
533 class Gebot;
534 typedef Gebot *Gebot_ptr;
535 typedef Gebot_ptr GebotRef;
536 typedef ValueVar< Gebot > Gebot_var;
537 typedef ValueOut< Gebot > Gebot_out;
538
539
540
541
542 class CCM_Bieter :
543 virtual public ::Components::EnterpriseComponent,
544 virtual public ::Auktion::Kaeufer
{
545 public:
546 virtual ~CCM_Bieter();
547
548 #ifdef HAVE_TYPEDEF_OVERLOAD
549 typedef CCM_Bieter_ptr _ptr_type;
550 typedef CCM_Bieter_var _var_type;
551 #endif
552
553 static CCM_Bieter_ptr _narrow( CORBA::Object_ptr obj );
554 static CCM_Bieter_ptr _narrow( CORBA::AbstractBase_ptr obj );
555 static CCM_Bieter_ptr _duplicate( CCM_Bieter_ptr _obj )
556 {
557 CORBA::Object::_duplicate (_obj);
558 return _obj;
559 }
560
561 static CCM_Bieter_ptr _nil()
562 {
563 return 0;
564 }
565
566 virtual void *_narrow_helper( const char *repoid );
567
568 virtual void push_gebote( Gebot* conxn ) = 0;
569
570 protected:
571 CCM_Bieter() {};
572 private:
573 CCM_Bieter( const CCM_Bieter& );
574 void operator=( const CCM_Bieter& );
575 };
576
577
578
579
580
581 class CCM_Bieter_Executor :
582 virtual public ::Components::EnterpriseComponent,
583 virtual public ::Auktion::Kaeufer
{
584 public:
585 virtual ~CCM_Bieter_Executor();
586
587 #ifdef HAVE_TYPEDEF_OVERLOAD
588 typedef CCM_Bieter_Executor_ptr _ptr_type;
589 typedef CCM_Bieter_Executor_var _var_type;
590 #endif
591
592 static CCM_Bieter_Executor_ptr _narrow( CORBA::Object_ptr obj );
593 static CCM_Bieter_Executor_ptr _narrow( CORBA::AbstractBase_ptr obj );
594 static CCM_Bieter_Executor_ptr _duplicate( CCM_Bieter_Executor_ptr _obj )
595 {
596 CORBA::Object::_duplicate (_obj);
597 return _obj;
598 }
599
600 static CCM_Bieter_Executor_ptr _nil()
601 {
602 return 0;
603 }
604
605 virtual void *_narrow_helper( const char *repoid );
606
607 protected:
608 CCM_Bieter_Executor() {};
609 private:
610 CCM_Bieter_Executor( const CCM_Bieter_Executor& );
611 void operator=( const CCM_Bieter_Executor& );
612 };
613
614
615
616
617
618 class CCM_Bieter_Context :
619 virtual public ::Components::SessionContext
{
620 public:
621 virtual ~CCM_Bieter_Context();
622
623 #ifdef HAVE_TYPEDEF_OVERLOAD
624 typedef CCM_Bieter_Context_ptr _ptr_type;
625 typedef CCM_Bieter_Context_var _var_type;
626 #endif
627
628 static CCM_Bieter_Context_ptr _narrow( CORBA::Object_ptr obj );
629 static CCM_Bieter_Context_ptr _narrow( CORBA::AbstractBase_ptr obj );
630 static CCM_Bieter_Context_ptr _duplicate( CCM_Bieter_Context_ptr _obj )
631 {
632 CORBA::Object::_duplicate (_obj);
633 return _obj;
634 }
635
636 static CCM_Bieter_Context_ptr _nil()
637 {
638 return 0;
639 }
640
641 virtual void *_narrow_helper( const char *repoid );
642
643 virtual Bieter::versteigerungenConnections* get_connections_versteigerungen() = 0;
644
645 protected:
646 CCM_Bieter_Context() {};
647 private:
648 CCM_Bieter_Context( const CCM_Bieter_Context& );
649 void operator=( const CCM_Bieter_Context& );
650 };
651
652
653
654
655 class Gebot :
656 virtual public ::Components::EventBase
{
657 public:
658 static Gebot* _downcast (CORBA::ValueBase *);
659 static Gebot* _downcast (CORBA::AbstractBase *);
660
661 virtual void gegenstand( Versteigerung_ptr _p ) = 0;
662 virtual Versteigerung_ptr gegenstand() const = 0;
663
664 virtual void angebot( CORBA::Long _p ) = 0;
665 virtual CORBA::Long angebot() const = 0;
666
667
668 public:
669 CORBA::ValueBase * _copy_value ();
670 CORBA::ValueDef_ptr get_value_def ();
671 virtual void * _narrow_helper (const char *);
672 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
673 void _marshal_members (CORBA::DataEncoder &);
674 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
675
676 protected:
677 Gebot ();
678 virtual ~Gebot ();
679 void _copy_members (const Gebot&);
680
681 private:
682 Gebot (const Gebot &);
683 void operator= (const Gebot &);
684 };
685
686
687
688
689 class GebotConsumer :
690 virtual public ::Components::EventConsumerBase
{
691 public:
692 virtual ~GebotConsumer();
693
694 #ifdef HAVE_TYPEDEF_OVERLOAD
695 typedef GebotConsumer_ptr _ptr_type;
696 typedef GebotConsumer_var _var_type;
697 #endif
698
699 static GebotConsumer_ptr _narrow( CORBA::Object_ptr obj );
700 static GebotConsumer_ptr _narrow( CORBA::AbstractBase_ptr obj );
701 static GebotConsumer_ptr _duplicate( GebotConsumer_ptr _obj )
702 {
703 CORBA::Object::_duplicate (_obj);
704 return _obj;
705 }
706
707 static GebotConsumer_ptr _nil()
708 {
709 return 0;
710 }
711
712 virtual void *_narrow_helper( const char *repoid );
713
714 virtual void push_Gebot( Gebot* event ) = 0;
715
716 protected:
717 GebotConsumer() {};
718 private:
719 GebotConsumer( const GebotConsumer& );
720 void operator=( const GebotConsumer& );
721 };
722
723
724 class GebotConsumer_stub:
725 virtual public GebotConsumer,
726 virtual public ::Components::EventConsumerBase_stub
{
727 public:
728 virtual ~GebotConsumer_stub();
729 void push_Gebot( Gebot* event );
730
731 private:
732 void operator=( const GebotConsumer_stub& );
733 };
734
735 #ifndef MICO_CONF_NO_POA
736
737 class GebotConsumer_stub_clp :
738 virtual public GebotConsumer_stub,
739 virtual public ::Components::EventConsumerBase_stub_clp
{
740 public:
741 GebotConsumer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
742 virtual ~GebotConsumer_stub_clp ();
743 void push_Gebot( Gebot* event );
744
745 protected:
746 GebotConsumer_stub_clp ();
747 private:
748 void operator=( const GebotConsumer_stub_clp & );
749 };
750
751 #endif // MICO_CONF_NO_POA
752
753
754
755
756 class CCM_GebotConsumer :
757 virtual public CORBA::LocalObject
{
758 public:
759 virtual ~CCM_GebotConsumer();
760
761 #ifdef HAVE_TYPEDEF_OVERLOAD
762 typedef CCM_GebotConsumer_ptr _ptr_type;
763 typedef CCM_GebotConsumer_var _var_type;
764 #endif
765
766 static CCM_GebotConsumer_ptr _narrow( CORBA::Object_ptr obj );
767 static CCM_GebotConsumer_ptr _narrow( CORBA::AbstractBase_ptr obj );
768 static CCM_GebotConsumer_ptr _duplicate( CCM_GebotConsumer_ptr _obj )
769 {
770 CORBA::Object::_duplicate (_obj);
771 return _obj;
772 }
773
774 static CCM_GebotConsumer_ptr _nil()
775 {
776 return 0;
777 }
778
779 virtual void *_narrow_helper( const char *repoid );
780
781 virtual void push( Gebot* event ) = 0;
782
783 protected:
784 CCM_GebotConsumer() {};
785 private:
786 CCM_GebotConsumer( const CCM_GebotConsumer& );
787 void operator=( const CCM_GebotConsumer& );
788 };
789
790
791
792
793
794 class Versteigerung :
795 virtual public CORBA::Object
{
796 public:
797 virtual ~Versteigerung();
798
799 #ifdef HAVE_TYPEDEF_OVERLOAD
800 typedef Versteigerung_ptr _ptr_type;
801 typedef Versteigerung_var _var_type;
802 #endif
803
804 static Versteigerung_ptr _narrow( CORBA::Object_ptr obj );
805 static Versteigerung_ptr _narrow( CORBA::AbstractBase_ptr obj );
806 static Versteigerung_ptr _duplicate( Versteigerung_ptr _obj )
807 {
808 CORBA::Object::_duplicate (_obj);
809 return _obj;
810 }
811
812 static Versteigerung_ptr _nil()
813 {
814 return 0;
815 }
816
817 virtual void *_narrow_helper( const char *repoid );
818
819 virtual char* name() = 0;
820 virtual CORBA::Long aktuelles_gebot() = 0;
821
822 virtual void biete( CORBA::Long gebot, Bieter_ptr potentieller_kaeufer ) = 0;
823
824 protected:
825 Versteigerung() {};
826 private:
827 Versteigerung( const Versteigerung& );
828 void operator=( const Versteigerung& );
829 };
830
831
832 class Versteigerung_stub:
833 virtual public Versteigerung
{
834 public:
835 virtual ~Versteigerung_stub();
836 char* name();
837 CORBA::Long aktuelles_gebot();
838
839 void biete( CORBA::Long gebot, Bieter_ptr potentieller_kaeufer );
840
841 private:
842 void operator=( const Versteigerung_stub& );
843 };
844
845 #ifndef MICO_CONF_NO_POA
846
847 class Versteigerung_stub_clp :
848 virtual public Versteigerung_stub,
849 virtual public PortableServer::StubBase
{
850 public:
851 Versteigerung_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
852 virtual ~Versteigerung_stub_clp ();
853 char* name();
854 CORBA::Long aktuelles_gebot();
855
856 void biete( CORBA::Long gebot, Bieter_ptr potentieller_kaeufer );
857
858 protected:
859 Versteigerung_stub_clp ();
860 private:
861 void operator=( const Versteigerung_stub_clp & );
862 };
863
864 #endif // MICO_CONF_NO_POA
865
866
867
868
869 class CCM_Versteigerung :
870 virtual public CORBA::LocalObject,
871 virtual public ::Auktion::Versteigerung
{
872 public:
873 virtual ~CCM_Versteigerung();
874
875 #ifdef HAVE_TYPEDEF_OVERLOAD
876 typedef CCM_Versteigerung_ptr _ptr_type;
877 typedef CCM_Versteigerung_var _var_type;
878 #endif
879
880 static CCM_Versteigerung_ptr _narrow( CORBA::Object_ptr obj );
881 static CCM_Versteigerung_ptr _narrow( CORBA::AbstractBase_ptr obj );
882 static CCM_Versteigerung_ptr _duplicate( CCM_Versteigerung_ptr _obj )
883 {
884 CORBA::Object::_duplicate (_obj);
885 return _obj;
886 }
887
888 static CCM_Versteigerung_ptr _nil()
889 {
890 return 0;
891 }
892
893 virtual void *_narrow_helper( const char *repoid );
894
895 protected:
896 CCM_Versteigerung() {};
897 private:
898 CCM_Versteigerung( const CCM_Versteigerung& );
899 void operator=( const CCM_Versteigerung& );
900 };
901
902
903
904
905
906 class Verkaeufer :
907 virtual public ::Components::CCMObject
{
908 public:
909 virtual ~Verkaeufer();
910
911 #ifdef HAVE_TYPEDEF_OVERLOAD
912 typedef Verkaeufer_ptr _ptr_type;
913 typedef Verkaeufer_var _var_type;
914 #endif
915
916 static Verkaeufer_ptr _narrow( CORBA::Object_ptr obj );
917 static Verkaeufer_ptr _narrow( CORBA::AbstractBase_ptr obj );
918 static Verkaeufer_ptr _duplicate( Verkaeufer_ptr _obj )
919 {
920 CORBA::Object::_duplicate (_obj);
921 return _obj;
922 }
923
924 static Verkaeufer_ptr _nil()
925 {
926 return 0;
927 }
928
929 virtual void *_narrow_helper( const char *repoid );
930
931 virtual void connect_handelsplatz( VersteigerungsFabrik_ptr conxn ) = 0;
932 virtual VersteigerungsFabrik_ptr disconnect_handelsplatz() = 0;
933 virtual VersteigerungsFabrik_ptr get_connection_handelsplatz() = 0;
934 virtual KaufConsumer_ptr get_consumer_zuschlag() = 0;
935
936 protected:
937 Verkaeufer() {};
938 private:
939 Verkaeufer( const Verkaeufer& );
940 void operator=( const Verkaeufer& );
941 };
942
943
944 class Verkaeufer_stub:
945 virtual public Verkaeufer,
946 virtual public ::Components::CCMObject_stub
{
947 public:
948 virtual ~Verkaeufer_stub();
949 void connect_handelsplatz( VersteigerungsFabrik_ptr conxn );
950 VersteigerungsFabrik_ptr disconnect_handelsplatz();
951 VersteigerungsFabrik_ptr get_connection_handelsplatz();
952 KaufConsumer_ptr get_consumer_zuschlag();
953
954 private:
955 void operator=( const Verkaeufer_stub& );
956 };
957
958 #ifndef MICO_CONF_NO_POA
959
960 class Verkaeufer_stub_clp :
961 virtual public Verkaeufer_stub,
962 virtual public ::Components::CCMObject_stub_clp
{
963 public:
964 Verkaeufer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
965 virtual ~Verkaeufer_stub_clp ();
966 void connect_handelsplatz( VersteigerungsFabrik_ptr conxn );
967 VersteigerungsFabrik_ptr disconnect_handelsplatz();
968 VersteigerungsFabrik_ptr get_connection_handelsplatz();
969 KaufConsumer_ptr get_consumer_zuschlag();
970
971 protected:
972 Verkaeufer_stub_clp ();
973 private:
974 void operator=( const Verkaeufer_stub_clp & );
975 };
976
977 #endif // MICO_CONF_NO_POA
978
979 class Kauf;
980 typedef Kauf *Kauf_ptr;
981 typedef Kauf_ptr KaufRef;
982 typedef ValueVar< Kauf > Kauf_var;
983 typedef ValueOut< Kauf > Kauf_out;
984
985
986
987
988 class CCM_Verkaeufer :
989 virtual public ::Components::EnterpriseComponent
{
990 public:
991 virtual ~CCM_Verkaeufer();
992
993 #ifdef HAVE_TYPEDEF_OVERLOAD
994 typedef CCM_Verkaeufer_ptr _ptr_type;
995 typedef CCM_Verkaeufer_var _var_type;
996 #endif
997
998 static CCM_Verkaeufer_ptr _narrow( CORBA::Object_ptr obj );
999 static CCM_Verkaeufer_ptr _narrow( CORBA::AbstractBase_ptr obj );
1000 static CCM_Verkaeufer_ptr _duplicate( CCM_Verkaeufer_ptr _obj )
1001 {
1002 CORBA::Object::_duplicate (_obj);
1003 return _obj;
1004 }
1005
1006 static CCM_Verkaeufer_ptr _nil()
1007 {
1008 return 0;
1009 }
1010
1011 virtual void *_narrow_helper( const char *repoid );
1012
1013 virtual void push_zuschlag( Kauf* conxn ) = 0;
1014
1015 protected:
1016 CCM_Verkaeufer() {};
1017 private:
1018 CCM_Verkaeufer( const CCM_Verkaeufer& );
1019 void operator=( const CCM_Verkaeufer& );
1020 };
1021
1022
1023
1024
1025
1026 class CCM_Verkaeufer_Executor :
1027 virtual public ::Components::EnterpriseComponent
{
1028 public:
1029 virtual ~CCM_Verkaeufer_Executor();
1030
1031 #ifdef HAVE_TYPEDEF_OVERLOAD
1032 typedef CCM_Verkaeufer_Executor_ptr _ptr_type;
1033 typedef CCM_Verkaeufer_Executor_var _var_type;
1034 #endif
1035
1036 static CCM_Verkaeufer_Executor_ptr _narrow( CORBA::Object_ptr obj );
1037 static CCM_Verkaeufer_Executor_ptr _narrow( CORBA::AbstractBase_ptr obj );
1038 static CCM_Verkaeufer_Executor_ptr _duplicate( CCM_Verkaeufer_Executor_ptr _obj )
1039 {
1040 CORBA::Object::_duplicate (_obj);
1041 return _obj;
1042 }
1043
1044 static CCM_Verkaeufer_Executor_ptr _nil()
1045 {
1046 return 0;
1047 }
1048
1049 virtual void *_narrow_helper( const char *repoid );
1050
1051 protected:
1052 CCM_Verkaeufer_Executor() {};
1053 private:
1054 CCM_Verkaeufer_Executor( const CCM_Verkaeufer_Executor& );
1055 void operator=( const CCM_Verkaeufer_Executor& );
1056 };
1057
1058
1059
1060
1061
1062 class CCM_Verkaeufer_Context :
1063 virtual public ::Components::SessionContext
{
1064 public:
1065 virtual ~CCM_Verkaeufer_Context();
1066
1067 #ifdef HAVE_TYPEDEF_OVERLOAD
1068 typedef CCM_Verkaeufer_Context_ptr _ptr_type;
1069 typedef CCM_Verkaeufer_Context_var _var_type;
1070 #endif
1071
1072 static CCM_Verkaeufer_Context_ptr _narrow( CORBA::Object_ptr obj );
1073 static CCM_Verkaeufer_Context_ptr _narrow( CORBA::AbstractBase_ptr obj );
1074 static CCM_Verkaeufer_Context_ptr _duplicate( CCM_Verkaeufer_Context_ptr _obj )
1075 {
1076 CORBA::Object::_duplicate (_obj);
1077 return _obj;
1078 }
1079
1080 static CCM_Verkaeufer_Context_ptr _nil()
1081 {
1082 return 0;
1083 }
1084
1085 virtual void *_narrow_helper( const char *repoid );
1086
1087 virtual VersteigerungsFabrik_ptr get_connection_handelsplatz() = 0;
1088
1089 protected:
1090 CCM_Verkaeufer_Context() {};
1091 private:
1092 CCM_Verkaeufer_Context( const CCM_Verkaeufer_Context& );
1093 void operator=( const CCM_Verkaeufer_Context& );
1094 };
1095
1096
1097
1098
1099
1100 class VersteigerungsFabrik :
1101 virtual public CORBA::Object
{
1102 public:
1103 virtual ~VersteigerungsFabrik();
1104
1105 #ifdef HAVE_TYPEDEF_OVERLOAD
1106 typedef VersteigerungsFabrik_ptr _ptr_type;
1107 typedef VersteigerungsFabrik_var _var_type;
1108 #endif
1109
1110 static VersteigerungsFabrik_ptr _narrow( CORBA::Object_ptr obj );
1111 static VersteigerungsFabrik_ptr _narrow( CORBA::AbstractBase_ptr obj );
1112 static VersteigerungsFabrik_ptr _duplicate( VersteigerungsFabrik_ptr _obj )
1113 {
1114 CORBA::Object::_duplicate (_obj);
1115 return _obj;
1116 }
1117
1118 static VersteigerungsFabrik_ptr _nil()
1119 {
1120 return 0;
1121 }
1122
1123 virtual void *_narrow_helper( const char *repoid );
1124
1125 virtual Versteigerung_ptr neue_auktion( const char* name, CORBA::Long minimalgebot, Verkaeufer_ptr besitzer ) = 0;
1126
1127 protected:
1128 VersteigerungsFabrik() {};
1129 private:
1130 VersteigerungsFabrik( const VersteigerungsFabrik& );
1131 void operator=( const VersteigerungsFabrik& );
1132 };
1133
1134
1135 class VersteigerungsFabrik_stub:
1136 virtual public VersteigerungsFabrik
{
1137 public:
1138 virtual ~VersteigerungsFabrik_stub();
1139 Versteigerung_ptr neue_auktion( const char* name, CORBA::Long minimalgebot, Verkaeufer_ptr besitzer );
1140
1141 private:
1142 void operator=( const VersteigerungsFabrik_stub& );
1143 };
1144
1145 #ifndef MICO_CONF_NO_POA
1146
1147 class VersteigerungsFabrik_stub_clp :
1148 virtual public VersteigerungsFabrik_stub,
1149 virtual public PortableServer::StubBase
{
1150 public:
1151 VersteigerungsFabrik_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1152 virtual ~VersteigerungsFabrik_stub_clp ();
1153 Versteigerung_ptr neue_auktion( const char* name, CORBA::Long minimalgebot, Verkaeufer_ptr besitzer );
1154
1155 protected:
1156 VersteigerungsFabrik_stub_clp ();
1157 private:
1158 void operator=( const VersteigerungsFabrik_stub_clp & );
1159 };
1160
1161 #endif // MICO_CONF_NO_POA
1162
1163
1164
1165
1166 class CCM_VersteigerungsFabrik :
1167 virtual public CORBA::LocalObject,
1168 virtual public ::Auktion::VersteigerungsFabrik
{
1169 public:
1170 virtual ~CCM_VersteigerungsFabrik();
1171
1172 #ifdef HAVE_TYPEDEF_OVERLOAD
1173 typedef CCM_VersteigerungsFabrik_ptr _ptr_type;
1174 typedef CCM_VersteigerungsFabrik_var _var_type;
1175 #endif
1176
1177 static CCM_VersteigerungsFabrik_ptr _narrow( CORBA::Object_ptr obj );
1178 static CCM_VersteigerungsFabrik_ptr _narrow( CORBA::AbstractBase_ptr obj );
1179 static CCM_VersteigerungsFabrik_ptr _duplicate( CCM_VersteigerungsFabrik_ptr _obj )
1180 {
1181 CORBA::Object::_duplicate (_obj);
1182 return _obj;
1183 }
1184
1185 static CCM_VersteigerungsFabrik_ptr _nil()
1186 {
1187 return 0;
1188 }
1189
1190 virtual void *_narrow_helper( const char *repoid );
1191
1192 protected:
1193 CCM_VersteigerungsFabrik() {};
1194 private:
1195 CCM_VersteigerungsFabrik( const CCM_VersteigerungsFabrik& );
1196 void operator=( const CCM_VersteigerungsFabrik& );
1197 };
1198
1199
1200
1201
1202 class Kauf :
1203 virtual public ::Auktion::Gebot
{
1204 public:
1205 static Kauf* _downcast (CORBA::ValueBase *);
1206 static Kauf* _downcast (CORBA::AbstractBase *);
1207
1208 virtual void kaeufer( Kaeufer_ptr _p ) = 0;
1209 virtual Kaeufer_ptr kaeufer() const = 0;
1210
1211
1212 public:
1213 CORBA::ValueBase * _copy_value ();
1214 CORBA::ValueDef_ptr get_value_def ();
1215 virtual void * _narrow_helper (const char *);
1216 void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
1217 void _marshal_members (CORBA::DataEncoder &);
1218 CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);
1219
1220 protected:
1221 Kauf ();
1222 virtual ~Kauf ();
1223 void _copy_members (const Kauf&);
1224
1225 private:
1226 Kauf (const Kauf &);
1227 void operator= (const Kauf &);
1228 };
1229
1230
1231
1232
1233 class KaufConsumer :
1234 virtual public ::Components::EventConsumerBase
{
1235 public:
1236 virtual ~KaufConsumer();
1237
1238 #ifdef HAVE_TYPEDEF_OVERLOAD
1239 typedef KaufConsumer_ptr _ptr_type;
1240 typedef KaufConsumer_var _var_type;
1241 #endif
1242
1243 static KaufConsumer_ptr _narrow( CORBA::Object_ptr obj );
1244 static KaufConsumer_ptr _narrow( CORBA::AbstractBase_ptr obj );
1245 static KaufConsumer_ptr _duplicate( KaufConsumer_ptr _obj )
1246 {
1247 CORBA::Object::_duplicate (_obj);
1248 return _obj;
1249 }
1250
1251 static KaufConsumer_ptr _nil()
1252 {
1253 return 0;
1254 }
1255
1256 virtual void *_narrow_helper( const char *repoid );
1257
1258 virtual void push_Kauf( Kauf* event ) = 0;
1259
1260 protected:
1261 KaufConsumer() {};
1262 private:
1263 KaufConsumer( const KaufConsumer& );
1264 void operator=( const KaufConsumer& );
1265 };
1266
1267
1268 class KaufConsumer_stub:
1269 virtual public KaufConsumer,
1270 virtual public ::Components::EventConsumerBase_stub
{
1271 public:
1272 virtual ~KaufConsumer_stub();
1273 void push_Kauf( Kauf* event );
1274
1275 private:
1276 void operator=( const KaufConsumer_stub& );
1277 };
1278
1279 #ifndef MICO_CONF_NO_POA
1280
1281 class KaufConsumer_stub_clp :
1282 virtual public KaufConsumer_stub,
1283 virtual public ::Components::EventConsumerBase_stub_clp
{
1284 public:
1285 KaufConsumer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1286 virtual ~KaufConsumer_stub_clp ();
1287 void push_Kauf( Kauf* event );
1288
1289 protected:
1290 KaufConsumer_stub_clp ();
1291 private:
1292 void operator=( const KaufConsumer_stub_clp & );
1293 };
1294
1295 #endif // MICO_CONF_NO_POA
1296
1297
1298
1299
1300 class CCM_KaufConsumer :
1301 virtual public CORBA::LocalObject
{
1302 public:
1303 virtual ~CCM_KaufConsumer();
1304
1305 #ifdef HAVE_TYPEDEF_OVERLOAD
1306 typedef CCM_KaufConsumer_ptr _ptr_type;
1307 typedef CCM_KaufConsumer_var _var_type;
1308 #endif
1309
1310 static CCM_KaufConsumer_ptr _narrow( CORBA::Object_ptr obj );
1311 static CCM_KaufConsumer_ptr _narrow( CORBA::AbstractBase_ptr obj );
1312 static CCM_KaufConsumer_ptr _duplicate( CCM_KaufConsumer_ptr _obj )
1313 {
1314 CORBA::Object::_duplicate (_obj);
1315 return _obj;
1316 }
1317
1318 static CCM_KaufConsumer_ptr _nil()
1319 {
1320 return 0;
1321 }
1322
1323 virtual void *_narrow_helper( const char *repoid );
1324
1325 virtual void push( Kauf* event ) = 0;
1326
1327 protected:
1328 CCM_KaufConsumer() {};
1329 private:
1330 CCM_KaufConsumer( const CCM_KaufConsumer& );
1331 void operator=( const CCM_KaufConsumer& );
1332 };
1333
1334
1335
1336
1337
1338 class Auktionshaus :
1339 virtual public ::Components::CCMObject
{
1340 public:
1341 virtual ~Auktionshaus();
1342
1343 #ifdef HAVE_TYPEDEF_OVERLOAD
1344 typedef Auktionshaus_ptr _ptr_type;
1345 typedef Auktionshaus_var _var_type;
1346 #endif
1347
1348 static Auktionshaus_ptr _narrow( CORBA::Object_ptr obj );
1349 static Auktionshaus_ptr _narrow( CORBA::AbstractBase_ptr obj );
1350 static Auktionshaus_ptr _duplicate( Auktionshaus_ptr _obj )
1351 {
1352 CORBA::Object::_duplicate (_obj);
1353 return _obj;
1354 }
1355
1356 static Auktionshaus_ptr _nil()
1357 {
1358 return 0;
1359 }
1360
1361 virtual void *_narrow_helper( const char *repoid );
1362
1363 virtual VersteigerungsFabrik_ptr provide_auktionen() = 0;
1364 virtual ::Components::Cookie* subscribe_gebote( GebotConsumer_ptr consumer ) = 0;
1365 virtual GebotConsumer_ptr unsubscribe_gebote( ::Components::Cookie* ck ) = 0;
1366
1367 protected:
1368 Auktionshaus() {};
1369 private:
1370 Auktionshaus( const Auktionshaus& );
1371 void operator=( const Auktionshaus& );
1372 };
1373
1374
1375 class Auktionshaus_stub:
1376 virtual public Auktionshaus,
1377 virtual public ::Components::CCMObject_stub
{
1378 public:
1379 virtual ~Auktionshaus_stub();
1380 VersteigerungsFabrik_ptr provide_auktionen();
1381 ::Components::Cookie* subscribe_gebote( GebotConsumer_ptr consumer );
1382 GebotConsumer_ptr unsubscribe_gebote( ::Components::Cookie* ck );
1383
1384 private:
1385 void operator=( const Auktionshaus_stub& );
1386 };
1387
1388 #ifndef MICO_CONF_NO_POA
1389
1390 class Auktionshaus_stub_clp :
1391 virtual public Auktionshaus_stub,
1392 virtual public ::Components::CCMObject_stub_clp
{
1393 public:
1394 Auktionshaus_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1395 virtual ~Auktionshaus_stub_clp ();
1396 VersteigerungsFabrik_ptr provide_auktionen();
1397 ::Components::Cookie* subscribe_gebote( GebotConsumer_ptr consumer );
1398 GebotConsumer_ptr unsubscribe_gebote( ::Components::Cookie* ck );
1399
1400 protected:
1401 Auktionshaus_stub_clp ();
1402 private:
1403 void operator=( const Auktionshaus_stub_clp & );
1404 };
1405
1406 #endif // MICO_CONF_NO_POA
1407
1408
1409
1410
1411 class CCM_Auktionshaus :
1412 virtual public ::Components::EnterpriseComponent
{
1413 public:
1414 virtual ~CCM_Auktionshaus();
1415
1416 #ifdef HAVE_TYPEDEF_OVERLOAD
1417 typedef CCM_Auktionshaus_ptr _ptr_type;
1418 typedef CCM_Auktionshaus_var _var_type;
1419 #endif
1420
1421 static CCM_Auktionshaus_ptr _narrow( CORBA::Object_ptr obj );
1422 static CCM_Auktionshaus_ptr _narrow( CORBA::AbstractBase_ptr obj );
1423 static CCM_Auktionshaus_ptr _duplicate( CCM_Auktionshaus_ptr _obj )
1424 {
1425 CORBA::Object::_duplicate (_obj);
1426 return _obj;
1427 }
1428
1429 static CCM_Auktionshaus_ptr _nil()
1430 {
1431 return 0;
1432 }
1433
1434 virtual void *_narrow_helper( const char *repoid );
1435
1436 virtual CCM_VersteigerungsFabrik_ptr get_auktionen() = 0;
1437
1438 protected:
1439 CCM_Auktionshaus() {};
1440 private:
1441 CCM_Auktionshaus( const CCM_Auktionshaus& );
1442 void operator=( const CCM_Auktionshaus& );
1443 };
1444
1445
1446
1447
1448
1449 class CCM_Auktionshaus_Executor :
1450 virtual public ::Components::EnterpriseComponent
{
1451 public:
1452 virtual ~CCM_Auktionshaus_Executor();
1453
1454 #ifdef HAVE_TYPEDEF_OVERLOAD
1455 typedef CCM_Auktionshaus_Executor_ptr _ptr_type;
1456 typedef CCM_Auktionshaus_Executor_var _var_type;
1457 #endif
1458
1459 static CCM_Auktionshaus_Executor_ptr _narrow( CORBA::Object_ptr obj );
1460 static CCM_Auktionshaus_Executor_ptr _narrow( CORBA::AbstractBase_ptr obj );
1461 static CCM_Auktionshaus_Executor_ptr _duplicate( CCM_Auktionshaus_Executor_ptr _obj )
1462 {
1463 CORBA::Object::_duplicate (_obj);
1464 return _obj;
1465 }
1466
1467 static CCM_Auktionshaus_Executor_ptr _nil()
1468 {
1469 return 0;
1470 }
1471
1472 virtual void *_narrow_helper( const char *repoid );
1473
1474 protected:
1475 CCM_Auktionshaus_Executor() {};
1476 private:
1477 CCM_Auktionshaus_Executor( const CCM_Auktionshaus_Executor& );
1478 void operator=( const CCM_Auktionshaus_Executor& );
1479 };
1480
1481
1482
1483
1484
1485 class CCM_Auktionshaus_Context :
1486 virtual public ::Components::SessionContext
{
1487 public:
1488 virtual ~CCM_Auktionshaus_Context();
1489
1490 #ifdef HAVE_TYPEDEF_OVERLOAD
1491 typedef CCM_Auktionshaus_Context_ptr _ptr_type;
1492 typedef CCM_Auktionshaus_Context_var _var_type;
1493 #endif
1494
1495 static CCM_Auktionshaus_Context_ptr _narrow( CORBA::Object_ptr obj );
1496 static CCM_Auktionshaus_Context_ptr _narrow( CORBA::AbstractBase_ptr obj );
1497 static CCM_Auktionshaus_Context_ptr _duplicate( CCM_Auktionshaus_Context_ptr _obj )
1498 {
1499 CORBA::Object::_duplicate (_obj);
1500 return _obj;
1501 }
1502
1503 static CCM_Auktionshaus_Context_ptr _nil()
1504 {
1505 return 0;
1506 }
1507
1508 virtual void *_narrow_helper( const char *repoid );
1509
1510 virtual void push_gebote( Gebot* event ) = 0;
1511
1512 protected:
1513 CCM_Auktionshaus_Context() {};
1514 private:
1515 CCM_Auktionshaus_Context( const CCM_Auktionshaus_Context& );
1516 void operator=( const CCM_Auktionshaus_Context& );
1517 };
1518
1519
1520
1521
1522
1523 class WeltExplicit :
1524 virtual public ::Components::CCMHome
{
1525 public:
1526 virtual ~WeltExplicit();
1527
1528 #ifdef HAVE_TYPEDEF_OVERLOAD
1529 typedef WeltExplicit_ptr _ptr_type;
1530 typedef WeltExplicit_var _var_type;
1531 #endif
1532
1533 static WeltExplicit_ptr _narrow( CORBA::Object_ptr obj );
1534 static WeltExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
1535 static WeltExplicit_ptr _duplicate( WeltExplicit_ptr _obj )
1536 {
1537 CORBA::Object::_duplicate (_obj);
1538 return _obj;
1539 }
1540
1541 static WeltExplicit_ptr _nil()
1542 {
1543 return 0;
1544 }
1545
1546 virtual void *_narrow_helper( const char *repoid );
1547
1548 protected:
1549 WeltExplicit() {};
1550 private:
1551 WeltExplicit( const WeltExplicit& );
1552 void operator=( const WeltExplicit& );
1553 };
1554
1555
1556 class WeltExplicit_stub:
1557 virtual public WeltExplicit,
1558 virtual public ::Components::CCMHome_stub
{
1559 public:
1560 virtual ~WeltExplicit_stub();
1561 private:
1562 void operator=( const WeltExplicit_stub& );
1563 };
1564
1565 #ifndef MICO_CONF_NO_POA
1566
1567 class WeltExplicit_stub_clp :
1568 virtual public WeltExplicit_stub,
1569 virtual public ::Components::CCMHome_stub_clp
{
1570 public:
1571 WeltExplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1572 virtual ~WeltExplicit_stub_clp ();
1573 protected:
1574 WeltExplicit_stub_clp ();
1575 private:
1576 void operator=( const WeltExplicit_stub_clp & );
1577 };
1578
1579 #endif // MICO_CONF_NO_POA
1580
1581
1582
1583
1584 class WeltImplicit :
1585 virtual public ::Components::KeylessCCMHome
{
1586 public:
1587 virtual ~WeltImplicit();
1588
1589 #ifdef HAVE_TYPEDEF_OVERLOAD
1590 typedef WeltImplicit_ptr _ptr_type;
1591 typedef WeltImplicit_var _var_type;
1592 #endif
1593
1594 static WeltImplicit_ptr _narrow( CORBA::Object_ptr obj );
1595 static WeltImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
1596 static WeltImplicit_ptr _duplicate( WeltImplicit_ptr _obj )
1597 {
1598 CORBA::Object::_duplicate (_obj);
1599 return _obj;
1600 }
1601
1602 static WeltImplicit_ptr _nil()
1603 {
1604 return 0;
1605 }
1606
1607 virtual void *_narrow_helper( const char *repoid );
1608
1609 virtual Auktionshaus_ptr create() = 0;
1610
1611 protected:
1612 WeltImplicit() {};
1613 private:
1614 WeltImplicit( const WeltImplicit& );
1615 void operator=( const WeltImplicit& );
1616 };
1617
1618
1619 class WeltImplicit_stub:
1620 virtual public WeltImplicit,
1621 virtual public ::Components::KeylessCCMHome_stub
{
1622 public:
1623 virtual ~WeltImplicit_stub();
1624 Auktionshaus_ptr create();
1625
1626 private:
1627 void operator=( const WeltImplicit_stub& );
1628 };
1629
1630 #ifndef MICO_CONF_NO_POA
1631
1632 class WeltImplicit_stub_clp :
1633 virtual public WeltImplicit_stub,
1634 virtual public ::Components::KeylessCCMHome_stub_clp
{
1635 public:
1636 WeltImplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1637 virtual ~WeltImplicit_stub_clp ();
1638 Auktionshaus_ptr create();
1639
1640 protected:
1641 WeltImplicit_stub_clp ();
1642 private:
1643 void operator=( const WeltImplicit_stub_clp & );
1644 };
1645
1646 #endif // MICO_CONF_NO_POA
1647
1648
1649
1650
1651 class Welt :
1652 virtual public ::Auktion::WeltExplicit,
1653 virtual public ::Auktion::WeltImplicit
{
1654 public:
1655 virtual ~Welt();
1656
1657 #ifdef HAVE_TYPEDEF_OVERLOAD
1658 typedef Welt_ptr _ptr_type;
1659 typedef Welt_var _var_type;
1660 #endif
1661
1662 static Welt_ptr _narrow( CORBA::Object_ptr obj );
1663 static Welt_ptr _narrow( CORBA::AbstractBase_ptr obj );
1664 static Welt_ptr _duplicate( Welt_ptr _obj )
1665 {
1666 CORBA::Object::_duplicate (_obj);
1667 return _obj;
1668 }
1669
1670 static Welt_ptr _nil()
1671 {
1672 return 0;
1673 }
1674
1675 virtual void *_narrow_helper( const char *repoid );
1676
1677 protected:
1678 Welt() {};
1679 private:
1680 Welt( const Welt& );
1681 void operator=( const Welt& );
1682 };
1683
1684
1685 class Welt_stub:
1686 virtual public Welt,
1687 virtual public ::Auktion::WeltExplicit_stub,
1688 virtual public ::Auktion::WeltImplicit_stub
{
1689 public:
1690 virtual ~Welt_stub();
1691 private:
1692 void operator=( const Welt_stub& );
1693 };
1694
1695 #ifndef MICO_CONF_NO_POA
1696
1697 class Welt_stub_clp :
1698 virtual public Welt_stub,
1699 virtual public ::Auktion::WeltExplicit_stub_clp,
1700 virtual public ::Auktion::WeltImplicit_stub_clp
{
1701 public:
1702 Welt_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1703 virtual ~Welt_stub_clp ();
1704 protected:
1705 Welt_stub_clp ();
1706 private:
1707 void operator=( const Welt_stub_clp & );
1708 };
1709
1710 #endif // MICO_CONF_NO_POA
1711
1712
1713
1714
1715 class CCM_WeltExplicit :
1716 virtual public ::Components::HomeExecutorBase
{
1717 public:
1718 virtual ~CCM_WeltExplicit();
1719
1720 #ifdef HAVE_TYPEDEF_OVERLOAD
1721 typedef CCM_WeltExplicit_ptr _ptr_type;
1722 typedef CCM_WeltExplicit_var _var_type;
1723 #endif
1724
1725 static CCM_WeltExplicit_ptr _narrow( CORBA::Object_ptr obj );
1726 static CCM_WeltExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
1727 static CCM_WeltExplicit_ptr _duplicate( CCM_WeltExplicit_ptr _obj )
1728 {
1729 CORBA::Object::_duplicate (_obj);
1730 return _obj;
1731 }
1732
1733 static CCM_WeltExplicit_ptr _nil()
1734 {
1735 return 0;
1736 }
1737
1738 virtual void *_narrow_helper( const char *repoid );
1739
1740 protected:
1741 CCM_WeltExplicit() {};
1742 private:
1743 CCM_WeltExplicit( const CCM_WeltExplicit& );
1744 void operator=( const CCM_WeltExplicit& );
1745 };
1746
1747
1748
1749
1750
1751 class CCM_WeltImplicit :
1752 virtual public CORBA::LocalObject
{
1753 public:
1754 virtual ~CCM_WeltImplicit();
1755
1756 #ifdef HAVE_TYPEDEF_OVERLOAD
1757 typedef CCM_WeltImplicit_ptr _ptr_type;
1758 typedef CCM_WeltImplicit_var _var_type;
1759 #endif
1760
1761 static CCM_WeltImplicit_ptr _narrow( CORBA::Object_ptr obj );
1762 static CCM_WeltImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
1763 static CCM_WeltImplicit_ptr _duplicate( CCM_WeltImplicit_ptr _obj )
1764 {
1765 CORBA::Object::_duplicate (_obj);
1766 return _obj;
1767 }
1768
1769 static CCM_WeltImplicit_ptr _nil()
1770 {
1771 return 0;
1772 }
1773
1774 virtual void *_narrow_helper( const char *repoid );
1775
1776 virtual ::Components::EnterpriseComponent_ptr create() = 0;
1777
1778 protected:
1779 CCM_WeltImplicit() {};
1780 private:
1781 CCM_WeltImplicit( const CCM_WeltImplicit& );
1782 void operator=( const CCM_WeltImplicit& );
1783 };
1784
1785
1786
1787
1788
1789 class CCM_Welt :
1790 virtual public ::Auktion::CCM_WeltExplicit,
1791 virtual public ::Auktion::CCM_WeltImplicit
{
1792 public:
1793 virtual ~CCM_Welt();
1794
1795 #ifdef HAVE_TYPEDEF_OVERLOAD
1796 typedef CCM_Welt_ptr _ptr_type;
1797 typedef CCM_Welt_var _var_type;
1798 #endif
1799
1800 static CCM_Welt_ptr _narrow( CORBA::Object_ptr obj );
1801 static CCM_Welt_ptr _narrow( CORBA::AbstractBase_ptr obj );
1802 static CCM_Welt_ptr _duplicate( CCM_Welt_ptr _obj )
1803 {
1804 CORBA::Object::_duplicate (_obj);
1805 return _obj;
1806 }
1807
1808 static CCM_Welt_ptr _nil()
1809 {
1810 return 0;
1811 }
1812
1813 virtual void *_narrow_helper( const char *repoid );
1814
1815 protected:
1816 CCM_Welt() {};
1817 private:
1818 CCM_Welt( const CCM_Welt& );
1819 void operator=( const CCM_Welt& );
1820 };
1821
1822
1823
1824
1825
1826 class ProduktFilter :
1827 virtual public ::Components::CCMObject
{
1828 public:
1829 virtual ~ProduktFilter();
1830
1831 #ifdef HAVE_TYPEDEF_OVERLOAD
1832 typedef ProduktFilter_ptr _ptr_type;
1833 typedef ProduktFilter_var _var_type;
1834 #endif
1835
1836 static ProduktFilter_ptr _narrow( CORBA::Object_ptr obj );
1837 static ProduktFilter_ptr _narrow( CORBA::AbstractBase_ptr obj );
1838 static ProduktFilter_ptr _duplicate( ProduktFilter_ptr _obj )
1839 {
1840 CORBA::Object::_duplicate (_obj);
1841 return _obj;
1842 }
1843
1844 static ProduktFilter_ptr _nil()
1845 {
1846 return 0;
1847 }
1848
1849 virtual void *_narrow_helper( const char *repoid );
1850
1851 virtual char* interessanter_gegenstand() = 0;
1852 virtual void interessanter_gegenstand( const char* value ) = 0;
1853
1854 virtual GebotConsumer_ptr get_consumer_eingehende_gebote() = 0;
1855 virtual ::Components::Cookie* subscribe_interessante_gebote( GebotConsumer_ptr consumer ) = 0;
1856 virtual GebotConsumer_ptr unsubscribe_interessante_gebote( ::Components::Cookie* ck ) = 0;
1857
1858 protected:
1859 ProduktFilter() {};
1860 private:
1861 ProduktFilter( const ProduktFilter& );
1862 void operator=( const ProduktFilter& );
1863 };
1864
1865
1866 class ProduktFilter_stub:
1867 virtual public ProduktFilter,
1868 virtual public ::Components::CCMObject_stub
{
1869 public:
1870 virtual ~ProduktFilter_stub();
1871 char* interessanter_gegenstand();
1872 void interessanter_gegenstand( const char* value );
1873
1874 GebotConsumer_ptr get_consumer_eingehende_gebote();
1875 ::Components::Cookie* subscribe_interessante_gebote( GebotConsumer_ptr consumer );
1876 GebotConsumer_ptr unsubscribe_interessante_gebote( ::Components::Cookie* ck );
1877
1878 private:
1879 void operator=( const ProduktFilter_stub& );
1880 };
1881
1882 #ifndef MICO_CONF_NO_POA
1883
1884 class ProduktFilter_stub_clp :
1885 virtual public ProduktFilter_stub,
1886 virtual public ::Components::CCMObject_stub_clp
{
1887 public:
1888 ProduktFilter_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
1889 virtual ~ProduktFilter_stub_clp ();
1890 char* interessanter_gegenstand();
1891 void interessanter_gegenstand( const char* value );
1892
1893 GebotConsumer_ptr get_consumer_eingehende_gebote();
1894 ::Components::Cookie* subscribe_interessante_gebote( GebotConsumer_ptr consumer );
1895 GebotConsumer_ptr unsubscribe_interessante_gebote( ::Components::Cookie* ck );
1896
1897 protected:
1898 ProduktFilter_stub_clp ();
1899 private:
1900 void operator=( const ProduktFilter_stub_clp & );
1901 };
1902
1903 #endif // MICO_CONF_NO_POA
1904
1905
1906
1907
1908 class CCM_ProduktFilter :
1909 virtual public ::Components::EnterpriseComponent
{
1910 public:
1911 virtual ~CCM_ProduktFilter();
1912
1913 #ifdef HAVE_TYPEDEF_OVERLOAD
1914 typedef CCM_ProduktFilter_ptr _ptr_type;
1915 typedef CCM_ProduktFilter_var _var_type;
1916 #endif
1917
1918 static CCM_ProduktFilter_ptr _narrow( CORBA::Object_ptr obj );
1919 static CCM_ProduktFilter_ptr _narrow( CORBA::AbstractBase_ptr obj );
1920 static CCM_ProduktFilter_ptr _duplicate( CCM_ProduktFilter_ptr _obj )
1921 {
1922 CORBA::Object::_duplicate (_obj);
1923 return _obj;
1924 }
1925
1926 static CCM_ProduktFilter_ptr _nil()
1927 {
1928 return 0;
1929 }
1930
1931 virtual void *_narrow_helper( const char *repoid );
1932
1933 virtual char* interessanter_gegenstand() = 0;
1934 virtual void interessanter_gegenstand( const char* value ) = 0;
1935
1936 virtual void push_eingehende_gebote( Gebot* conxn ) = 0;
1937
1938 protected:
1939 CCM_ProduktFilter() {};
1940 private:
1941 CCM_ProduktFilter( const CCM_ProduktFilter& );
1942 void operator=( const CCM_ProduktFilter& );
1943 };
1944
1945
1946
1947
1948
1949 class CCM_ProduktFilter_Executor :
1950 virtual public ::Components::EnterpriseComponent
{
1951 public:
1952 virtual ~CCM_ProduktFilter_Executor();
1953
1954 #ifdef HAVE_TYPEDEF_OVERLOAD
1955 typedef CCM_ProduktFilter_Executor_ptr _ptr_type;
1956 typedef CCM_ProduktFilter_Executor_var _var_type;
1957 #endif
1958
1959 static CCM_ProduktFilter_Executor_ptr _narrow( CORBA::Object_ptr obj );
1960 static CCM_ProduktFilter_Executor_ptr _narrow( CORBA::AbstractBase_ptr obj );
1961 static CCM_ProduktFilter_Executor_ptr _duplicate( CCM_ProduktFilter_Executor_ptr _obj )
1962 {
1963 CORBA::Object::_duplicate (_obj);
1964 return _obj;
1965 }
1966
1967 static CCM_ProduktFilter_Executor_ptr _nil()
1968 {
1969 return 0;
1970 }
1971
1972 virtual void *_narrow_helper( const char *repoid );
1973
1974 virtual char* interessanter_gegenstand() = 0;
1975 virtual void interessanter_gegenstand( const char* value ) = 0;
1976
1977 protected:
1978 CCM_ProduktFilter_Executor() {};
1979 private:
1980 CCM_ProduktFilter_Executor( const CCM_ProduktFilter_Executor& );
1981 void operator=( const CCM_ProduktFilter_Executor& );
1982 };
1983
1984
1985
1986
1987
1988 class CCM_ProduktFilter_Context :
1989 virtual public ::Components::SessionContext
{
1990 public:
1991 virtual ~CCM_ProduktFilter_Context();
1992
1993 #ifdef HAVE_TYPEDEF_OVERLOAD
1994 typedef CCM_ProduktFilter_Context_ptr _ptr_type;
1995 typedef CCM_ProduktFilter_Context_var _var_type;
1996 #endif
1997
1998 static CCM_ProduktFilter_Context_ptr _narrow( CORBA::Object_ptr obj );
1999 static CCM_ProduktFilter_Context_ptr _narrow( CORBA::AbstractBase_ptr obj );
2000 static CCM_ProduktFilter_Context_ptr _duplicate( CCM_ProduktFilter_Context_ptr _obj )
2001 {
2002 CORBA::Object::_duplicate (_obj);
2003 return _obj;
2004 }
2005
2006 static CCM_ProduktFilter_Context_ptr _nil()
2007 {
2008 return 0;
2009 }
2010
2011 virtual void *_narrow_helper( const char *repoid );
2012
2013 virtual void push_interessante_gebote( Gebot* event ) = 0;
2014
2015 protected:
2016 CCM_ProduktFilter_Context() {};
2017 private:
2018 CCM_ProduktFilter_Context( const CCM_ProduktFilter_Context& );
2019 void operator=( const CCM_ProduktFilter_Context& );
2020 };
2021
2022
2023
2024
2025
2026 class FilterHomeExplicit :
2027 virtual public ::Components::CCMHome
{
2028 public:
2029 virtual ~FilterHomeExplicit();
2030
2031 #ifdef HAVE_TYPEDEF_OVERLOAD
2032 typedef FilterHomeExplicit_ptr _ptr_type;
2033 typedef FilterHomeExplicit_var _var_type;
2034 #endif
2035
2036 static FilterHomeExplicit_ptr _narrow( CORBA::Object_ptr obj );
2037 static FilterHomeExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
2038 static FilterHomeExplicit_ptr _duplicate( FilterHomeExplicit_ptr _obj )
2039 {
2040 CORBA::Object::_duplicate (_obj);
2041 return _obj;
2042 }
2043
2044 static FilterHomeExplicit_ptr _nil()
2045 {
2046 return 0;
2047 }
2048
2049 virtual void *_narrow_helper( const char *repoid );
2050
2051 virtual ProduktFilter_ptr new_filter( const char* gegenstand ) = 0;
2052
2053 protected:
2054 FilterHomeExplicit() {};
2055 private:
2056 FilterHomeExplicit( const FilterHomeExplicit& );
2057 void operator=( const FilterHomeExplicit& );
2058 };
2059
2060
2061 class FilterHomeExplicit_stub:
2062 virtual public FilterHomeExplicit,
2063 virtual public ::Components::CCMHome_stub
{
2064 public:
2065 virtual ~FilterHomeExplicit_stub();
2066 ProduktFilter_ptr new_filter( const char* gegenstand );
2067
2068 private:
2069 void operator=( const FilterHomeExplicit_stub& );
2070 };
2071
2072 #ifndef MICO_CONF_NO_POA
2073
2074 class FilterHomeExplicit_stub_clp :
2075 virtual public FilterHomeExplicit_stub,
2076 virtual public ::Components::CCMHome_stub_clp
{
2077 public:
2078 FilterHomeExplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2079 virtual ~FilterHomeExplicit_stub_clp ();
2080 ProduktFilter_ptr new_filter( const char* gegenstand );
2081
2082 protected:
2083 FilterHomeExplicit_stub_clp ();
2084 private:
2085 void operator=( const FilterHomeExplicit_stub_clp & );
2086 };
2087
2088 #endif // MICO_CONF_NO_POA
2089
2090
2091
2092
2093 class FilterHomeImplicit :
2094 virtual public ::Components::KeylessCCMHome
{
2095 public:
2096 virtual ~FilterHomeImplicit();
2097
2098 #ifdef HAVE_TYPEDEF_OVERLOAD
2099 typedef FilterHomeImplicit_ptr _ptr_type;
2100 typedef FilterHomeImplicit_var _var_type;
2101 #endif
2102
2103 static FilterHomeImplicit_ptr _narrow( CORBA::Object_ptr obj );
2104 static FilterHomeImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
2105 static FilterHomeImplicit_ptr _duplicate( FilterHomeImplicit_ptr _obj )
2106 {
2107 CORBA::Object::_duplicate (_obj);
2108 return _obj;
2109 }
2110
2111 static FilterHomeImplicit_ptr _nil()
2112 {
2113 return 0;
2114 }
2115
2116 virtual void *_narrow_helper( const char *repoid );
2117
2118 virtual ProduktFilter_ptr create() = 0;
2119
2120 protected:
2121 FilterHomeImplicit() {};
2122 private:
2123 FilterHomeImplicit( const FilterHomeImplicit& );
2124 void operator=( const FilterHomeImplicit& );
2125 };
2126
2127
2128 class FilterHomeImplicit_stub:
2129 virtual public FilterHomeImplicit,
2130 virtual public ::Components::KeylessCCMHome_stub
{
2131 public:
2132 virtual ~FilterHomeImplicit_stub();
2133 ProduktFilter_ptr create();
2134
2135 private:
2136 void operator=( const FilterHomeImplicit_stub& );
2137 };
2138
2139 #ifndef MICO_CONF_NO_POA
2140
2141 class FilterHomeImplicit_stub_clp :
2142 virtual public FilterHomeImplicit_stub,
2143 virtual public ::Components::KeylessCCMHome_stub_clp
{
2144 public:
2145 FilterHomeImplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2146 virtual ~FilterHomeImplicit_stub_clp ();
2147 ProduktFilter_ptr create();
2148
2149 protected:
2150 FilterHomeImplicit_stub_clp ();
2151 private:
2152 void operator=( const FilterHomeImplicit_stub_clp & );
2153 };
2154
2155 #endif // MICO_CONF_NO_POA
2156
2157
2158
2159
2160 class FilterHome :
2161 virtual public ::Auktion::FilterHomeExplicit,
2162 virtual public ::Auktion::FilterHomeImplicit
{
2163 public:
2164 virtual ~FilterHome();
2165
2166 #ifdef HAVE_TYPEDEF_OVERLOAD
2167 typedef FilterHome_ptr _ptr_type;
2168 typedef FilterHome_var _var_type;
2169 #endif
2170
2171 static FilterHome_ptr _narrow( CORBA::Object_ptr obj );
2172 static FilterHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
2173 static FilterHome_ptr _duplicate( FilterHome_ptr _obj )
2174 {
2175 CORBA::Object::_duplicate (_obj);
2176 return _obj;
2177 }
2178
2179 static FilterHome_ptr _nil()
2180 {
2181 return 0;
2182 }
2183
2184 virtual void *_narrow_helper( const char *repoid );
2185
2186 protected:
2187 FilterHome() {};
2188 private:
2189 FilterHome( const FilterHome& );
2190 void operator=( const FilterHome& );
2191 };
2192
2193
2194 class FilterHome_stub:
2195 virtual public FilterHome,
2196 virtual public ::Auktion::FilterHomeExplicit_stub,
2197 virtual public ::Auktion::FilterHomeImplicit_stub
{
2198 public:
2199 virtual ~FilterHome_stub();
2200 private:
2201 void operator=( const FilterHome_stub& );
2202 };
2203
2204 #ifndef MICO_CONF_NO_POA
2205
2206 class FilterHome_stub_clp :
2207 virtual public FilterHome_stub,
2208 virtual public ::Auktion::FilterHomeExplicit_stub_clp,
2209 virtual public ::Auktion::FilterHomeImplicit_stub_clp
{
2210 public:
2211 FilterHome_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2212 virtual ~FilterHome_stub_clp ();
2213 protected:
2214 FilterHome_stub_clp ();
2215 private:
2216 void operator=( const FilterHome_stub_clp & );
2217 };
2218
2219 #endif // MICO_CONF_NO_POA
2220
2221
2222
2223
2224 class CCM_FilterHomeExplicit :
2225 virtual public ::Components::HomeExecutorBase
{
2226 public:
2227 virtual ~CCM_FilterHomeExplicit();
2228
2229 #ifdef HAVE_TYPEDEF_OVERLOAD
2230 typedef CCM_FilterHomeExplicit_ptr _ptr_type;
2231 typedef CCM_FilterHomeExplicit_var _var_type;
2232 #endif
2233
2234 static CCM_FilterHomeExplicit_ptr _narrow( CORBA::Object_ptr obj );
2235 static CCM_FilterHomeExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
2236 static CCM_FilterHomeExplicit_ptr _duplicate( CCM_FilterHomeExplicit_ptr _obj )
2237 {
2238 CORBA::Object::_duplicate (_obj);
2239 return _obj;
2240 }
2241
2242 static CCM_FilterHomeExplicit_ptr _nil()
2243 {
2244 return 0;
2245 }
2246
2247 virtual void *_narrow_helper( const char *repoid );
2248
2249 virtual ::Components::EnterpriseComponent_ptr new_filter( const char* gegenstand ) = 0;
2250
2251 protected:
2252 CCM_FilterHomeExplicit() {};
2253 private:
2254 CCM_FilterHomeExplicit( const CCM_FilterHomeExplicit& );
2255 void operator=( const CCM_FilterHomeExplicit& );
2256 };
2257
2258
2259
2260
2261
2262 class CCM_FilterHomeImplicit :
2263 virtual public CORBA::LocalObject
{
2264 public:
2265 virtual ~CCM_FilterHomeImplicit();
2266
2267 #ifdef HAVE_TYPEDEF_OVERLOAD
2268 typedef CCM_FilterHomeImplicit_ptr _ptr_type;
2269 typedef CCM_FilterHomeImplicit_var _var_type;
2270 #endif
2271
2272 static CCM_FilterHomeImplicit_ptr _narrow( CORBA::Object_ptr obj );
2273 static CCM_FilterHomeImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
2274 static CCM_FilterHomeImplicit_ptr _duplicate( CCM_FilterHomeImplicit_ptr _obj )
2275 {
2276 CORBA::Object::_duplicate (_obj);
2277 return _obj;
2278 }
2279
2280 static CCM_FilterHomeImplicit_ptr _nil()
2281 {
2282 return 0;
2283 }
2284
2285 virtual void *_narrow_helper( const char *repoid );
2286
2287 virtual ::Components::EnterpriseComponent_ptr create() = 0;
2288
2289 protected:
2290 CCM_FilterHomeImplicit() {};
2291 private:
2292 CCM_FilterHomeImplicit( const CCM_FilterHomeImplicit& );
2293 void operator=( const CCM_FilterHomeImplicit& );
2294 };
2295
2296
2297
2298
2299
2300 class CCM_FilterHome :
2301 virtual public ::Auktion::CCM_FilterHomeExplicit,
2302 virtual public ::Auktion::CCM_FilterHomeImplicit
{
2303 public:
2304 virtual ~CCM_FilterHome();
2305
2306 #ifdef HAVE_TYPEDEF_OVERLOAD
2307 typedef CCM_FilterHome_ptr _ptr_type;
2308 typedef CCM_FilterHome_var _var_type;
2309 #endif
2310
2311 static CCM_FilterHome_ptr _narrow( CORBA::Object_ptr obj );
2312 static CCM_FilterHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
2313 static CCM_FilterHome_ptr _duplicate( CCM_FilterHome_ptr _obj )
2314 {
2315 CORBA::Object::_duplicate (_obj);
2316 return _obj;
2317 }
2318
2319 static CCM_FilterHome_ptr _nil()
2320 {
2321 return 0;
2322 }
2323
2324 virtual void *_narrow_helper( const char *repoid );
2325
2326 protected:
2327 CCM_FilterHome() {};
2328 private:
2329 CCM_FilterHome( const CCM_FilterHome& );
2330 void operator=( const CCM_FilterHome& );
2331 };
2332
2333
2334
2335
2336
2337 class BieterHomeExplicit :
2338 virtual public ::Components::CCMHome
{
2339 public:
2340 virtual ~BieterHomeExplicit();
2341
2342 #ifdef HAVE_TYPEDEF_OVERLOAD
2343 typedef BieterHomeExplicit_ptr _ptr_type;
2344 typedef BieterHomeExplicit_var _var_type;
2345 #endif
2346
2347 static BieterHomeExplicit_ptr _narrow( CORBA::Object_ptr obj );
2348 static BieterHomeExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
2349 static BieterHomeExplicit_ptr _duplicate( BieterHomeExplicit_ptr _obj )
2350 {
2351 CORBA::Object::_duplicate (_obj);
2352 return _obj;
2353 }
2354
2355 static BieterHomeExplicit_ptr _nil()
2356 {
2357 return 0;
2358 }
2359
2360 virtual void *_narrow_helper( const char *repoid );
2361
2362 protected:
2363 BieterHomeExplicit() {};
2364 private:
2365 BieterHomeExplicit( const BieterHomeExplicit& );
2366 void operator=( const BieterHomeExplicit& );
2367 };
2368
2369
2370 class BieterHomeExplicit_stub:
2371 virtual public BieterHomeExplicit,
2372 virtual public ::Components::CCMHome_stub
{
2373 public:
2374 virtual ~BieterHomeExplicit_stub();
2375 private:
2376 void operator=( const BieterHomeExplicit_stub& );
2377 };
2378
2379 #ifndef MICO_CONF_NO_POA
2380
2381 class BieterHomeExplicit_stub_clp :
2382 virtual public BieterHomeExplicit_stub,
2383 virtual public ::Components::CCMHome_stub_clp
{
2384 public:
2385 BieterHomeExplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2386 virtual ~BieterHomeExplicit_stub_clp ();
2387 protected:
2388 BieterHomeExplicit_stub_clp ();
2389 private:
2390 void operator=( const BieterHomeExplicit_stub_clp & );
2391 };
2392
2393 #endif // MICO_CONF_NO_POA
2394
2395
2396
2397
2398 class BieterHomeImplicit :
2399 virtual public ::Components::KeylessCCMHome
{
2400 public:
2401 virtual ~BieterHomeImplicit();
2402
2403 #ifdef HAVE_TYPEDEF_OVERLOAD
2404 typedef BieterHomeImplicit_ptr _ptr_type;
2405 typedef BieterHomeImplicit_var _var_type;
2406 #endif
2407
2408 static BieterHomeImplicit_ptr _narrow( CORBA::Object_ptr obj );
2409 static BieterHomeImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
2410 static BieterHomeImplicit_ptr _duplicate( BieterHomeImplicit_ptr _obj )
2411 {
2412 CORBA::Object::_duplicate (_obj);
2413 return _obj;
2414 }
2415
2416 static BieterHomeImplicit_ptr _nil()
2417 {
2418 return 0;
2419 }
2420
2421 virtual void *_narrow_helper( const char *repoid );
2422
2423 virtual Bieter_ptr create() = 0;
2424
2425 protected:
2426 BieterHomeImplicit() {};
2427 private:
2428 BieterHomeImplicit( const BieterHomeImplicit& );
2429 void operator=( const BieterHomeImplicit& );
2430 };
2431
2432
2433 class BieterHomeImplicit_stub:
2434 virtual public BieterHomeImplicit,
2435 virtual public ::Components::KeylessCCMHome_stub
{
2436 public:
2437 virtual ~BieterHomeImplicit_stub();
2438 Bieter_ptr create();
2439
2440 private:
2441 void operator=( const BieterHomeImplicit_stub& );
2442 };
2443
2444 #ifndef MICO_CONF_NO_POA
2445
2446 class BieterHomeImplicit_stub_clp :
2447 virtual public BieterHomeImplicit_stub,
2448 virtual public ::Components::KeylessCCMHome_stub_clp
{
2449 public:
2450 BieterHomeImplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2451 virtual ~BieterHomeImplicit_stub_clp ();
2452 Bieter_ptr create();
2453
2454 protected:
2455 BieterHomeImplicit_stub_clp ();
2456 private:
2457 void operator=( const BieterHomeImplicit_stub_clp & );
2458 };
2459
2460 #endif // MICO_CONF_NO_POA
2461
2462
2463
2464
2465 class BieterHome :
2466 virtual public ::Auktion::BieterHomeExplicit,
2467 virtual public ::Auktion::BieterHomeImplicit
{
2468 public:
2469 virtual ~BieterHome();
2470
2471 #ifdef HAVE_TYPEDEF_OVERLOAD
2472 typedef BieterHome_ptr _ptr_type;
2473 typedef BieterHome_var _var_type;
2474 #endif
2475
2476 static BieterHome_ptr _narrow( CORBA::Object_ptr obj );
2477 static BieterHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
2478 static BieterHome_ptr _duplicate( BieterHome_ptr _obj )
2479 {
2480 CORBA::Object::_duplicate (_obj);
2481 return _obj;
2482 }
2483
2484 static BieterHome_ptr _nil()
2485 {
2486 return 0;
2487 }
2488
2489 virtual void *_narrow_helper( const char *repoid );
2490
2491 protected:
2492 BieterHome() {};
2493 private:
2494 BieterHome( const BieterHome& );
2495 void operator=( const BieterHome& );
2496 };
2497
2498
2499 class BieterHome_stub:
2500 virtual public BieterHome,
2501 virtual public ::Auktion::BieterHomeExplicit_stub,
2502 virtual public ::Auktion::BieterHomeImplicit_stub
{
2503 public:
2504 virtual ~BieterHome_stub();
2505 private:
2506 void operator=( const BieterHome_stub& );
2507 };
2508
2509 #ifndef MICO_CONF_NO_POA
2510
2511 class BieterHome_stub_clp :
2512 virtual public BieterHome_stub,
2513 virtual public ::Auktion::BieterHomeExplicit_stub_clp,
2514 virtual public ::Auktion::BieterHomeImplicit_stub_clp
{
2515 public:
2516 BieterHome_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2517 virtual ~BieterHome_stub_clp ();
2518 protected:
2519 BieterHome_stub_clp ();
2520 private:
2521 void operator=( const BieterHome_stub_clp & );
2522 };
2523
2524 #endif // MICO_CONF_NO_POA
2525
2526
2527
2528
2529 class CCM_BieterHomeExplicit :
2530 virtual public ::Components::HomeExecutorBase
{
2531 public:
2532 virtual ~CCM_BieterHomeExplicit();
2533
2534 #ifdef HAVE_TYPEDEF_OVERLOAD
2535 typedef CCM_BieterHomeExplicit_ptr _ptr_type;
2536 typedef CCM_BieterHomeExplicit_var _var_type;
2537 #endif
2538
2539 static CCM_BieterHomeExplicit_ptr _narrow( CORBA::Object_ptr obj );
2540 static CCM_BieterHomeExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
2541 static CCM_BieterHomeExplicit_ptr _duplicate( CCM_BieterHomeExplicit_ptr _obj )
2542 {
2543 CORBA::Object::_duplicate (_obj);
2544 return _obj;
2545 }
2546
2547 static CCM_BieterHomeExplicit_ptr _nil()
2548 {
2549 return 0;
2550 }
2551
2552 virtual void *_narrow_helper( const char *repoid );
2553
2554 protected:
2555 CCM_BieterHomeExplicit() {};
2556 private:
2557 CCM_BieterHomeExplicit( const CCM_BieterHomeExplicit& );
2558 void operator=( const CCM_BieterHomeExplicit& );
2559 };
2560
2561
2562
2563
2564
2565 class CCM_BieterHomeImplicit :
2566 virtual public CORBA::LocalObject
{
2567 public:
2568 virtual ~CCM_BieterHomeImplicit();
2569
2570 #ifdef HAVE_TYPEDEF_OVERLOAD
2571 typedef CCM_BieterHomeImplicit_ptr _ptr_type;
2572 typedef CCM_BieterHomeImplicit_var _var_type;
2573 #endif
2574
2575 static CCM_BieterHomeImplicit_ptr _narrow( CORBA::Object_ptr obj );
2576 static CCM_BieterHomeImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
2577 static CCM_BieterHomeImplicit_ptr _duplicate( CCM_BieterHomeImplicit_ptr _obj )
2578 {
2579 CORBA::Object::_duplicate (_obj);
2580 return _obj;
2581 }
2582
2583 static CCM_BieterHomeImplicit_ptr _nil()
2584 {
2585 return 0;
2586 }
2587
2588 virtual void *_narrow_helper( const char *repoid );
2589
2590 virtual ::Components::EnterpriseComponent_ptr create() = 0;
2591
2592 protected:
2593 CCM_BieterHomeImplicit() {};
2594 private:
2595 CCM_BieterHomeImplicit( const CCM_BieterHomeImplicit& );
2596 void operator=( const CCM_BieterHomeImplicit& );
2597 };
2598
2599
2600
2601
2602
2603 class CCM_BieterHome :
2604 virtual public ::Auktion::CCM_BieterHomeExplicit,
2605 virtual public ::Auktion::CCM_BieterHomeImplicit
{
2606 public:
2607 virtual ~CCM_BieterHome();
2608
2609 #ifdef HAVE_TYPEDEF_OVERLOAD
2610 typedef CCM_BieterHome_ptr _ptr_type;
2611 typedef CCM_BieterHome_var _var_type;
2612 #endif
2613
2614 static CCM_BieterHome_ptr _narrow( CORBA::Object_ptr obj );
2615 static CCM_BieterHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
2616 static CCM_BieterHome_ptr _duplicate( CCM_BieterHome_ptr _obj )
2617 {
2618 CORBA::Object::_duplicate (_obj);
2619 return _obj;
2620 }
2621
2622 static CCM_BieterHome_ptr _nil()
2623 {
2624 return 0;
2625 }
2626
2627 virtual void *_narrow_helper( const char *repoid );
2628
2629 protected:
2630 CCM_BieterHome() {};
2631 private:
2632 CCM_BieterHome( const CCM_BieterHome& );
2633 void operator=( const CCM_BieterHome& );
2634 };
2635
2636
2637
2638
2639
2640 class VerkaeuferHomeExplicit :
2641 virtual public ::Components::CCMHome
{
2642 public:
2643 virtual ~VerkaeuferHomeExplicit();
2644
2645 #ifdef HAVE_TYPEDEF_OVERLOAD
2646 typedef VerkaeuferHomeExplicit_ptr _ptr_type;
2647 typedef VerkaeuferHomeExplicit_var _var_type;
2648 #endif
2649
2650 static VerkaeuferHomeExplicit_ptr _narrow( CORBA::Object_ptr obj );
2651 static VerkaeuferHomeExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
2652 static VerkaeuferHomeExplicit_ptr _duplicate( VerkaeuferHomeExplicit_ptr _obj )
2653 {
2654 CORBA::Object::_duplicate (_obj);
2655 return _obj;
2656 }
2657
2658 static VerkaeuferHomeExplicit_ptr _nil()
2659 {
2660 return 0;
2661 }
2662
2663 virtual void *_narrow_helper( const char *repoid );
2664
2665 protected:
2666 VerkaeuferHomeExplicit() {};
2667 private:
2668 VerkaeuferHomeExplicit( const VerkaeuferHomeExplicit& );
2669 void operator=( const VerkaeuferHomeExplicit& );
2670 };
2671
2672
2673 class VerkaeuferHomeExplicit_stub:
2674 virtual public VerkaeuferHomeExplicit,
2675 virtual public ::Components::CCMHome_stub
{
2676 public:
2677 virtual ~VerkaeuferHomeExplicit_stub();
2678 private:
2679 void operator=( const VerkaeuferHomeExplicit_stub& );
2680 };
2681
2682 #ifndef MICO_CONF_NO_POA
2683
2684 class VerkaeuferHomeExplicit_stub_clp :
2685 virtual public VerkaeuferHomeExplicit_stub,
2686 virtual public ::Components::CCMHome_stub_clp
{
2687 public:
2688 VerkaeuferHomeExplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2689 virtual ~VerkaeuferHomeExplicit_stub_clp ();
2690 protected:
2691 VerkaeuferHomeExplicit_stub_clp ();
2692 private:
2693 void operator=( const VerkaeuferHomeExplicit_stub_clp & );
2694 };
2695
2696 #endif // MICO_CONF_NO_POA
2697
2698
2699
2700
2701 class VerkaeuferHomeImplicit :
2702 virtual public ::Components::KeylessCCMHome
{
2703 public:
2704 virtual ~VerkaeuferHomeImplicit();
2705
2706 #ifdef HAVE_TYPEDEF_OVERLOAD
2707 typedef VerkaeuferHomeImplicit_ptr _ptr_type;
2708 typedef VerkaeuferHomeImplicit_var _var_type;
2709 #endif
2710
2711 static VerkaeuferHomeImplicit_ptr _narrow( CORBA::Object_ptr obj );
2712 static VerkaeuferHomeImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
2713 static VerkaeuferHomeImplicit_ptr _duplicate( VerkaeuferHomeImplicit_ptr _obj )
2714 {
2715 CORBA::Object::_duplicate (_obj);
2716 return _obj;
2717 }
2718
2719 static VerkaeuferHomeImplicit_ptr _nil()
2720 {
2721 return 0;
2722 }
2723
2724 virtual void *_narrow_helper( const char *repoid );
2725
2726 virtual Verkaeufer_ptr create() = 0;
2727
2728 protected:
2729 VerkaeuferHomeImplicit() {};
2730 private:
2731 VerkaeuferHomeImplicit( const VerkaeuferHomeImplicit& );
2732 void operator=( const VerkaeuferHomeImplicit& );
2733 };
2734
2735
2736 class VerkaeuferHomeImplicit_stub:
2737 virtual public VerkaeuferHomeImplicit,
2738 virtual public ::Components::KeylessCCMHome_stub
{
2739 public:
2740 virtual ~VerkaeuferHomeImplicit_stub();
2741 Verkaeufer_ptr create();
2742
2743 private:
2744 void operator=( const VerkaeuferHomeImplicit_stub& );
2745 };
2746
2747 #ifndef MICO_CONF_NO_POA
2748
2749 class VerkaeuferHomeImplicit_stub_clp :
2750 virtual public VerkaeuferHomeImplicit_stub,
2751 virtual public ::Components::KeylessCCMHome_stub_clp
{
2752 public:
2753 VerkaeuferHomeImplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2754 virtual ~VerkaeuferHomeImplicit_stub_clp ();
2755 Verkaeufer_ptr create();
2756
2757 protected:
2758 VerkaeuferHomeImplicit_stub_clp ();
2759 private:
2760 void operator=( const VerkaeuferHomeImplicit_stub_clp & );
2761 };
2762
2763 #endif // MICO_CONF_NO_POA
2764
2765
2766
2767
2768 class VerkaeuferHome :
2769 virtual public ::Auktion::VerkaeuferHomeExplicit,
2770 virtual public ::Auktion::VerkaeuferHomeImplicit
{
2771 public:
2772 virtual ~VerkaeuferHome();
2773
2774 #ifdef HAVE_TYPEDEF_OVERLOAD
2775 typedef VerkaeuferHome_ptr _ptr_type;
2776 typedef VerkaeuferHome_var _var_type;
2777 #endif
2778
2779 static VerkaeuferHome_ptr _narrow( CORBA::Object_ptr obj );
2780 static VerkaeuferHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
2781 static VerkaeuferHome_ptr _duplicate( VerkaeuferHome_ptr _obj )
2782 {
2783 CORBA::Object::_duplicate (_obj);
2784 return _obj;
2785 }
2786
2787 static VerkaeuferHome_ptr _nil()
2788 {
2789 return 0;
2790 }
2791
2792 virtual void *_narrow_helper( const char *repoid );
2793
2794 protected:
2795 VerkaeuferHome() {};
2796 private:
2797 VerkaeuferHome( const VerkaeuferHome& );
2798 void operator=( const VerkaeuferHome& );
2799 };
2800
2801
2802 class VerkaeuferHome_stub:
2803 virtual public VerkaeuferHome,
2804 virtual public ::Auktion::VerkaeuferHomeExplicit_stub,
2805 virtual public ::Auktion::VerkaeuferHomeImplicit_stub
{
2806 public:
2807 virtual ~VerkaeuferHome_stub();
2808 private:
2809 void operator=( const VerkaeuferHome_stub& );
2810 };
2811
2812 #ifndef MICO_CONF_NO_POA
2813
2814 class VerkaeuferHome_stub_clp :
2815 virtual public VerkaeuferHome_stub,
2816 virtual public ::Auktion::VerkaeuferHomeExplicit_stub_clp,
2817 virtual public ::Auktion::VerkaeuferHomeImplicit_stub_clp
{
2818 public:
2819 VerkaeuferHome_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
2820 virtual ~VerkaeuferHome_stub_clp ();
2821 protected:
2822 VerkaeuferHome_stub_clp ();
2823 private:
2824 void operator=( const VerkaeuferHome_stub_clp & );
2825 };
2826
2827 #endif // MICO_CONF_NO_POA
2828
2829
2830
2831
2832 class CCM_VerkaeuferHomeExplicit :
2833 virtual public ::Components::HomeExecutorBase
{
2834 public:
2835 virtual ~CCM_VerkaeuferHomeExplicit();
2836
2837 #ifdef HAVE_TYPEDEF_OVERLOAD
2838 typedef CCM_VerkaeuferHomeExplicit_ptr _ptr_type;
2839 typedef CCM_VerkaeuferHomeExplicit_var _var_type;
2840 #endif
2841
2842 static CCM_VerkaeuferHomeExplicit_ptr _narrow( CORBA::Object_ptr obj );
2843 static CCM_VerkaeuferHomeExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
2844 static CCM_VerkaeuferHomeExplicit_ptr _duplicate( CCM_VerkaeuferHomeExplicit_ptr _obj )
2845 {
2846 CORBA::Object::_duplicate (_obj);
2847 return _obj;
2848 }
2849
2850 static CCM_VerkaeuferHomeExplicit_ptr _nil()
2851 {
2852 return 0;
2853 }
2854
2855 virtual void *_narrow_helper( const char *repoid );
2856
2857 protected:
2858 CCM_VerkaeuferHomeExplicit() {};
2859 private:
2860 CCM_VerkaeuferHomeExplicit( const CCM_VerkaeuferHomeExplicit& );
2861 void operator=( const CCM_VerkaeuferHomeExplicit& );
2862 };
2863
2864
2865
2866
2867
2868 class CCM_VerkaeuferHomeImplicit :
2869 virtual public CORBA::LocalObject
{
2870 public:
2871 virtual ~CCM_VerkaeuferHomeImplicit();
2872
2873 #ifdef HAVE_TYPEDEF_OVERLOAD
2874 typedef CCM_VerkaeuferHomeImplicit_ptr _ptr_type;
2875 typedef CCM_VerkaeuferHomeImplicit_var _var_type;
2876 #endif
2877
2878 static CCM_VerkaeuferHomeImplicit_ptr _narrow( CORBA::Object_ptr obj );
2879 static CCM_VerkaeuferHomeImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
2880 static CCM_VerkaeuferHomeImplicit_ptr _duplicate( CCM_VerkaeuferHomeImplicit_ptr _obj )
2881 {
2882 CORBA::Object::_duplicate (_obj);
2883 return _obj;
2884 }
2885
2886 static CCM_VerkaeuferHomeImplicit_ptr _nil()
2887 {
2888 return 0;
2889 }
2890
2891 virtual void *_narrow_helper( const char *repoid );
2892
2893 virtual ::Components::EnterpriseComponent_ptr create() = 0;
2894
2895 protected:
2896 CCM_VerkaeuferHomeImplicit() {};
2897 private:
2898 CCM_VerkaeuferHomeImplicit( const CCM_VerkaeuferHomeImplicit& );
2899 void operator=( const CCM_VerkaeuferHomeImplicit& );
2900 };
2901
2902
2903
2904
2905
2906 class CCM_VerkaeuferHome :
2907 virtual public ::Auktion::CCM_VerkaeuferHomeExplicit,
2908 virtual public ::Auktion::CCM_VerkaeuferHomeImplicit
{
2909 public:
2910 virtual ~CCM_VerkaeuferHome();
2911
2912 #ifdef HAVE_TYPEDEF_OVERLOAD
2913 typedef CCM_VerkaeuferHome_ptr _ptr_type;
2914 typedef CCM_VerkaeuferHome_var _var_type;
2915 #endif
2916
2917 static CCM_VerkaeuferHome_ptr _narrow( CORBA::Object_ptr obj );
2918 static CCM_VerkaeuferHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
2919 static CCM_VerkaeuferHome_ptr _duplicate( CCM_VerkaeuferHome_ptr _obj )
2920 {
2921 CORBA::Object::_duplicate (_obj);
2922 return _obj;
2923 }
2924
2925 static CCM_VerkaeuferHome_ptr _nil()
2926 {
2927 return 0;
2928 }
2929
2930 virtual void *_narrow_helper( const char *repoid );
2931
2932 protected:
2933 CCM_VerkaeuferHome() {};
2934 private:
2935 CCM_VerkaeuferHome( const CCM_VerkaeuferHome& );
2936 void operator=( const CCM_VerkaeuferHome& );
2937 };
2938
2939
2940 }
2941
2942
2943 #ifndef MICO_CONF_NO_POA
2944
2945
2946
2947 namespace POA_Auktion
{
2948
2949 class Kaeufer : virtual public PortableServer::StaticImplementation
{
2950 public:
2951 virtual ~Kaeufer ();
2952 Auktion::Kaeufer_ptr _this ();
2953 bool dispatch (CORBA::StaticServerRequest_ptr);
2954 virtual void invoke (CORBA::StaticServerRequest_ptr);
2955 virtual CORBA::Boolean _is_a (const char *);
2956 virtual CORBA::InterfaceDef_ptr _get_interface ();
2957 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
2958
2959 virtual void * _narrow_helper (const char *);
2960 static Kaeufer * _narrow (PortableServer::Servant);
2961 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
2962
2963 virtual void zuschlag( ::Auktion::Versteigerung_ptr gegenstand, ::Auktion::Verkaeufer_ptr v ) = 0;
2964
2965 protected:
2966 Kaeufer () {};
2967
2968 private:
2969 Kaeufer (const Kaeufer &);
2970 void operator= (const Kaeufer &);
2971 };
2972
2973 class Bieter :
2974 virtual public POA_Components::CCMObject,
2975 virtual public POA_Auktion::Kaeufer
{
2976 public:
2977 virtual ~Bieter ();
2978 Auktion::Bieter_ptr _this ();
2979 bool dispatch (CORBA::StaticServerRequest_ptr);
2980 virtual void invoke (CORBA::StaticServerRequest_ptr);
2981 virtual CORBA::Boolean _is_a (const char *);
2982 virtual CORBA::InterfaceDef_ptr _get_interface ();
2983 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
2984
2985 virtual void * _narrow_helper (const char *);
2986 static Bieter * _narrow (PortableServer::Servant);
2987 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
2988
2989 virtual ::Auktion::GebotConsumer_ptr get_consumer_gebote() = 0;
2990 virtual ::Components::Cookie* connect_versteigerungen( ::Auktion::Versteigerung_ptr connection ) = 0;
2991 virtual ::Auktion::Versteigerung_ptr disconnect_versteigerungen( ::Components::Cookie* ck ) = 0;
2992 virtual ::Auktion::Bieter::versteigerungenConnections* get_connections_versteigerungen() = 0;
2993
2994 protected:
2995 Bieter () {};
2996
2997 private:
2998 Bieter (const Bieter &);
2999 void operator= (const Bieter &);
3000 };
3001
3002 class GebotConsumer :
3003 virtual public POA_Components::EventConsumerBase
{
3004 public:
3005 virtual ~GebotConsumer ();
3006 Auktion::GebotConsumer_ptr _this ();
3007 bool dispatch (CORBA::StaticServerRequest_ptr);
3008 virtual void invoke (CORBA::StaticServerRequest_ptr);
3009 virtual CORBA::Boolean _is_a (const char *);
3010 virtual CORBA::InterfaceDef_ptr _get_interface ();
3011 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3012
3013 virtual void * _narrow_helper (const char *);
3014 static GebotConsumer * _narrow (PortableServer::Servant);
3015 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3016
3017 virtual void push_Gebot( ::Auktion::Gebot* event ) = 0;
3018
3019 protected:
3020 GebotConsumer () {};
3021
3022 private:
3023 GebotConsumer (const GebotConsumer &);
3024 void operator= (const GebotConsumer &);
3025 };
3026
3027 class Versteigerung : virtual public PortableServer::StaticImplementation
{
3028 public:
3029 virtual ~Versteigerung ();
3030 Auktion::Versteigerung_ptr _this ();
3031 bool dispatch (CORBA::StaticServerRequest_ptr);
3032 virtual void invoke (CORBA::StaticServerRequest_ptr);
3033 virtual CORBA::Boolean _is_a (const char *);
3034 virtual CORBA::InterfaceDef_ptr _get_interface ();
3035 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3036
3037 virtual void * _narrow_helper (const char *);
3038 static Versteigerung * _narrow (PortableServer::Servant);
3039 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3040
3041 virtual char* name() = 0;
3042 virtual CORBA::Long aktuelles_gebot() = 0;
3043
3044 virtual void biete( CORBA::Long gebot, ::Auktion::Bieter_ptr potentieller_kaeufer ) = 0;
3045
3046 protected:
3047 Versteigerung () {};
3048
3049 private:
3050 Versteigerung (const Versteigerung &);
3051 void operator= (const Versteigerung &);
3052 };
3053
3054 class Verkaeufer :
3055 virtual public POA_Components::CCMObject
{
3056 public:
3057 virtual ~Verkaeufer ();
3058 Auktion::Verkaeufer_ptr _this ();
3059 bool dispatch (CORBA::StaticServerRequest_ptr);
3060 virtual void invoke (CORBA::StaticServerRequest_ptr);
3061 virtual CORBA::Boolean _is_a (const char *);
3062 virtual CORBA::InterfaceDef_ptr _get_interface ();
3063 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3064
3065 virtual void * _narrow_helper (const char *);
3066 static Verkaeufer * _narrow (PortableServer::Servant);
3067 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3068
3069 virtual void connect_handelsplatz( ::Auktion::VersteigerungsFabrik_ptr conxn ) = 0;
3070 virtual ::Auktion::VersteigerungsFabrik_ptr disconnect_handelsplatz() = 0;
3071 virtual ::Auktion::VersteigerungsFabrik_ptr get_connection_handelsplatz() = 0;
3072 virtual ::Auktion::KaufConsumer_ptr get_consumer_zuschlag() = 0;
3073
3074 protected:
3075 Verkaeufer () {};
3076
3077 private:
3078 Verkaeufer (const Verkaeufer &);
3079 void operator= (const Verkaeufer &);
3080 };
3081
3082 class VersteigerungsFabrik : virtual public PortableServer::StaticImplementation
{
3083 public:
3084 virtual ~VersteigerungsFabrik ();
3085 Auktion::VersteigerungsFabrik_ptr _this ();
3086 bool dispatch (CORBA::StaticServerRequest_ptr);
3087 virtual void invoke (CORBA::StaticServerRequest_ptr);
3088 virtual CORBA::Boolean _is_a (const char *);
3089 virtual CORBA::InterfaceDef_ptr _get_interface ();
3090 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3091
3092 virtual void * _narrow_helper (const char *);
3093 static VersteigerungsFabrik * _narrow (PortableServer::Servant);
3094 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3095
3096 virtual ::Auktion::Versteigerung_ptr neue_auktion( const char* name, CORBA::Long minimalgebot, ::Auktion::Verkaeufer_ptr besitzer ) = 0;
3097
3098 protected:
3099 VersteigerungsFabrik () {};
3100
3101 private:
3102 VersteigerungsFabrik (const VersteigerungsFabrik &);
3103 void operator= (const VersteigerungsFabrik &);
3104 };
3105
3106 class KaufConsumer :
3107 virtual public POA_Components::EventConsumerBase
{
3108 public:
3109 virtual ~KaufConsumer ();
3110 Auktion::KaufConsumer_ptr _this ();
3111 bool dispatch (CORBA::StaticServerRequest_ptr);
3112 virtual void invoke (CORBA::StaticServerRequest_ptr);
3113 virtual CORBA::Boolean _is_a (const char *);
3114 virtual CORBA::InterfaceDef_ptr _get_interface ();
3115 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3116
3117 virtual void * _narrow_helper (const char *);
3118 static KaufConsumer * _narrow (PortableServer::Servant);
3119 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3120
3121 virtual void push_Kauf( ::Auktion::Kauf* event ) = 0;
3122
3123 protected:
3124 KaufConsumer () {};
3125
3126 private:
3127 KaufConsumer (const KaufConsumer &);
3128 void operator= (const KaufConsumer &);
3129 };
3130
3131 class Auktionshaus :
3132 virtual public POA_Components::CCMObject
{
3133 public:
3134 virtual ~Auktionshaus ();
3135 Auktion::Auktionshaus_ptr _this ();
3136 bool dispatch (CORBA::StaticServerRequest_ptr);
3137 virtual void invoke (CORBA::StaticServerRequest_ptr);
3138 virtual CORBA::Boolean _is_a (const char *);
3139 virtual CORBA::InterfaceDef_ptr _get_interface ();
3140 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3141
3142 virtual void * _narrow_helper (const char *);
3143 static Auktionshaus * _narrow (PortableServer::Servant);
3144 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3145
3146 virtual ::Auktion::VersteigerungsFabrik_ptr provide_auktionen() = 0;
3147 virtual ::Components::Cookie* subscribe_gebote( ::Auktion::GebotConsumer_ptr consumer ) = 0;
3148 virtual ::Auktion::GebotConsumer_ptr unsubscribe_gebote( ::Components::Cookie* ck ) = 0;
3149
3150 protected:
3151 Auktionshaus () {};
3152
3153 private:
3154 Auktionshaus (const Auktionshaus &);
3155 void operator= (const Auktionshaus &);
3156 };
3157
3158 class WeltExplicit :
3159 virtual public POA_Components::CCMHome
{
3160 public:
3161 virtual ~WeltExplicit ();
3162 Auktion::WeltExplicit_ptr _this ();
3163 bool dispatch (CORBA::StaticServerRequest_ptr);
3164 virtual void invoke (CORBA::StaticServerRequest_ptr);
3165 virtual CORBA::Boolean _is_a (const char *);
3166 virtual CORBA::InterfaceDef_ptr _get_interface ();
3167 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3168
3169 virtual void * _narrow_helper (const char *);
3170 static WeltExplicit * _narrow (PortableServer::Servant);
3171 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3172
3173 protected:
3174 WeltExplicit () {};
3175
3176 private:
3177 WeltExplicit (const WeltExplicit &);
3178 void operator= (const WeltExplicit &);
3179 };
3180
3181 class WeltImplicit :
3182 virtual public POA_Components::KeylessCCMHome
{
3183 public:
3184 virtual ~WeltImplicit ();
3185 Auktion::WeltImplicit_ptr _this ();
3186 bool dispatch (CORBA::StaticServerRequest_ptr);
3187 virtual void invoke (CORBA::StaticServerRequest_ptr);
3188 virtual CORBA::Boolean _is_a (const char *);
3189 virtual CORBA::InterfaceDef_ptr _get_interface ();
3190 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3191
3192 virtual void * _narrow_helper (const char *);
3193 static WeltImplicit * _narrow (PortableServer::Servant);
3194 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3195
3196 virtual ::Auktion::Auktionshaus_ptr create() = 0;
3197
3198 protected:
3199 WeltImplicit () {};
3200
3201 private:
3202 WeltImplicit (const WeltImplicit &);
3203 void operator= (const WeltImplicit &);
3204 };
3205
3206 class Welt :
3207 virtual public POA_Auktion::WeltExplicit,
3208 virtual public POA_Auktion::WeltImplicit
{
3209 public:
3210 virtual ~Welt ();
3211 Auktion::Welt_ptr _this ();
3212 bool dispatch (CORBA::StaticServerRequest_ptr);
3213 virtual void invoke (CORBA::StaticServerRequest_ptr);
3214 virtual CORBA::Boolean _is_a (const char *);
3215 virtual CORBA::InterfaceDef_ptr _get_interface ();
3216 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3217
3218 virtual void * _narrow_helper (const char *);
3219 static Welt * _narrow (PortableServer::Servant);
3220 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3221
3222 protected:
3223 Welt () {};
3224
3225 private:
3226 Welt (const Welt &);
3227 void operator= (const Welt &);
3228 };
3229
3230 class ProduktFilter :
3231 virtual public POA_Components::CCMObject
{
3232 public:
3233 virtual ~ProduktFilter ();
3234 Auktion::ProduktFilter_ptr _this ();
3235 bool dispatch (CORBA::StaticServerRequest_ptr);
3236 virtual void invoke (CORBA::StaticServerRequest_ptr);
3237 virtual CORBA::Boolean _is_a (const char *);
3238 virtual CORBA::InterfaceDef_ptr _get_interface ();
3239 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3240
3241 virtual void * _narrow_helper (const char *);
3242 static ProduktFilter * _narrow (PortableServer::Servant);
3243 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3244
3245 virtual char* interessanter_gegenstand() = 0;
3246 virtual void interessanter_gegenstand( const char* value ) = 0;
3247
3248 virtual ::Auktion::GebotConsumer_ptr get_consumer_eingehende_gebote() = 0;
3249 virtual ::Components::Cookie* subscribe_interessante_gebote( ::Auktion::GebotConsumer_ptr consumer ) = 0;
3250 virtual ::Auktion::GebotConsumer_ptr unsubscribe_interessante_gebote( ::Components::Cookie* ck ) = 0;
3251
3252 protected:
3253 ProduktFilter () {};
3254
3255 private:
3256 ProduktFilter (const ProduktFilter &);
3257 void operator= (const ProduktFilter &);
3258 };
3259
3260 class FilterHomeExplicit :
3261 virtual public POA_Components::CCMHome
{
3262 public:
3263 virtual ~FilterHomeExplicit ();
3264 Auktion::FilterHomeExplicit_ptr _this ();
3265 bool dispatch (CORBA::StaticServerRequest_ptr);
3266 virtual void invoke (CORBA::StaticServerRequest_ptr);
3267 virtual CORBA::Boolean _is_a (const char *);
3268 virtual CORBA::InterfaceDef_ptr _get_interface ();
3269 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3270
3271 virtual void * _narrow_helper (const char *);
3272 static FilterHomeExplicit * _narrow (PortableServer::Servant);
3273 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3274
3275 virtual ::Auktion::ProduktFilter_ptr new_filter( const char* gegenstand ) = 0;
3276
3277 protected:
3278 FilterHomeExplicit () {};
3279
3280 private:
3281 FilterHomeExplicit (const FilterHomeExplicit &);
3282 void operator= (const FilterHomeExplicit &);
3283 };
3284
3285 class FilterHomeImplicit :
3286 virtual public POA_Components::KeylessCCMHome
{
3287 public:
3288 virtual ~FilterHomeImplicit ();
3289 Auktion::FilterHomeImplicit_ptr _this ();
3290 bool dispatch (CORBA::StaticServerRequest_ptr);
3291 virtual void invoke (CORBA::StaticServerRequest_ptr);
3292 virtual CORBA::Boolean _is_a (const char *);
3293 virtual CORBA::InterfaceDef_ptr _get_interface ();
3294 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3295
3296 virtual void * _narrow_helper (const char *);
3297 static FilterHomeImplicit * _narrow (PortableServer::Servant);
3298 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3299
3300 virtual ::Auktion::ProduktFilter_ptr create() = 0;
3301
3302 protected:
3303 FilterHomeImplicit () {};
3304
3305 private:
3306 FilterHomeImplicit (const FilterHomeImplicit &);
3307 void operator= (const FilterHomeImplicit &);
3308 };
3309
3310 class FilterHome :
3311 virtual public POA_Auktion::FilterHomeExplicit,
3312 virtual public POA_Auktion::FilterHomeImplicit
{
3313 public:
3314 virtual ~FilterHome ();
3315 Auktion::FilterHome_ptr _this ();
3316 bool dispatch (CORBA::StaticServerRequest_ptr);
3317 virtual void invoke (CORBA::StaticServerRequest_ptr);
3318 virtual CORBA::Boolean _is_a (const char *);
3319 virtual CORBA::InterfaceDef_ptr _get_interface ();
3320 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3321
3322 virtual void * _narrow_helper (const char *);
3323 static FilterHome * _narrow (PortableServer::Servant);
3324 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3325
3326 protected:
3327 FilterHome () {};
3328
3329 private:
3330 FilterHome (const FilterHome &);
3331 void operator= (const FilterHome &);
3332 };
3333
3334 class BieterHomeExplicit :
3335 virtual public POA_Components::CCMHome
{
3336 public:
3337 virtual ~BieterHomeExplicit ();
3338 Auktion::BieterHomeExplicit_ptr _this ();
3339 bool dispatch (CORBA::StaticServerRequest_ptr);
3340 virtual void invoke (CORBA::StaticServerRequest_ptr);
3341 virtual CORBA::Boolean _is_a (const char *);
3342 virtual CORBA::InterfaceDef_ptr _get_interface ();
3343 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3344
3345 virtual void * _narrow_helper (const char *);
3346 static BieterHomeExplicit * _narrow (PortableServer::Servant);
3347 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3348
3349 protected:
3350 BieterHomeExplicit () {};
3351
3352 private:
3353 BieterHomeExplicit (const BieterHomeExplicit &);
3354 void operator= (const BieterHomeExplicit &);
3355 };
3356
3357 class BieterHomeImplicit :
3358 virtual public POA_Components::KeylessCCMHome
{
3359 public:
3360 virtual ~BieterHomeImplicit ();
3361 Auktion::BieterHomeImplicit_ptr _this ();
3362 bool dispatch (CORBA::StaticServerRequest_ptr);
3363 virtual void invoke (CORBA::StaticServerRequest_ptr);
3364 virtual CORBA::Boolean _is_a (const char *);
3365 virtual CORBA::InterfaceDef_ptr _get_interface ();
3366 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3367
3368 virtual void * _narrow_helper (const char *);
3369 static BieterHomeImplicit * _narrow (PortableServer::Servant);
3370 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3371
3372 virtual ::Auktion::Bieter_ptr create() = 0;
3373
3374 protected:
3375 BieterHomeImplicit () {};
3376
3377 private:
3378 BieterHomeImplicit (const BieterHomeImplicit &);
3379 void operator= (const BieterHomeImplicit &);
3380 };
3381
3382 class BieterHome :
3383 virtual public POA_Auktion::BieterHomeExplicit,
3384 virtual public POA_Auktion::BieterHomeImplicit
{
3385 public:
3386 virtual ~BieterHome ();
3387 Auktion::BieterHome_ptr _this ();
3388 bool dispatch (CORBA::StaticServerRequest_ptr);
3389 virtual void invoke (CORBA::StaticServerRequest_ptr);
3390 virtual CORBA::Boolean _is_a (const char *);
3391 virtual CORBA::InterfaceDef_ptr _get_interface ();
3392 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3393
3394 virtual void * _narrow_helper (const char *);
3395 static BieterHome * _narrow (PortableServer::Servant);
3396 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3397
3398 protected:
3399 BieterHome () {};
3400
3401 private:
3402 BieterHome (const BieterHome &);
3403 void operator= (const BieterHome &);
3404 };
3405
3406 class VerkaeuferHomeExplicit :
3407 virtual public POA_Components::CCMHome
{
3408 public:
3409 virtual ~VerkaeuferHomeExplicit ();
3410 Auktion::VerkaeuferHomeExplicit_ptr _this ();
3411 bool dispatch (CORBA::StaticServerRequest_ptr);
3412 virtual void invoke (CORBA::StaticServerRequest_ptr);
3413 virtual CORBA::Boolean _is_a (const char *);
3414 virtual CORBA::InterfaceDef_ptr _get_interface ();
3415 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3416
3417 virtual void * _narrow_helper (const char *);
3418 static VerkaeuferHomeExplicit * _narrow (PortableServer::Servant);
3419 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3420
3421 protected:
3422 VerkaeuferHomeExplicit () {};
3423
3424 private:
3425 VerkaeuferHomeExplicit (const VerkaeuferHomeExplicit &);
3426 void operator= (const VerkaeuferHomeExplicit &);
3427 };
3428
3429 class VerkaeuferHomeImplicit :
3430 virtual public POA_Components::KeylessCCMHome
{
3431 public:
3432 virtual ~VerkaeuferHomeImplicit ();
3433 Auktion::VerkaeuferHomeImplicit_ptr _this ();
3434 bool dispatch (CORBA::StaticServerRequest_ptr);
3435 virtual void invoke (CORBA::StaticServerRequest_ptr);
3436 virtual CORBA::Boolean _is_a (const char *);
3437 virtual CORBA::InterfaceDef_ptr _get_interface ();
3438 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3439
3440 virtual void * _narrow_helper (const char *);
3441 static VerkaeuferHomeImplicit * _narrow (PortableServer::Servant);
3442 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3443
3444 virtual ::Auktion::Verkaeufer_ptr create() = 0;
3445
3446 protected:
3447 VerkaeuferHomeImplicit () {};
3448
3449 private:
3450 VerkaeuferHomeImplicit (const VerkaeuferHomeImplicit &);
3451 void operator= (const VerkaeuferHomeImplicit &);
3452 };
3453
3454 class VerkaeuferHome :
3455 virtual public POA_Auktion::VerkaeuferHomeExplicit,
3456 virtual public POA_Auktion::VerkaeuferHomeImplicit
{
3457 public:
3458 virtual ~VerkaeuferHome ();
3459 Auktion::VerkaeuferHome_ptr _this ();
3460 bool dispatch (CORBA::StaticServerRequest_ptr);
3461 virtual void invoke (CORBA::StaticServerRequest_ptr);
3462 virtual CORBA::Boolean _is_a (const char *);
3463 virtual CORBA::InterfaceDef_ptr _get_interface ();
3464 virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
3465
3466 virtual void * _narrow_helper (const char *);
3467 static VerkaeuferHome * _narrow (PortableServer::Servant);
3468 virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
3469
3470 protected:
3471 VerkaeuferHome () {};
3472
3473 private:
3474 VerkaeuferHome (const VerkaeuferHome &);
3475 void operator= (const VerkaeuferHome &);
3476 };
3477
3478 }
3479
3480
3481 #endif // MICO_CONF_NO_POA
3482
3483
3484
3485 namespace OBV_Auktion
{
3486
3487
3488
3489 class Gebot : virtual public Auktion::Gebot
{
3490 protected:
3491 Gebot ();
3492 Gebot (::Auktion::Versteigerung_ptr _gegenstand, CORBA::Long _angebot);
3493 virtual ~Gebot();
3494
3495 public:
3496 void gegenstand( ::Auktion::Versteigerung_ptr _p );
3497 ::Auktion::Versteigerung_ptr gegenstand() const;
3498
3499 void angebot( CORBA::Long _p );
3500 CORBA::Long angebot() const;
3501
3502
3503 private:
3504 struct _M {
3505 ::Auktion::Versteigerung_var gegenstand;
3506 CORBA::Long angebot;
3507 } _m;
3508 };
3509
3510
3511
3512 class Kauf :
3513 virtual public Auktion::Kauf,
3514 virtual public OBV_Auktion::Gebot
{
3515 protected:
3516 Kauf ();
3517 Kauf (::Auktion::Kaeufer_ptr _kaeufer);
3518 virtual ~Kauf();
3519
3520 public:
3521 void kaeufer( ::Auktion::Kaeufer_ptr _p );
3522 ::Auktion::Kaeufer_ptr kaeufer() const;
3523
3524
3525 private:
3526 struct _M {
3527 ::Auktion::Kaeufer_var kaeufer;
3528 } _m;
3529 };
3530
3531 }
3532
3533
3534 extern CORBA::StaticTypeInfo *_marshaller_Auktion_Kaeufer;
3535
3536 extern CORBA::StaticTypeInfo *_marshaller_Auktion_Bieter_versteigerungenConnection;
3537
3538 extern CORBA::StaticTypeInfo *_marshaller_Auktion_Bieter;
3539
3540 extern CORBA::StaticTypeInfo *_marshaller_Auktion_Gebot;
3541
3542 extern CORBA::StaticTypeInfo *_marshaller_Auktion_GebotConsumer;
3543
3544 extern CORBA::StaticTypeInfo *_marshaller_Auktion_Versteigerung;
3545
3546 extern CORBA::StaticTypeInfo *_marshaller_Auktion_Verkaeufer;
3547
3548 extern CORBA::StaticTypeInfo *_marshaller_Auktion_VersteigerungsFabrik;
3549
3550 extern CORBA::StaticTypeInfo *_marshaller_Auktion_Kauf;
3551
3552 extern CORBA::StaticTypeInfo *_marshaller_Auktion_KaufConsumer;
3553
3554 extern CORBA::StaticTypeInfo *_marshaller_Auktion_Auktionshaus;
3555
3556 extern CORBA::StaticTypeInfo *_marshaller_Auktion_WeltExplicit;
3557
3558 extern CORBA::StaticTypeInfo *_marshaller_Auktion_WeltImplicit;
3559
3560 extern CORBA::StaticTypeInfo *_marshaller_Auktion_Welt;
3561
3562 extern CORBA::StaticTypeInfo *_marshaller_Auktion_ProduktFilter;
3563
3564 extern CORBA::StaticTypeInfo *_marshaller_Auktion_FilterHomeExplicit;
3565
3566 extern CORBA::StaticTypeInfo *_marshaller_Auktion_FilterHomeImplicit;
3567
3568 extern CORBA::StaticTypeInfo *_marshaller_Auktion_FilterHome;
3569
3570 extern CORBA::StaticTypeInfo *_marshaller_Auktion_BieterHomeExplicit;
3571
3572 extern CORBA::StaticTypeInfo *_marshaller_Auktion_BieterHomeImplicit;
3573
3574 extern CORBA::StaticTypeInfo *_marshaller_Auktion_BieterHome;
3575
3576 extern CORBA::StaticTypeInfo *_marshaller_Auktion_VerkaeuferHomeExplicit;
3577
3578 extern CORBA::StaticTypeInfo *_marshaller_Auktion_VerkaeuferHomeImplicit;
3579
3580 extern CORBA::StaticTypeInfo *_marshaller_Auktion_VerkaeuferHome;
3581
3582 extern CORBA::StaticTypeInfo *_marshaller__seq_Auktion_Bieter_versteigerungenConnection;
3583
3584 #endif
3585
3586