FilterHome_impl.cpp (1.7k)
FilterHome_impl.h (945 bytes)
ProduktFilter_impl.cpp (1.5k)
ProduktFilter_impl.h (1.1k)
auktion.cpp (217.6k)
auktion.h (105.7k)
auktion.idl (1.8k)
auktion_ccm.cpp (69.8k)
auktion_ccm.h (23.4k)
session.cpp (1.6k)
session.h (1.9k)
session.idl (209 bytes)


more info here

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