sources:


website:
more info here
studies/corba/Corba-Code4/Filter/auktion.h
download file

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