/*
 *  MICO --- an Open Source CORBA implementation
 *  Copyright (c) 1997-2001 by The Mico Team
 *
 *  This file was automatically generated. DO NOT EDIT!
 */

#include <CORBA.h>
#include <mico/throw.h>

#ifndef __AUKTION_H__
#define __AUKTION_H__




namespace Auktion
{

class Versteigerung;
typedef Versteigerung *Versteigerung_ptr;
typedef Versteigerung_ptr VersteigerungRef;
typedef ObjVar< Versteigerung > Versteigerung_var;
typedef ObjOut< Versteigerung > Versteigerung_out;

class Verkaeufer;
typedef Verkaeufer *Verkaeufer_ptr;
typedef Verkaeufer_ptr VerkaeuferRef;
typedef ObjVar< Verkaeufer > Verkaeufer_var;
typedef ObjOut< Verkaeufer > Verkaeufer_out;

class Kaeufer;
typedef Kaeufer *Kaeufer_ptr;
typedef Kaeufer_ptr KaeuferRef;
typedef ObjVar< Kaeufer > Kaeufer_var;
typedef ObjOut< Kaeufer > Kaeufer_out;

class CCM_Kaeufer;
typedef CCM_Kaeufer *CCM_Kaeufer_ptr;
typedef CCM_Kaeufer_ptr CCM_KaeuferRef;
typedef ObjVar< CCM_Kaeufer > CCM_Kaeufer_var;
typedef ObjOut< CCM_Kaeufer > CCM_Kaeufer_out;

class GebotConsumer;
typedef GebotConsumer *GebotConsumer_ptr;
typedef GebotConsumer_ptr GebotConsumerRef;
typedef ObjVar< GebotConsumer > GebotConsumer_var;
typedef ObjOut< GebotConsumer > GebotConsumer_out;

class Bieter;
typedef Bieter *Bieter_ptr;
typedef Bieter_ptr BieterRef;
typedef ObjVar< Bieter > Bieter_var;
typedef ObjOut< Bieter > Bieter_out;

class CCM_Bieter;
typedef CCM_Bieter *CCM_Bieter_ptr;
typedef CCM_Bieter_ptr CCM_BieterRef;
typedef ObjVar< CCM_Bieter > CCM_Bieter_var;
typedef ObjOut< CCM_Bieter > CCM_Bieter_out;

class CCM_Bieter_Executor;
typedef CCM_Bieter_Executor *CCM_Bieter_Executor_ptr;
typedef CCM_Bieter_Executor_ptr CCM_Bieter_ExecutorRef;
typedef ObjVar< CCM_Bieter_Executor > CCM_Bieter_Executor_var;
typedef ObjOut< CCM_Bieter_Executor > CCM_Bieter_Executor_out;

class CCM_Bieter_Context;
typedef CCM_Bieter_Context *CCM_Bieter_Context_ptr;
typedef CCM_Bieter_Context_ptr CCM_Bieter_ContextRef;
typedef ObjVar< CCM_Bieter_Context > CCM_Bieter_Context_var;
typedef ObjOut< CCM_Bieter_Context > CCM_Bieter_Context_out;

class CCM_GebotConsumer;
typedef CCM_GebotConsumer *CCM_GebotConsumer_ptr;
typedef CCM_GebotConsumer_ptr CCM_GebotConsumerRef;
typedef ObjVar< CCM_GebotConsumer > CCM_GebotConsumer_var;
typedef ObjOut< CCM_GebotConsumer > CCM_GebotConsumer_out;

class CCM_Versteigerung;
typedef CCM_Versteigerung *CCM_Versteigerung_ptr;
typedef CCM_Versteigerung_ptr CCM_VersteigerungRef;
typedef ObjVar< CCM_Versteigerung > CCM_Versteigerung_var;
typedef ObjOut< CCM_Versteigerung > CCM_Versteigerung_out;

class VersteigerungsFabrik;
typedef VersteigerungsFabrik *VersteigerungsFabrik_ptr;
typedef VersteigerungsFabrik_ptr VersteigerungsFabrikRef;
typedef ObjVar< VersteigerungsFabrik > VersteigerungsFabrik_var;
typedef ObjOut< VersteigerungsFabrik > VersteigerungsFabrik_out;

class KaufConsumer;
typedef KaufConsumer *KaufConsumer_ptr;
typedef KaufConsumer_ptr KaufConsumerRef;
typedef ObjVar< KaufConsumer > KaufConsumer_var;
typedef ObjOut< KaufConsumer > KaufConsumer_out;

class CCM_Verkaeufer;
typedef CCM_Verkaeufer *CCM_Verkaeufer_ptr;
typedef CCM_Verkaeufer_ptr CCM_VerkaeuferRef;
typedef ObjVar< CCM_Verkaeufer > CCM_Verkaeufer_var;
typedef ObjOut< CCM_Verkaeufer > CCM_Verkaeufer_out;

class CCM_Verkaeufer_Executor;
typedef CCM_Verkaeufer_Executor *CCM_Verkaeufer_Executor_ptr;
typedef CCM_Verkaeufer_Executor_ptr CCM_Verkaeufer_ExecutorRef;
typedef ObjVar< CCM_Verkaeufer_Executor > CCM_Verkaeufer_Executor_var;
typedef ObjOut< CCM_Verkaeufer_Executor > CCM_Verkaeufer_Executor_out;

class CCM_Verkaeufer_Context;
typedef CCM_Verkaeufer_Context *CCM_Verkaeufer_Context_ptr;
typedef CCM_Verkaeufer_Context_ptr CCM_Verkaeufer_ContextRef;
typedef ObjVar< CCM_Verkaeufer_Context > CCM_Verkaeufer_Context_var;
typedef ObjOut< CCM_Verkaeufer_Context > CCM_Verkaeufer_Context_out;

class CCM_VersteigerungsFabrik;
typedef CCM_VersteigerungsFabrik *CCM_VersteigerungsFabrik_ptr;
typedef CCM_VersteigerungsFabrik_ptr CCM_VersteigerungsFabrikRef;
typedef ObjVar< CCM_VersteigerungsFabrik > CCM_VersteigerungsFabrik_var;
typedef ObjOut< CCM_VersteigerungsFabrik > CCM_VersteigerungsFabrik_out;

class CCM_KaufConsumer;
typedef CCM_KaufConsumer *CCM_KaufConsumer_ptr;
typedef CCM_KaufConsumer_ptr CCM_KaufConsumerRef;
typedef ObjVar< CCM_KaufConsumer > CCM_KaufConsumer_var;
typedef ObjOut< CCM_KaufConsumer > CCM_KaufConsumer_out;

class Auktionshaus;
typedef Auktionshaus *Auktionshaus_ptr;
typedef Auktionshaus_ptr AuktionshausRef;
typedef ObjVar< Auktionshaus > Auktionshaus_var;
typedef ObjOut< Auktionshaus > Auktionshaus_out;

class CCM_Auktionshaus;
typedef CCM_Auktionshaus *CCM_Auktionshaus_ptr;
typedef CCM_Auktionshaus_ptr CCM_AuktionshausRef;
typedef ObjVar< CCM_Auktionshaus > CCM_Auktionshaus_var;
typedef ObjOut< CCM_Auktionshaus > CCM_Auktionshaus_out;

class CCM_Auktionshaus_Executor;
typedef CCM_Auktionshaus_Executor *CCM_Auktionshaus_Executor_ptr;
typedef CCM_Auktionshaus_Executor_ptr CCM_Auktionshaus_ExecutorRef;
typedef ObjVar< CCM_Auktionshaus_Executor > CCM_Auktionshaus_Executor_var;
typedef ObjOut< CCM_Auktionshaus_Executor > CCM_Auktionshaus_Executor_out;

class CCM_Auktionshaus_Context;
typedef CCM_Auktionshaus_Context *CCM_Auktionshaus_Context_ptr;
typedef CCM_Auktionshaus_Context_ptr CCM_Auktionshaus_ContextRef;
typedef ObjVar< CCM_Auktionshaus_Context > CCM_Auktionshaus_Context_var;
typedef ObjOut< CCM_Auktionshaus_Context > CCM_Auktionshaus_Context_out;

class WeltExplicit;
typedef WeltExplicit *WeltExplicit_ptr;
typedef WeltExplicit_ptr WeltExplicitRef;
typedef ObjVar< WeltExplicit > WeltExplicit_var;
typedef ObjOut< WeltExplicit > WeltExplicit_out;

class WeltImplicit;
typedef WeltImplicit *WeltImplicit_ptr;
typedef WeltImplicit_ptr WeltImplicitRef;
typedef ObjVar< WeltImplicit > WeltImplicit_var;
typedef ObjOut< WeltImplicit > WeltImplicit_out;

class Welt;
typedef Welt *Welt_ptr;
typedef Welt_ptr WeltRef;
typedef ObjVar< Welt > Welt_var;
typedef ObjOut< Welt > Welt_out;

class CCM_WeltExplicit;
typedef CCM_WeltExplicit *CCM_WeltExplicit_ptr;
typedef CCM_WeltExplicit_ptr CCM_WeltExplicitRef;
typedef ObjVar< CCM_WeltExplicit > CCM_WeltExplicit_var;
typedef ObjOut< CCM_WeltExplicit > CCM_WeltExplicit_out;

class CCM_WeltImplicit;
typedef CCM_WeltImplicit *CCM_WeltImplicit_ptr;
typedef CCM_WeltImplicit_ptr CCM_WeltImplicitRef;
typedef ObjVar< CCM_WeltImplicit > CCM_WeltImplicit_var;
typedef ObjOut< CCM_WeltImplicit > CCM_WeltImplicit_out;

class CCM_Welt;
typedef CCM_Welt *CCM_Welt_ptr;
typedef CCM_Welt_ptr CCM_WeltRef;
typedef ObjVar< CCM_Welt > CCM_Welt_var;
typedef ObjOut< CCM_Welt > CCM_Welt_out;

class ProduktFilter;
typedef ProduktFilter *ProduktFilter_ptr;
typedef ProduktFilter_ptr ProduktFilterRef;
typedef ObjVar< ProduktFilter > ProduktFilter_var;
typedef ObjOut< ProduktFilter > ProduktFilter_out;

class CCM_ProduktFilter;
typedef CCM_ProduktFilter *CCM_ProduktFilter_ptr;
typedef CCM_ProduktFilter_ptr CCM_ProduktFilterRef;
typedef ObjVar< CCM_ProduktFilter > CCM_ProduktFilter_var;
typedef ObjOut< CCM_ProduktFilter > CCM_ProduktFilter_out;

class CCM_ProduktFilter_Executor;
typedef CCM_ProduktFilter_Executor *CCM_ProduktFilter_Executor_ptr;
typedef CCM_ProduktFilter_Executor_ptr CCM_ProduktFilter_ExecutorRef;
typedef ObjVar< CCM_ProduktFilter_Executor > CCM_ProduktFilter_Executor_var;
typedef ObjOut< CCM_ProduktFilter_Executor > CCM_ProduktFilter_Executor_out;

class CCM_ProduktFilter_Context;
typedef CCM_ProduktFilter_Context *CCM_ProduktFilter_Context_ptr;
typedef CCM_ProduktFilter_Context_ptr CCM_ProduktFilter_ContextRef;
typedef ObjVar< CCM_ProduktFilter_Context > CCM_ProduktFilter_Context_var;
typedef ObjOut< CCM_ProduktFilter_Context > CCM_ProduktFilter_Context_out;

class FilterHomeExplicit;
typedef FilterHomeExplicit *FilterHomeExplicit_ptr;
typedef FilterHomeExplicit_ptr FilterHomeExplicitRef;
typedef ObjVar< FilterHomeExplicit > FilterHomeExplicit_var;
typedef ObjOut< FilterHomeExplicit > FilterHomeExplicit_out;

class FilterHomeImplicit;
typedef FilterHomeImplicit *FilterHomeImplicit_ptr;
typedef FilterHomeImplicit_ptr FilterHomeImplicitRef;
typedef ObjVar< FilterHomeImplicit > FilterHomeImplicit_var;
typedef ObjOut< FilterHomeImplicit > FilterHomeImplicit_out;

class FilterHome;
typedef FilterHome *FilterHome_ptr;
typedef FilterHome_ptr FilterHomeRef;
typedef ObjVar< FilterHome > FilterHome_var;
typedef ObjOut< FilterHome > FilterHome_out;

class CCM_FilterHomeExplicit;
typedef CCM_FilterHomeExplicit *CCM_FilterHomeExplicit_ptr;
typedef CCM_FilterHomeExplicit_ptr CCM_FilterHomeExplicitRef;
typedef ObjVar< CCM_FilterHomeExplicit > CCM_FilterHomeExplicit_var;
typedef ObjOut< CCM_FilterHomeExplicit > CCM_FilterHomeExplicit_out;

class CCM_FilterHomeImplicit;
typedef CCM_FilterHomeImplicit *CCM_FilterHomeImplicit_ptr;
typedef CCM_FilterHomeImplicit_ptr CCM_FilterHomeImplicitRef;
typedef ObjVar< CCM_FilterHomeImplicit > CCM_FilterHomeImplicit_var;
typedef ObjOut< CCM_FilterHomeImplicit > CCM_FilterHomeImplicit_out;

class CCM_FilterHome;
typedef CCM_FilterHome *CCM_FilterHome_ptr;
typedef CCM_FilterHome_ptr CCM_FilterHomeRef;
typedef ObjVar< CCM_FilterHome > CCM_FilterHome_var;
typedef ObjOut< CCM_FilterHome > CCM_FilterHome_out;

class BieterHomeExplicit;
typedef BieterHomeExplicit *BieterHomeExplicit_ptr;
typedef BieterHomeExplicit_ptr BieterHomeExplicitRef;
typedef ObjVar< BieterHomeExplicit > BieterHomeExplicit_var;
typedef ObjOut< BieterHomeExplicit > BieterHomeExplicit_out;

class BieterHomeImplicit;
typedef BieterHomeImplicit *BieterHomeImplicit_ptr;
typedef BieterHomeImplicit_ptr BieterHomeImplicitRef;
typedef ObjVar< BieterHomeImplicit > BieterHomeImplicit_var;
typedef ObjOut< BieterHomeImplicit > BieterHomeImplicit_out;

class BieterHome;
typedef BieterHome *BieterHome_ptr;
typedef BieterHome_ptr BieterHomeRef;
typedef ObjVar< BieterHome > BieterHome_var;
typedef ObjOut< BieterHome > BieterHome_out;

class CCM_BieterHomeExplicit;
typedef CCM_BieterHomeExplicit *CCM_BieterHomeExplicit_ptr;
typedef CCM_BieterHomeExplicit_ptr CCM_BieterHomeExplicitRef;
typedef ObjVar< CCM_BieterHomeExplicit > CCM_BieterHomeExplicit_var;
typedef ObjOut< CCM_BieterHomeExplicit > CCM_BieterHomeExplicit_out;

class CCM_BieterHomeImplicit;
typedef CCM_BieterHomeImplicit *CCM_BieterHomeImplicit_ptr;
typedef CCM_BieterHomeImplicit_ptr CCM_BieterHomeImplicitRef;
typedef ObjVar< CCM_BieterHomeImplicit > CCM_BieterHomeImplicit_var;
typedef ObjOut< CCM_BieterHomeImplicit > CCM_BieterHomeImplicit_out;

class CCM_BieterHome;
typedef CCM_BieterHome *CCM_BieterHome_ptr;
typedef CCM_BieterHome_ptr CCM_BieterHomeRef;
typedef ObjVar< CCM_BieterHome > CCM_BieterHome_var;
typedef ObjOut< CCM_BieterHome > CCM_BieterHome_out;

class VerkaeuferHomeExplicit;
typedef VerkaeuferHomeExplicit *VerkaeuferHomeExplicit_ptr;
typedef VerkaeuferHomeExplicit_ptr VerkaeuferHomeExplicitRef;
typedef ObjVar< VerkaeuferHomeExplicit > VerkaeuferHomeExplicit_var;
typedef ObjOut< VerkaeuferHomeExplicit > VerkaeuferHomeExplicit_out;

class VerkaeuferHomeImplicit;
typedef VerkaeuferHomeImplicit *VerkaeuferHomeImplicit_ptr;
typedef VerkaeuferHomeImplicit_ptr VerkaeuferHomeImplicitRef;
typedef ObjVar< VerkaeuferHomeImplicit > VerkaeuferHomeImplicit_var;
typedef ObjOut< VerkaeuferHomeImplicit > VerkaeuferHomeImplicit_out;

class VerkaeuferHome;
typedef VerkaeuferHome *VerkaeuferHome_ptr;
typedef VerkaeuferHome_ptr VerkaeuferHomeRef;
typedef ObjVar< VerkaeuferHome > VerkaeuferHome_var;
typedef ObjOut< VerkaeuferHome > VerkaeuferHome_out;

class CCM_VerkaeuferHomeExplicit;
typedef CCM_VerkaeuferHomeExplicit *CCM_VerkaeuferHomeExplicit_ptr;
typedef CCM_VerkaeuferHomeExplicit_ptr CCM_VerkaeuferHomeExplicitRef;
typedef ObjVar< CCM_VerkaeuferHomeExplicit > CCM_VerkaeuferHomeExplicit_var;
typedef ObjOut< CCM_VerkaeuferHomeExplicit > CCM_VerkaeuferHomeExplicit_out;

class CCM_VerkaeuferHomeImplicit;
typedef CCM_VerkaeuferHomeImplicit *CCM_VerkaeuferHomeImplicit_ptr;
typedef CCM_VerkaeuferHomeImplicit_ptr CCM_VerkaeuferHomeImplicitRef;
typedef ObjVar< CCM_VerkaeuferHomeImplicit > CCM_VerkaeuferHomeImplicit_var;
typedef ObjOut< CCM_VerkaeuferHomeImplicit > CCM_VerkaeuferHomeImplicit_out;

class CCM_VerkaeuferHome;
typedef CCM_VerkaeuferHome *CCM_VerkaeuferHome_ptr;
typedef CCM_VerkaeuferHome_ptr CCM_VerkaeuferHomeRef;
typedef ObjVar< CCM_VerkaeuferHome > CCM_VerkaeuferHome_var;
typedef ObjOut< CCM_VerkaeuferHome > CCM_VerkaeuferHome_out;

}



#include "C:/Studium/Übungen/Corba/mico/include/mico/CCM.h"



namespace Auktion
{


/*
 * Base class and common definitions for interface Kaeufer
 */

class Kaeufer : 
  virtual public CORBA::Object
{
  public:
    virtual ~Kaeufer();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Kaeufer_ptr _ptr_type;
    typedef Kaeufer_var _var_type;
    #endif

    static Kaeufer_ptr _narrow( CORBA::Object_ptr obj );
    static Kaeufer_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Kaeufer_ptr _duplicate( Kaeufer_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Kaeufer_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void zuschlag( Versteigerung_ptr gegenstand, Verkaeufer_ptr v ) = 0;

  protected:
    Kaeufer() {};
  private:
    Kaeufer( const Kaeufer& );
    void operator=( const Kaeufer& );
};

// Stub for interface Kaeufer
class Kaeufer_stub:
  virtual public Kaeufer
{
  public:
    virtual ~Kaeufer_stub();
    void zuschlag( Versteigerung_ptr gegenstand, Verkaeufer_ptr v );

  private:
    void operator=( const Kaeufer_stub& );
};

#ifndef MICO_CONF_NO_POA

class Kaeufer_stub_clp :
  virtual public Kaeufer_stub,
  virtual public PortableServer::StubBase
{
  public:
    Kaeufer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Kaeufer_stub_clp ();
    void zuschlag( Versteigerung_ptr gegenstand, Verkaeufer_ptr v );

  protected:
    Kaeufer_stub_clp ();
  private:
    void operator=( const Kaeufer_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for local interface CCM_Kaeufer
 */

class CCM_Kaeufer : 
  virtual public CORBA::LocalObject,
  virtual public ::Auktion::Kaeufer
{
  public:
    virtual ~CCM_Kaeufer();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_Kaeufer_ptr _ptr_type;
    typedef CCM_Kaeufer_var _var_type;
    #endif

    static CCM_Kaeufer_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_Kaeufer_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_Kaeufer_ptr _duplicate( CCM_Kaeufer_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_Kaeufer_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_Kaeufer() {};
  private:
    CCM_Kaeufer( const CCM_Kaeufer& );
    void operator=( const CCM_Kaeufer& );
};



/*
 * Base class and common definitions for interface Bieter
 */

class Bieter : 
  virtual public ::Components::CCMObject,
  virtual public ::Auktion::Kaeufer
{
  public:
    virtual ~Bieter();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Bieter_ptr _ptr_type;
    typedef Bieter_var _var_type;
    #endif

    static Bieter_ptr _narrow( CORBA::Object_ptr obj );
    static Bieter_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Bieter_ptr _duplicate( Bieter_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Bieter_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    struct versteigerungenConnection;
    typedef TVarVar< versteigerungenConnection > versteigerungenConnection_var;
    typedef TVarOut< versteigerungenConnection > versteigerungenConnection_out;


    struct versteigerungenConnection {
      #ifdef HAVE_TYPEDEF_OVERLOAD
      typedef versteigerungenConnection_var _var_type;
      #endif
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      versteigerungenConnection();
      ~versteigerungenConnection();
      versteigerungenConnection( const versteigerungenConnection& s );
      versteigerungenConnection& operator=( const versteigerungenConnection& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      Versteigerung_var objref;
      ::Components::Cookie_var ck;
      // we contain a valuetype
      CORBA::Long _count_refs (CORBA::ValueBase::visited * = 0);
      void _release_members ();
    };

    typedef SequenceTmpl< versteigerungenConnection,MICO_TID_DEF> versteigerungenConnections;
    typedef TSeqVar< SequenceTmpl< versteigerungenConnection,MICO_TID_DEF> > versteigerungenConnections_var;
    typedef TSeqOut< SequenceTmpl< versteigerungenConnection,MICO_TID_DEF> > versteigerungenConnections_out;

    virtual GebotConsumer_ptr get_consumer_gebote() = 0;
    virtual ::Components::Cookie* connect_versteigerungen( Versteigerung_ptr connection ) = 0;
    virtual Versteigerung_ptr disconnect_versteigerungen( ::Components::Cookie* ck ) = 0;
    virtual versteigerungenConnections* get_connections_versteigerungen() = 0;

  protected:
    Bieter() {};
  private:
    Bieter( const Bieter& );
    void operator=( const Bieter& );
};

// Stub for interface Bieter
class Bieter_stub:
  virtual public Bieter,
  virtual public ::Components::CCMObject_stub,
  virtual public ::Auktion::Kaeufer_stub
{
  public:
    virtual ~Bieter_stub();
    GebotConsumer_ptr get_consumer_gebote();
    ::Components::Cookie* connect_versteigerungen( Versteigerung_ptr connection );
    Versteigerung_ptr disconnect_versteigerungen( ::Components::Cookie* ck );
    versteigerungenConnections* get_connections_versteigerungen();

  private:
    void operator=( const Bieter_stub& );
};

#ifndef MICO_CONF_NO_POA

class Bieter_stub_clp :
  virtual public Bieter_stub,
  virtual public ::Components::CCMObject_stub_clp,
  virtual public ::Auktion::Kaeufer_stub_clp
{
  public:
    Bieter_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Bieter_stub_clp ();
    GebotConsumer_ptr get_consumer_gebote();
    ::Components::Cookie* connect_versteigerungen( Versteigerung_ptr connection );
    Versteigerung_ptr disconnect_versteigerungen( ::Components::Cookie* ck );
    versteigerungenConnections* get_connections_versteigerungen();

  protected:
    Bieter_stub_clp ();
  private:
    void operator=( const Bieter_stub_clp & );
};

#endif // MICO_CONF_NO_POA

class Gebot;
typedef Gebot *Gebot_ptr;
typedef Gebot_ptr GebotRef;
typedef ValueVar< Gebot > Gebot_var;
typedef ValueOut< Gebot > Gebot_out;


/*
 * Base class and common definitions for local interface CCM_Bieter
 */

class CCM_Bieter : 
  virtual public ::Components::EnterpriseComponent,
  virtual public ::Auktion::Kaeufer
{
  public:
    virtual ~CCM_Bieter();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_Bieter_ptr _ptr_type;
    typedef CCM_Bieter_var _var_type;
    #endif

    static CCM_Bieter_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_Bieter_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_Bieter_ptr _duplicate( CCM_Bieter_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_Bieter_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void push_gebote( Gebot* conxn ) = 0;

  protected:
    CCM_Bieter() {};
  private:
    CCM_Bieter( const CCM_Bieter& );
    void operator=( const CCM_Bieter& );
};



/*
 * Base class and common definitions for local interface CCM_Bieter_Executor
 */

class CCM_Bieter_Executor : 
  virtual public ::Components::EnterpriseComponent,
  virtual public ::Auktion::Kaeufer
{
  public:
    virtual ~CCM_Bieter_Executor();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_Bieter_Executor_ptr _ptr_type;
    typedef CCM_Bieter_Executor_var _var_type;
    #endif

    static CCM_Bieter_Executor_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_Bieter_Executor_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_Bieter_Executor_ptr _duplicate( CCM_Bieter_Executor_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_Bieter_Executor_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_Bieter_Executor() {};
  private:
    CCM_Bieter_Executor( const CCM_Bieter_Executor& );
    void operator=( const CCM_Bieter_Executor& );
};



/*
 * Base class and common definitions for local interface CCM_Bieter_Context
 */

class CCM_Bieter_Context : 
  virtual public ::Components::SessionContext
{
  public:
    virtual ~CCM_Bieter_Context();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_Bieter_Context_ptr _ptr_type;
    typedef CCM_Bieter_Context_var _var_type;
    #endif

    static CCM_Bieter_Context_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_Bieter_Context_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_Bieter_Context_ptr _duplicate( CCM_Bieter_Context_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_Bieter_Context_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Bieter::versteigerungenConnections* get_connections_versteigerungen() = 0;

  protected:
    CCM_Bieter_Context() {};
  private:
    CCM_Bieter_Context( const CCM_Bieter_Context& );
    void operator=( const CCM_Bieter_Context& );
};



// Common definitions for valuetype Gebot
class Gebot : 
  virtual public ::Components::EventBase
{
  public:
    static Gebot* _downcast (CORBA::ValueBase *);
    static Gebot* _downcast (CORBA::AbstractBase *);

    virtual void gegenstand( Versteigerung_ptr _p ) = 0;
    virtual Versteigerung_ptr gegenstand() const = 0;

    virtual void angebot( CORBA::Long _p ) = 0;
    virtual CORBA::Long angebot() const = 0;


  public:
    CORBA::ValueBase * _copy_value ();
    CORBA::ValueDef_ptr get_value_def ();
    virtual void * _narrow_helper (const char *);
    void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
    void _marshal_members (CORBA::DataEncoder &);
    CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);

  protected:
    Gebot ();
    virtual ~Gebot ();
    void _copy_members (const Gebot&);

  private:
    Gebot (const Gebot &);
    void operator= (const Gebot &);
};


/*
 * Base class and common definitions for interface GebotConsumer
 */

class GebotConsumer : 
  virtual public ::Components::EventConsumerBase
{
  public:
    virtual ~GebotConsumer();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef GebotConsumer_ptr _ptr_type;
    typedef GebotConsumer_var _var_type;
    #endif

    static GebotConsumer_ptr _narrow( CORBA::Object_ptr obj );
    static GebotConsumer_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static GebotConsumer_ptr _duplicate( GebotConsumer_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static GebotConsumer_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void push_Gebot( Gebot* event ) = 0;

  protected:
    GebotConsumer() {};
  private:
    GebotConsumer( const GebotConsumer& );
    void operator=( const GebotConsumer& );
};

// Stub for interface GebotConsumer
class GebotConsumer_stub:
  virtual public GebotConsumer,
  virtual public ::Components::EventConsumerBase_stub
{
  public:
    virtual ~GebotConsumer_stub();
    void push_Gebot( Gebot* event );

  private:
    void operator=( const GebotConsumer_stub& );
};

#ifndef MICO_CONF_NO_POA

class GebotConsumer_stub_clp :
  virtual public GebotConsumer_stub,
  virtual public ::Components::EventConsumerBase_stub_clp
{
  public:
    GebotConsumer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~GebotConsumer_stub_clp ();
    void push_Gebot( Gebot* event );

  protected:
    GebotConsumer_stub_clp ();
  private:
    void operator=( const GebotConsumer_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for local interface CCM_GebotConsumer
 */

class CCM_GebotConsumer : 
  virtual public CORBA::LocalObject
{
  public:
    virtual ~CCM_GebotConsumer();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_GebotConsumer_ptr _ptr_type;
    typedef CCM_GebotConsumer_var _var_type;
    #endif

    static CCM_GebotConsumer_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_GebotConsumer_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_GebotConsumer_ptr _duplicate( CCM_GebotConsumer_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_GebotConsumer_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void push( Gebot* event ) = 0;

  protected:
    CCM_GebotConsumer() {};
  private:
    CCM_GebotConsumer( const CCM_GebotConsumer& );
    void operator=( const CCM_GebotConsumer& );
};



/*
 * Base class and common definitions for interface Versteigerung
 */

class Versteigerung : 
  virtual public CORBA::Object
{
  public:
    virtual ~Versteigerung();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Versteigerung_ptr _ptr_type;
    typedef Versteigerung_var _var_type;
    #endif

    static Versteigerung_ptr _narrow( CORBA::Object_ptr obj );
    static Versteigerung_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Versteigerung_ptr _duplicate( Versteigerung_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Versteigerung_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual char* name() = 0;
    virtual CORBA::Long aktuelles_gebot() = 0;

    virtual void biete( CORBA::Long gebot, Bieter_ptr potentieller_kaeufer ) = 0;

  protected:
    Versteigerung() {};
  private:
    Versteigerung( const Versteigerung& );
    void operator=( const Versteigerung& );
};

// Stub for interface Versteigerung
class Versteigerung_stub:
  virtual public Versteigerung
{
  public:
    virtual ~Versteigerung_stub();
    char* name();
    CORBA::Long aktuelles_gebot();

    void biete( CORBA::Long gebot, Bieter_ptr potentieller_kaeufer );

  private:
    void operator=( const Versteigerung_stub& );
};

#ifndef MICO_CONF_NO_POA

class Versteigerung_stub_clp :
  virtual public Versteigerung_stub,
  virtual public PortableServer::StubBase
{
  public:
    Versteigerung_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Versteigerung_stub_clp ();
    char* name();
    CORBA::Long aktuelles_gebot();

    void biete( CORBA::Long gebot, Bieter_ptr potentieller_kaeufer );

  protected:
    Versteigerung_stub_clp ();
  private:
    void operator=( const Versteigerung_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for local interface CCM_Versteigerung
 */

class CCM_Versteigerung : 
  virtual public CORBA::LocalObject,
  virtual public ::Auktion::Versteigerung
{
  public:
    virtual ~CCM_Versteigerung();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_Versteigerung_ptr _ptr_type;
    typedef CCM_Versteigerung_var _var_type;
    #endif

    static CCM_Versteigerung_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_Versteigerung_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_Versteigerung_ptr _duplicate( CCM_Versteigerung_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_Versteigerung_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_Versteigerung() {};
  private:
    CCM_Versteigerung( const CCM_Versteigerung& );
    void operator=( const CCM_Versteigerung& );
};



/*
 * Base class and common definitions for interface Verkaeufer
 */

class Verkaeufer : 
  virtual public ::Components::CCMObject
{
  public:
    virtual ~Verkaeufer();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Verkaeufer_ptr _ptr_type;
    typedef Verkaeufer_var _var_type;
    #endif

    static Verkaeufer_ptr _narrow( CORBA::Object_ptr obj );
    static Verkaeufer_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Verkaeufer_ptr _duplicate( Verkaeufer_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Verkaeufer_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void connect_handelsplatz( VersteigerungsFabrik_ptr conxn ) = 0;
    virtual VersteigerungsFabrik_ptr disconnect_handelsplatz() = 0;
    virtual VersteigerungsFabrik_ptr get_connection_handelsplatz() = 0;
    virtual KaufConsumer_ptr get_consumer_zuschlag() = 0;

  protected:
    Verkaeufer() {};
  private:
    Verkaeufer( const Verkaeufer& );
    void operator=( const Verkaeufer& );
};

// Stub for interface Verkaeufer
class Verkaeufer_stub:
  virtual public Verkaeufer,
  virtual public ::Components::CCMObject_stub
{
  public:
    virtual ~Verkaeufer_stub();
    void connect_handelsplatz( VersteigerungsFabrik_ptr conxn );
    VersteigerungsFabrik_ptr disconnect_handelsplatz();
    VersteigerungsFabrik_ptr get_connection_handelsplatz();
    KaufConsumer_ptr get_consumer_zuschlag();

  private:
    void operator=( const Verkaeufer_stub& );
};

#ifndef MICO_CONF_NO_POA

class Verkaeufer_stub_clp :
  virtual public Verkaeufer_stub,
  virtual public ::Components::CCMObject_stub_clp
{
  public:
    Verkaeufer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Verkaeufer_stub_clp ();
    void connect_handelsplatz( VersteigerungsFabrik_ptr conxn );
    VersteigerungsFabrik_ptr disconnect_handelsplatz();
    VersteigerungsFabrik_ptr get_connection_handelsplatz();
    KaufConsumer_ptr get_consumer_zuschlag();

  protected:
    Verkaeufer_stub_clp ();
  private:
    void operator=( const Verkaeufer_stub_clp & );
};

#endif // MICO_CONF_NO_POA

class Kauf;
typedef Kauf *Kauf_ptr;
typedef Kauf_ptr KaufRef;
typedef ValueVar< Kauf > Kauf_var;
typedef ValueOut< Kauf > Kauf_out;


/*
 * Base class and common definitions for local interface CCM_Verkaeufer
 */

class CCM_Verkaeufer : 
  virtual public ::Components::EnterpriseComponent
{
  public:
    virtual ~CCM_Verkaeufer();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_Verkaeufer_ptr _ptr_type;
    typedef CCM_Verkaeufer_var _var_type;
    #endif

    static CCM_Verkaeufer_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_Verkaeufer_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_Verkaeufer_ptr _duplicate( CCM_Verkaeufer_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_Verkaeufer_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void push_zuschlag( Kauf* conxn ) = 0;

  protected:
    CCM_Verkaeufer() {};
  private:
    CCM_Verkaeufer( const CCM_Verkaeufer& );
    void operator=( const CCM_Verkaeufer& );
};



/*
 * Base class and common definitions for local interface CCM_Verkaeufer_Executor
 */

class CCM_Verkaeufer_Executor : 
  virtual public ::Components::EnterpriseComponent
{
  public:
    virtual ~CCM_Verkaeufer_Executor();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_Verkaeufer_Executor_ptr _ptr_type;
    typedef CCM_Verkaeufer_Executor_var _var_type;
    #endif

    static CCM_Verkaeufer_Executor_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_Verkaeufer_Executor_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_Verkaeufer_Executor_ptr _duplicate( CCM_Verkaeufer_Executor_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_Verkaeufer_Executor_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_Verkaeufer_Executor() {};
  private:
    CCM_Verkaeufer_Executor( const CCM_Verkaeufer_Executor& );
    void operator=( const CCM_Verkaeufer_Executor& );
};



/*
 * Base class and common definitions for local interface CCM_Verkaeufer_Context
 */

class CCM_Verkaeufer_Context : 
  virtual public ::Components::SessionContext
{
  public:
    virtual ~CCM_Verkaeufer_Context();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_Verkaeufer_Context_ptr _ptr_type;
    typedef CCM_Verkaeufer_Context_var _var_type;
    #endif

    static CCM_Verkaeufer_Context_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_Verkaeufer_Context_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_Verkaeufer_Context_ptr _duplicate( CCM_Verkaeufer_Context_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_Verkaeufer_Context_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual VersteigerungsFabrik_ptr get_connection_handelsplatz() = 0;

  protected:
    CCM_Verkaeufer_Context() {};
  private:
    CCM_Verkaeufer_Context( const CCM_Verkaeufer_Context& );
    void operator=( const CCM_Verkaeufer_Context& );
};



/*
 * Base class and common definitions for interface VersteigerungsFabrik
 */

class VersteigerungsFabrik : 
  virtual public CORBA::Object
{
  public:
    virtual ~VersteigerungsFabrik();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef VersteigerungsFabrik_ptr _ptr_type;
    typedef VersteigerungsFabrik_var _var_type;
    #endif

    static VersteigerungsFabrik_ptr _narrow( CORBA::Object_ptr obj );
    static VersteigerungsFabrik_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static VersteigerungsFabrik_ptr _duplicate( VersteigerungsFabrik_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static VersteigerungsFabrik_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Versteigerung_ptr neue_auktion( const char* name, CORBA::Long minimalgebot, Verkaeufer_ptr besitzer ) = 0;

  protected:
    VersteigerungsFabrik() {};
  private:
    VersteigerungsFabrik( const VersteigerungsFabrik& );
    void operator=( const VersteigerungsFabrik& );
};

// Stub for interface VersteigerungsFabrik
class VersteigerungsFabrik_stub:
  virtual public VersteigerungsFabrik
{
  public:
    virtual ~VersteigerungsFabrik_stub();
    Versteigerung_ptr neue_auktion( const char* name, CORBA::Long minimalgebot, Verkaeufer_ptr besitzer );

  private:
    void operator=( const VersteigerungsFabrik_stub& );
};

#ifndef MICO_CONF_NO_POA

class VersteigerungsFabrik_stub_clp :
  virtual public VersteigerungsFabrik_stub,
  virtual public PortableServer::StubBase
{
  public:
    VersteigerungsFabrik_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~VersteigerungsFabrik_stub_clp ();
    Versteigerung_ptr neue_auktion( const char* name, CORBA::Long minimalgebot, Verkaeufer_ptr besitzer );

  protected:
    VersteigerungsFabrik_stub_clp ();
  private:
    void operator=( const VersteigerungsFabrik_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for local interface CCM_VersteigerungsFabrik
 */

class CCM_VersteigerungsFabrik : 
  virtual public CORBA::LocalObject,
  virtual public ::Auktion::VersteigerungsFabrik
{
  public:
    virtual ~CCM_VersteigerungsFabrik();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_VersteigerungsFabrik_ptr _ptr_type;
    typedef CCM_VersteigerungsFabrik_var _var_type;
    #endif

    static CCM_VersteigerungsFabrik_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_VersteigerungsFabrik_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_VersteigerungsFabrik_ptr _duplicate( CCM_VersteigerungsFabrik_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_VersteigerungsFabrik_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_VersteigerungsFabrik() {};
  private:
    CCM_VersteigerungsFabrik( const CCM_VersteigerungsFabrik& );
    void operator=( const CCM_VersteigerungsFabrik& );
};



// Common definitions for valuetype Kauf
class Kauf : 
  virtual public ::Auktion::Gebot
{
  public:
    static Kauf* _downcast (CORBA::ValueBase *);
    static Kauf* _downcast (CORBA::AbstractBase *);

    virtual void kaeufer( Kaeufer_ptr _p ) = 0;
    virtual Kaeufer_ptr kaeufer() const = 0;


  public:
    CORBA::ValueBase * _copy_value ();
    CORBA::ValueDef_ptr get_value_def ();
    virtual void * _narrow_helper (const char *);
    void _get_marshal_info (std::vector<std::string> &, CORBA::Boolean &);
    void _marshal_members (CORBA::DataEncoder &);
    CORBA::Boolean _demarshal_members (CORBA::DataDecoder &);

  protected:
    Kauf ();
    virtual ~Kauf ();
    void _copy_members (const Kauf&);

  private:
    Kauf (const Kauf &);
    void operator= (const Kauf &);
};


/*
 * Base class and common definitions for interface KaufConsumer
 */

class KaufConsumer : 
  virtual public ::Components::EventConsumerBase
{
  public:
    virtual ~KaufConsumer();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef KaufConsumer_ptr _ptr_type;
    typedef KaufConsumer_var _var_type;
    #endif

    static KaufConsumer_ptr _narrow( CORBA::Object_ptr obj );
    static KaufConsumer_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static KaufConsumer_ptr _duplicate( KaufConsumer_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static KaufConsumer_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void push_Kauf( Kauf* event ) = 0;

  protected:
    KaufConsumer() {};
  private:
    KaufConsumer( const KaufConsumer& );
    void operator=( const KaufConsumer& );
};

// Stub for interface KaufConsumer
class KaufConsumer_stub:
  virtual public KaufConsumer,
  virtual public ::Components::EventConsumerBase_stub
{
  public:
    virtual ~KaufConsumer_stub();
    void push_Kauf( Kauf* event );

  private:
    void operator=( const KaufConsumer_stub& );
};

#ifndef MICO_CONF_NO_POA

class KaufConsumer_stub_clp :
  virtual public KaufConsumer_stub,
  virtual public ::Components::EventConsumerBase_stub_clp
{
  public:
    KaufConsumer_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~KaufConsumer_stub_clp ();
    void push_Kauf( Kauf* event );

  protected:
    KaufConsumer_stub_clp ();
  private:
    void operator=( const KaufConsumer_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for local interface CCM_KaufConsumer
 */

class CCM_KaufConsumer : 
  virtual public CORBA::LocalObject
{
  public:
    virtual ~CCM_KaufConsumer();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_KaufConsumer_ptr _ptr_type;
    typedef CCM_KaufConsumer_var _var_type;
    #endif

    static CCM_KaufConsumer_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_KaufConsumer_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_KaufConsumer_ptr _duplicate( CCM_KaufConsumer_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_KaufConsumer_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void push( Kauf* event ) = 0;

  protected:
    CCM_KaufConsumer() {};
  private:
    CCM_KaufConsumer( const CCM_KaufConsumer& );
    void operator=( const CCM_KaufConsumer& );
};



/*
 * Base class and common definitions for interface Auktionshaus
 */

class Auktionshaus : 
  virtual public ::Components::CCMObject
{
  public:
    virtual ~Auktionshaus();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Auktionshaus_ptr _ptr_type;
    typedef Auktionshaus_var _var_type;
    #endif

    static Auktionshaus_ptr _narrow( CORBA::Object_ptr obj );
    static Auktionshaus_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Auktionshaus_ptr _duplicate( Auktionshaus_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Auktionshaus_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual VersteigerungsFabrik_ptr provide_auktionen() = 0;
    virtual ::Components::Cookie* subscribe_gebote( GebotConsumer_ptr consumer ) = 0;
    virtual GebotConsumer_ptr unsubscribe_gebote( ::Components::Cookie* ck ) = 0;

  protected:
    Auktionshaus() {};
  private:
    Auktionshaus( const Auktionshaus& );
    void operator=( const Auktionshaus& );
};

// Stub for interface Auktionshaus
class Auktionshaus_stub:
  virtual public Auktionshaus,
  virtual public ::Components::CCMObject_stub
{
  public:
    virtual ~Auktionshaus_stub();
    VersteigerungsFabrik_ptr provide_auktionen();
    ::Components::Cookie* subscribe_gebote( GebotConsumer_ptr consumer );
    GebotConsumer_ptr unsubscribe_gebote( ::Components::Cookie* ck );

  private:
    void operator=( const Auktionshaus_stub& );
};

#ifndef MICO_CONF_NO_POA

class Auktionshaus_stub_clp :
  virtual public Auktionshaus_stub,
  virtual public ::Components::CCMObject_stub_clp
{
  public:
    Auktionshaus_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Auktionshaus_stub_clp ();
    VersteigerungsFabrik_ptr provide_auktionen();
    ::Components::Cookie* subscribe_gebote( GebotConsumer_ptr consumer );
    GebotConsumer_ptr unsubscribe_gebote( ::Components::Cookie* ck );

  protected:
    Auktionshaus_stub_clp ();
  private:
    void operator=( const Auktionshaus_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for local interface CCM_Auktionshaus
 */

class CCM_Auktionshaus : 
  virtual public ::Components::EnterpriseComponent
{
  public:
    virtual ~CCM_Auktionshaus();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_Auktionshaus_ptr _ptr_type;
    typedef CCM_Auktionshaus_var _var_type;
    #endif

    static CCM_Auktionshaus_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_Auktionshaus_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_Auktionshaus_ptr _duplicate( CCM_Auktionshaus_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_Auktionshaus_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CCM_VersteigerungsFabrik_ptr get_auktionen() = 0;

  protected:
    CCM_Auktionshaus() {};
  private:
    CCM_Auktionshaus( const CCM_Auktionshaus& );
    void operator=( const CCM_Auktionshaus& );
};



/*
 * Base class and common definitions for local interface CCM_Auktionshaus_Executor
 */

class CCM_Auktionshaus_Executor : 
  virtual public ::Components::EnterpriseComponent
{
  public:
    virtual ~CCM_Auktionshaus_Executor();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_Auktionshaus_Executor_ptr _ptr_type;
    typedef CCM_Auktionshaus_Executor_var _var_type;
    #endif

    static CCM_Auktionshaus_Executor_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_Auktionshaus_Executor_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_Auktionshaus_Executor_ptr _duplicate( CCM_Auktionshaus_Executor_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_Auktionshaus_Executor_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_Auktionshaus_Executor() {};
  private:
    CCM_Auktionshaus_Executor( const CCM_Auktionshaus_Executor& );
    void operator=( const CCM_Auktionshaus_Executor& );
};



/*
 * Base class and common definitions for local interface CCM_Auktionshaus_Context
 */

class CCM_Auktionshaus_Context : 
  virtual public ::Components::SessionContext
{
  public:
    virtual ~CCM_Auktionshaus_Context();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_Auktionshaus_Context_ptr _ptr_type;
    typedef CCM_Auktionshaus_Context_var _var_type;
    #endif

    static CCM_Auktionshaus_Context_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_Auktionshaus_Context_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_Auktionshaus_Context_ptr _duplicate( CCM_Auktionshaus_Context_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_Auktionshaus_Context_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void push_gebote( Gebot* event ) = 0;

  protected:
    CCM_Auktionshaus_Context() {};
  private:
    CCM_Auktionshaus_Context( const CCM_Auktionshaus_Context& );
    void operator=( const CCM_Auktionshaus_Context& );
};



/*
 * Base class and common definitions for interface WeltExplicit
 */

class WeltExplicit : 
  virtual public ::Components::CCMHome
{
  public:
    virtual ~WeltExplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef WeltExplicit_ptr _ptr_type;
    typedef WeltExplicit_var _var_type;
    #endif

    static WeltExplicit_ptr _narrow( CORBA::Object_ptr obj );
    static WeltExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static WeltExplicit_ptr _duplicate( WeltExplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static WeltExplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    WeltExplicit() {};
  private:
    WeltExplicit( const WeltExplicit& );
    void operator=( const WeltExplicit& );
};

// Stub for interface WeltExplicit
class WeltExplicit_stub:
  virtual public WeltExplicit,
  virtual public ::Components::CCMHome_stub
{
  public:
    virtual ~WeltExplicit_stub();
  private:
    void operator=( const WeltExplicit_stub& );
};

#ifndef MICO_CONF_NO_POA

class WeltExplicit_stub_clp :
  virtual public WeltExplicit_stub,
  virtual public ::Components::CCMHome_stub_clp
{
  public:
    WeltExplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~WeltExplicit_stub_clp ();
  protected:
    WeltExplicit_stub_clp ();
  private:
    void operator=( const WeltExplicit_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface WeltImplicit
 */

class WeltImplicit : 
  virtual public ::Components::KeylessCCMHome
{
  public:
    virtual ~WeltImplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef WeltImplicit_ptr _ptr_type;
    typedef WeltImplicit_var _var_type;
    #endif

    static WeltImplicit_ptr _narrow( CORBA::Object_ptr obj );
    static WeltImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static WeltImplicit_ptr _duplicate( WeltImplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static WeltImplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Auktionshaus_ptr create() = 0;

  protected:
    WeltImplicit() {};
  private:
    WeltImplicit( const WeltImplicit& );
    void operator=( const WeltImplicit& );
};

// Stub for interface WeltImplicit
class WeltImplicit_stub:
  virtual public WeltImplicit,
  virtual public ::Components::KeylessCCMHome_stub
{
  public:
    virtual ~WeltImplicit_stub();
    Auktionshaus_ptr create();

  private:
    void operator=( const WeltImplicit_stub& );
};

#ifndef MICO_CONF_NO_POA

class WeltImplicit_stub_clp :
  virtual public WeltImplicit_stub,
  virtual public ::Components::KeylessCCMHome_stub_clp
{
  public:
    WeltImplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~WeltImplicit_stub_clp ();
    Auktionshaus_ptr create();

  protected:
    WeltImplicit_stub_clp ();
  private:
    void operator=( const WeltImplicit_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface Welt
 */

class Welt : 
  virtual public ::Auktion::WeltExplicit,
  virtual public ::Auktion::WeltImplicit
{
  public:
    virtual ~Welt();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Welt_ptr _ptr_type;
    typedef Welt_var _var_type;
    #endif

    static Welt_ptr _narrow( CORBA::Object_ptr obj );
    static Welt_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Welt_ptr _duplicate( Welt_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Welt_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    Welt() {};
  private:
    Welt( const Welt& );
    void operator=( const Welt& );
};

// Stub for interface Welt
class Welt_stub:
  virtual public Welt,
  virtual public ::Auktion::WeltExplicit_stub,
  virtual public ::Auktion::WeltImplicit_stub
{
  public:
    virtual ~Welt_stub();
  private:
    void operator=( const Welt_stub& );
};

#ifndef MICO_CONF_NO_POA

class Welt_stub_clp :
  virtual public Welt_stub,
  virtual public ::Auktion::WeltExplicit_stub_clp,
  virtual public ::Auktion::WeltImplicit_stub_clp
{
  public:
    Welt_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Welt_stub_clp ();
  protected:
    Welt_stub_clp ();
  private:
    void operator=( const Welt_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for local interface CCM_WeltExplicit
 */

class CCM_WeltExplicit : 
  virtual public ::Components::HomeExecutorBase
{
  public:
    virtual ~CCM_WeltExplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_WeltExplicit_ptr _ptr_type;
    typedef CCM_WeltExplicit_var _var_type;
    #endif

    static CCM_WeltExplicit_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_WeltExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_WeltExplicit_ptr _duplicate( CCM_WeltExplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_WeltExplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_WeltExplicit() {};
  private:
    CCM_WeltExplicit( const CCM_WeltExplicit& );
    void operator=( const CCM_WeltExplicit& );
};



/*
 * Base class and common definitions for local interface CCM_WeltImplicit
 */

class CCM_WeltImplicit : 
  virtual public CORBA::LocalObject
{
  public:
    virtual ~CCM_WeltImplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_WeltImplicit_ptr _ptr_type;
    typedef CCM_WeltImplicit_var _var_type;
    #endif

    static CCM_WeltImplicit_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_WeltImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_WeltImplicit_ptr _duplicate( CCM_WeltImplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_WeltImplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Components::EnterpriseComponent_ptr create() = 0;

  protected:
    CCM_WeltImplicit() {};
  private:
    CCM_WeltImplicit( const CCM_WeltImplicit& );
    void operator=( const CCM_WeltImplicit& );
};



/*
 * Base class and common definitions for local interface CCM_Welt
 */

class CCM_Welt : 
  virtual public ::Auktion::CCM_WeltExplicit,
  virtual public ::Auktion::CCM_WeltImplicit
{
  public:
    virtual ~CCM_Welt();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_Welt_ptr _ptr_type;
    typedef CCM_Welt_var _var_type;
    #endif

    static CCM_Welt_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_Welt_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_Welt_ptr _duplicate( CCM_Welt_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_Welt_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_Welt() {};
  private:
    CCM_Welt( const CCM_Welt& );
    void operator=( const CCM_Welt& );
};



/*
 * Base class and common definitions for interface ProduktFilter
 */

class ProduktFilter : 
  virtual public ::Components::CCMObject
{
  public:
    virtual ~ProduktFilter();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ProduktFilter_ptr _ptr_type;
    typedef ProduktFilter_var _var_type;
    #endif

    static ProduktFilter_ptr _narrow( CORBA::Object_ptr obj );
    static ProduktFilter_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static ProduktFilter_ptr _duplicate( ProduktFilter_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static ProduktFilter_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual char* interessanter_gegenstand() = 0;
    virtual void interessanter_gegenstand( const char* value ) = 0;

    virtual GebotConsumer_ptr get_consumer_eingehende_gebote() = 0;
    virtual ::Components::Cookie* subscribe_interessante_gebote( GebotConsumer_ptr consumer ) = 0;
    virtual GebotConsumer_ptr unsubscribe_interessante_gebote( ::Components::Cookie* ck ) = 0;

  protected:
    ProduktFilter() {};
  private:
    ProduktFilter( const ProduktFilter& );
    void operator=( const ProduktFilter& );
};

// Stub for interface ProduktFilter
class ProduktFilter_stub:
  virtual public ProduktFilter,
  virtual public ::Components::CCMObject_stub
{
  public:
    virtual ~ProduktFilter_stub();
    char* interessanter_gegenstand();
    void interessanter_gegenstand( const char* value );

    GebotConsumer_ptr get_consumer_eingehende_gebote();
    ::Components::Cookie* subscribe_interessante_gebote( GebotConsumer_ptr consumer );
    GebotConsumer_ptr unsubscribe_interessante_gebote( ::Components::Cookie* ck );

  private:
    void operator=( const ProduktFilter_stub& );
};

#ifndef MICO_CONF_NO_POA

class ProduktFilter_stub_clp :
  virtual public ProduktFilter_stub,
  virtual public ::Components::CCMObject_stub_clp
{
  public:
    ProduktFilter_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~ProduktFilter_stub_clp ();
    char* interessanter_gegenstand();
    void interessanter_gegenstand( const char* value );

    GebotConsumer_ptr get_consumer_eingehende_gebote();
    ::Components::Cookie* subscribe_interessante_gebote( GebotConsumer_ptr consumer );
    GebotConsumer_ptr unsubscribe_interessante_gebote( ::Components::Cookie* ck );

  protected:
    ProduktFilter_stub_clp ();
  private:
    void operator=( const ProduktFilter_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for local interface CCM_ProduktFilter
 */

class CCM_ProduktFilter : 
  virtual public ::Components::EnterpriseComponent
{
  public:
    virtual ~CCM_ProduktFilter();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_ProduktFilter_ptr _ptr_type;
    typedef CCM_ProduktFilter_var _var_type;
    #endif

    static CCM_ProduktFilter_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_ProduktFilter_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_ProduktFilter_ptr _duplicate( CCM_ProduktFilter_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_ProduktFilter_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual char* interessanter_gegenstand() = 0;
    virtual void interessanter_gegenstand( const char* value ) = 0;

    virtual void push_eingehende_gebote( Gebot* conxn ) = 0;

  protected:
    CCM_ProduktFilter() {};
  private:
    CCM_ProduktFilter( const CCM_ProduktFilter& );
    void operator=( const CCM_ProduktFilter& );
};



/*
 * Base class and common definitions for local interface CCM_ProduktFilter_Executor
 */

class CCM_ProduktFilter_Executor : 
  virtual public ::Components::EnterpriseComponent
{
  public:
    virtual ~CCM_ProduktFilter_Executor();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_ProduktFilter_Executor_ptr _ptr_type;
    typedef CCM_ProduktFilter_Executor_var _var_type;
    #endif

    static CCM_ProduktFilter_Executor_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_ProduktFilter_Executor_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_ProduktFilter_Executor_ptr _duplicate( CCM_ProduktFilter_Executor_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_ProduktFilter_Executor_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual char* interessanter_gegenstand() = 0;
    virtual void interessanter_gegenstand( const char* value ) = 0;

  protected:
    CCM_ProduktFilter_Executor() {};
  private:
    CCM_ProduktFilter_Executor( const CCM_ProduktFilter_Executor& );
    void operator=( const CCM_ProduktFilter_Executor& );
};



/*
 * Base class and common definitions for local interface CCM_ProduktFilter_Context
 */

class CCM_ProduktFilter_Context : 
  virtual public ::Components::SessionContext
{
  public:
    virtual ~CCM_ProduktFilter_Context();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_ProduktFilter_Context_ptr _ptr_type;
    typedef CCM_ProduktFilter_Context_var _var_type;
    #endif

    static CCM_ProduktFilter_Context_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_ProduktFilter_Context_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_ProduktFilter_Context_ptr _duplicate( CCM_ProduktFilter_Context_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_ProduktFilter_Context_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual void push_interessante_gebote( Gebot* event ) = 0;

  protected:
    CCM_ProduktFilter_Context() {};
  private:
    CCM_ProduktFilter_Context( const CCM_ProduktFilter_Context& );
    void operator=( const CCM_ProduktFilter_Context& );
};



/*
 * Base class and common definitions for interface FilterHomeExplicit
 */

class FilterHomeExplicit : 
  virtual public ::Components::CCMHome
{
  public:
    virtual ~FilterHomeExplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef FilterHomeExplicit_ptr _ptr_type;
    typedef FilterHomeExplicit_var _var_type;
    #endif

    static FilterHomeExplicit_ptr _narrow( CORBA::Object_ptr obj );
    static FilterHomeExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static FilterHomeExplicit_ptr _duplicate( FilterHomeExplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static FilterHomeExplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ProduktFilter_ptr new_filter( const char* gegenstand ) = 0;

  protected:
    FilterHomeExplicit() {};
  private:
    FilterHomeExplicit( const FilterHomeExplicit& );
    void operator=( const FilterHomeExplicit& );
};

// Stub for interface FilterHomeExplicit
class FilterHomeExplicit_stub:
  virtual public FilterHomeExplicit,
  virtual public ::Components::CCMHome_stub
{
  public:
    virtual ~FilterHomeExplicit_stub();
    ProduktFilter_ptr new_filter( const char* gegenstand );

  private:
    void operator=( const FilterHomeExplicit_stub& );
};

#ifndef MICO_CONF_NO_POA

class FilterHomeExplicit_stub_clp :
  virtual public FilterHomeExplicit_stub,
  virtual public ::Components::CCMHome_stub_clp
{
  public:
    FilterHomeExplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~FilterHomeExplicit_stub_clp ();
    ProduktFilter_ptr new_filter( const char* gegenstand );

  protected:
    FilterHomeExplicit_stub_clp ();
  private:
    void operator=( const FilterHomeExplicit_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface FilterHomeImplicit
 */

class FilterHomeImplicit : 
  virtual public ::Components::KeylessCCMHome
{
  public:
    virtual ~FilterHomeImplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef FilterHomeImplicit_ptr _ptr_type;
    typedef FilterHomeImplicit_var _var_type;
    #endif

    static FilterHomeImplicit_ptr _narrow( CORBA::Object_ptr obj );
    static FilterHomeImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static FilterHomeImplicit_ptr _duplicate( FilterHomeImplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static FilterHomeImplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ProduktFilter_ptr create() = 0;

  protected:
    FilterHomeImplicit() {};
  private:
    FilterHomeImplicit( const FilterHomeImplicit& );
    void operator=( const FilterHomeImplicit& );
};

// Stub for interface FilterHomeImplicit
class FilterHomeImplicit_stub:
  virtual public FilterHomeImplicit,
  virtual public ::Components::KeylessCCMHome_stub
{
  public:
    virtual ~FilterHomeImplicit_stub();
    ProduktFilter_ptr create();

  private:
    void operator=( const FilterHomeImplicit_stub& );
};

#ifndef MICO_CONF_NO_POA

class FilterHomeImplicit_stub_clp :
  virtual public FilterHomeImplicit_stub,
  virtual public ::Components::KeylessCCMHome_stub_clp
{
  public:
    FilterHomeImplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~FilterHomeImplicit_stub_clp ();
    ProduktFilter_ptr create();

  protected:
    FilterHomeImplicit_stub_clp ();
  private:
    void operator=( const FilterHomeImplicit_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface FilterHome
 */

class FilterHome : 
  virtual public ::Auktion::FilterHomeExplicit,
  virtual public ::Auktion::FilterHomeImplicit
{
  public:
    virtual ~FilterHome();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef FilterHome_ptr _ptr_type;
    typedef FilterHome_var _var_type;
    #endif

    static FilterHome_ptr _narrow( CORBA::Object_ptr obj );
    static FilterHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static FilterHome_ptr _duplicate( FilterHome_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static FilterHome_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    FilterHome() {};
  private:
    FilterHome( const FilterHome& );
    void operator=( const FilterHome& );
};

// Stub for interface FilterHome
class FilterHome_stub:
  virtual public FilterHome,
  virtual public ::Auktion::FilterHomeExplicit_stub,
  virtual public ::Auktion::FilterHomeImplicit_stub
{
  public:
    virtual ~FilterHome_stub();
  private:
    void operator=( const FilterHome_stub& );
};

#ifndef MICO_CONF_NO_POA

class FilterHome_stub_clp :
  virtual public FilterHome_stub,
  virtual public ::Auktion::FilterHomeExplicit_stub_clp,
  virtual public ::Auktion::FilterHomeImplicit_stub_clp
{
  public:
    FilterHome_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~FilterHome_stub_clp ();
  protected:
    FilterHome_stub_clp ();
  private:
    void operator=( const FilterHome_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for local interface CCM_FilterHomeExplicit
 */

class CCM_FilterHomeExplicit : 
  virtual public ::Components::HomeExecutorBase
{
  public:
    virtual ~CCM_FilterHomeExplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_FilterHomeExplicit_ptr _ptr_type;
    typedef CCM_FilterHomeExplicit_var _var_type;
    #endif

    static CCM_FilterHomeExplicit_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_FilterHomeExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_FilterHomeExplicit_ptr _duplicate( CCM_FilterHomeExplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_FilterHomeExplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Components::EnterpriseComponent_ptr new_filter( const char* gegenstand ) = 0;

  protected:
    CCM_FilterHomeExplicit() {};
  private:
    CCM_FilterHomeExplicit( const CCM_FilterHomeExplicit& );
    void operator=( const CCM_FilterHomeExplicit& );
};



/*
 * Base class and common definitions for local interface CCM_FilterHomeImplicit
 */

class CCM_FilterHomeImplicit : 
  virtual public CORBA::LocalObject
{
  public:
    virtual ~CCM_FilterHomeImplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_FilterHomeImplicit_ptr _ptr_type;
    typedef CCM_FilterHomeImplicit_var _var_type;
    #endif

    static CCM_FilterHomeImplicit_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_FilterHomeImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_FilterHomeImplicit_ptr _duplicate( CCM_FilterHomeImplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_FilterHomeImplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Components::EnterpriseComponent_ptr create() = 0;

  protected:
    CCM_FilterHomeImplicit() {};
  private:
    CCM_FilterHomeImplicit( const CCM_FilterHomeImplicit& );
    void operator=( const CCM_FilterHomeImplicit& );
};



/*
 * Base class and common definitions for local interface CCM_FilterHome
 */

class CCM_FilterHome : 
  virtual public ::Auktion::CCM_FilterHomeExplicit,
  virtual public ::Auktion::CCM_FilterHomeImplicit
{
  public:
    virtual ~CCM_FilterHome();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_FilterHome_ptr _ptr_type;
    typedef CCM_FilterHome_var _var_type;
    #endif

    static CCM_FilterHome_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_FilterHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_FilterHome_ptr _duplicate( CCM_FilterHome_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_FilterHome_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_FilterHome() {};
  private:
    CCM_FilterHome( const CCM_FilterHome& );
    void operator=( const CCM_FilterHome& );
};



/*
 * Base class and common definitions for interface BieterHomeExplicit
 */

class BieterHomeExplicit : 
  virtual public ::Components::CCMHome
{
  public:
    virtual ~BieterHomeExplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef BieterHomeExplicit_ptr _ptr_type;
    typedef BieterHomeExplicit_var _var_type;
    #endif

    static BieterHomeExplicit_ptr _narrow( CORBA::Object_ptr obj );
    static BieterHomeExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static BieterHomeExplicit_ptr _duplicate( BieterHomeExplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static BieterHomeExplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    BieterHomeExplicit() {};
  private:
    BieterHomeExplicit( const BieterHomeExplicit& );
    void operator=( const BieterHomeExplicit& );
};

// Stub for interface BieterHomeExplicit
class BieterHomeExplicit_stub:
  virtual public BieterHomeExplicit,
  virtual public ::Components::CCMHome_stub
{
  public:
    virtual ~BieterHomeExplicit_stub();
  private:
    void operator=( const BieterHomeExplicit_stub& );
};

#ifndef MICO_CONF_NO_POA

class BieterHomeExplicit_stub_clp :
  virtual public BieterHomeExplicit_stub,
  virtual public ::Components::CCMHome_stub_clp
{
  public:
    BieterHomeExplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~BieterHomeExplicit_stub_clp ();
  protected:
    BieterHomeExplicit_stub_clp ();
  private:
    void operator=( const BieterHomeExplicit_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface BieterHomeImplicit
 */

class BieterHomeImplicit : 
  virtual public ::Components::KeylessCCMHome
{
  public:
    virtual ~BieterHomeImplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef BieterHomeImplicit_ptr _ptr_type;
    typedef BieterHomeImplicit_var _var_type;
    #endif

    static BieterHomeImplicit_ptr _narrow( CORBA::Object_ptr obj );
    static BieterHomeImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static BieterHomeImplicit_ptr _duplicate( BieterHomeImplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static BieterHomeImplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Bieter_ptr create() = 0;

  protected:
    BieterHomeImplicit() {};
  private:
    BieterHomeImplicit( const BieterHomeImplicit& );
    void operator=( const BieterHomeImplicit& );
};

// Stub for interface BieterHomeImplicit
class BieterHomeImplicit_stub:
  virtual public BieterHomeImplicit,
  virtual public ::Components::KeylessCCMHome_stub
{
  public:
    virtual ~BieterHomeImplicit_stub();
    Bieter_ptr create();

  private:
    void operator=( const BieterHomeImplicit_stub& );
};

#ifndef MICO_CONF_NO_POA

class BieterHomeImplicit_stub_clp :
  virtual public BieterHomeImplicit_stub,
  virtual public ::Components::KeylessCCMHome_stub_clp
{
  public:
    BieterHomeImplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~BieterHomeImplicit_stub_clp ();
    Bieter_ptr create();

  protected:
    BieterHomeImplicit_stub_clp ();
  private:
    void operator=( const BieterHomeImplicit_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface BieterHome
 */

class BieterHome : 
  virtual public ::Auktion::BieterHomeExplicit,
  virtual public ::Auktion::BieterHomeImplicit
{
  public:
    virtual ~BieterHome();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef BieterHome_ptr _ptr_type;
    typedef BieterHome_var _var_type;
    #endif

    static BieterHome_ptr _narrow( CORBA::Object_ptr obj );
    static BieterHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static BieterHome_ptr _duplicate( BieterHome_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static BieterHome_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    BieterHome() {};
  private:
    BieterHome( const BieterHome& );
    void operator=( const BieterHome& );
};

// Stub for interface BieterHome
class BieterHome_stub:
  virtual public BieterHome,
  virtual public ::Auktion::BieterHomeExplicit_stub,
  virtual public ::Auktion::BieterHomeImplicit_stub
{
  public:
    virtual ~BieterHome_stub();
  private:
    void operator=( const BieterHome_stub& );
};

#ifndef MICO_CONF_NO_POA

class BieterHome_stub_clp :
  virtual public BieterHome_stub,
  virtual public ::Auktion::BieterHomeExplicit_stub_clp,
  virtual public ::Auktion::BieterHomeImplicit_stub_clp
{
  public:
    BieterHome_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~BieterHome_stub_clp ();
  protected:
    BieterHome_stub_clp ();
  private:
    void operator=( const BieterHome_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for local interface CCM_BieterHomeExplicit
 */

class CCM_BieterHomeExplicit : 
  virtual public ::Components::HomeExecutorBase
{
  public:
    virtual ~CCM_BieterHomeExplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_BieterHomeExplicit_ptr _ptr_type;
    typedef CCM_BieterHomeExplicit_var _var_type;
    #endif

    static CCM_BieterHomeExplicit_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_BieterHomeExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_BieterHomeExplicit_ptr _duplicate( CCM_BieterHomeExplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_BieterHomeExplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_BieterHomeExplicit() {};
  private:
    CCM_BieterHomeExplicit( const CCM_BieterHomeExplicit& );
    void operator=( const CCM_BieterHomeExplicit& );
};



/*
 * Base class and common definitions for local interface CCM_BieterHomeImplicit
 */

class CCM_BieterHomeImplicit : 
  virtual public CORBA::LocalObject
{
  public:
    virtual ~CCM_BieterHomeImplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_BieterHomeImplicit_ptr _ptr_type;
    typedef CCM_BieterHomeImplicit_var _var_type;
    #endif

    static CCM_BieterHomeImplicit_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_BieterHomeImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_BieterHomeImplicit_ptr _duplicate( CCM_BieterHomeImplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_BieterHomeImplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Components::EnterpriseComponent_ptr create() = 0;

  protected:
    CCM_BieterHomeImplicit() {};
  private:
    CCM_BieterHomeImplicit( const CCM_BieterHomeImplicit& );
    void operator=( const CCM_BieterHomeImplicit& );
};



/*
 * Base class and common definitions for local interface CCM_BieterHome
 */

class CCM_BieterHome : 
  virtual public ::Auktion::CCM_BieterHomeExplicit,
  virtual public ::Auktion::CCM_BieterHomeImplicit
{
  public:
    virtual ~CCM_BieterHome();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_BieterHome_ptr _ptr_type;
    typedef CCM_BieterHome_var _var_type;
    #endif

    static CCM_BieterHome_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_BieterHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_BieterHome_ptr _duplicate( CCM_BieterHome_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_BieterHome_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_BieterHome() {};
  private:
    CCM_BieterHome( const CCM_BieterHome& );
    void operator=( const CCM_BieterHome& );
};



/*
 * Base class and common definitions for interface VerkaeuferHomeExplicit
 */

class VerkaeuferHomeExplicit : 
  virtual public ::Components::CCMHome
{
  public:
    virtual ~VerkaeuferHomeExplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef VerkaeuferHomeExplicit_ptr _ptr_type;
    typedef VerkaeuferHomeExplicit_var _var_type;
    #endif

    static VerkaeuferHomeExplicit_ptr _narrow( CORBA::Object_ptr obj );
    static VerkaeuferHomeExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static VerkaeuferHomeExplicit_ptr _duplicate( VerkaeuferHomeExplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static VerkaeuferHomeExplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    VerkaeuferHomeExplicit() {};
  private:
    VerkaeuferHomeExplicit( const VerkaeuferHomeExplicit& );
    void operator=( const VerkaeuferHomeExplicit& );
};

// Stub for interface VerkaeuferHomeExplicit
class VerkaeuferHomeExplicit_stub:
  virtual public VerkaeuferHomeExplicit,
  virtual public ::Components::CCMHome_stub
{
  public:
    virtual ~VerkaeuferHomeExplicit_stub();
  private:
    void operator=( const VerkaeuferHomeExplicit_stub& );
};

#ifndef MICO_CONF_NO_POA

class VerkaeuferHomeExplicit_stub_clp :
  virtual public VerkaeuferHomeExplicit_stub,
  virtual public ::Components::CCMHome_stub_clp
{
  public:
    VerkaeuferHomeExplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~VerkaeuferHomeExplicit_stub_clp ();
  protected:
    VerkaeuferHomeExplicit_stub_clp ();
  private:
    void operator=( const VerkaeuferHomeExplicit_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface VerkaeuferHomeImplicit
 */

class VerkaeuferHomeImplicit : 
  virtual public ::Components::KeylessCCMHome
{
  public:
    virtual ~VerkaeuferHomeImplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef VerkaeuferHomeImplicit_ptr _ptr_type;
    typedef VerkaeuferHomeImplicit_var _var_type;
    #endif

    static VerkaeuferHomeImplicit_ptr _narrow( CORBA::Object_ptr obj );
    static VerkaeuferHomeImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static VerkaeuferHomeImplicit_ptr _duplicate( VerkaeuferHomeImplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static VerkaeuferHomeImplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual Verkaeufer_ptr create() = 0;

  protected:
    VerkaeuferHomeImplicit() {};
  private:
    VerkaeuferHomeImplicit( const VerkaeuferHomeImplicit& );
    void operator=( const VerkaeuferHomeImplicit& );
};

// Stub for interface VerkaeuferHomeImplicit
class VerkaeuferHomeImplicit_stub:
  virtual public VerkaeuferHomeImplicit,
  virtual public ::Components::KeylessCCMHome_stub
{
  public:
    virtual ~VerkaeuferHomeImplicit_stub();
    Verkaeufer_ptr create();

  private:
    void operator=( const VerkaeuferHomeImplicit_stub& );
};

#ifndef MICO_CONF_NO_POA

class VerkaeuferHomeImplicit_stub_clp :
  virtual public VerkaeuferHomeImplicit_stub,
  virtual public ::Components::KeylessCCMHome_stub_clp
{
  public:
    VerkaeuferHomeImplicit_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~VerkaeuferHomeImplicit_stub_clp ();
    Verkaeufer_ptr create();

  protected:
    VerkaeuferHomeImplicit_stub_clp ();
  private:
    void operator=( const VerkaeuferHomeImplicit_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for interface VerkaeuferHome
 */

class VerkaeuferHome : 
  virtual public ::Auktion::VerkaeuferHomeExplicit,
  virtual public ::Auktion::VerkaeuferHomeImplicit
{
  public:
    virtual ~VerkaeuferHome();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef VerkaeuferHome_ptr _ptr_type;
    typedef VerkaeuferHome_var _var_type;
    #endif

    static VerkaeuferHome_ptr _narrow( CORBA::Object_ptr obj );
    static VerkaeuferHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static VerkaeuferHome_ptr _duplicate( VerkaeuferHome_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static VerkaeuferHome_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    VerkaeuferHome() {};
  private:
    VerkaeuferHome( const VerkaeuferHome& );
    void operator=( const VerkaeuferHome& );
};

// Stub for interface VerkaeuferHome
class VerkaeuferHome_stub:
  virtual public VerkaeuferHome,
  virtual public ::Auktion::VerkaeuferHomeExplicit_stub,
  virtual public ::Auktion::VerkaeuferHomeImplicit_stub
{
  public:
    virtual ~VerkaeuferHome_stub();
  private:
    void operator=( const VerkaeuferHome_stub& );
};

#ifndef MICO_CONF_NO_POA

class VerkaeuferHome_stub_clp :
  virtual public VerkaeuferHome_stub,
  virtual public ::Auktion::VerkaeuferHomeExplicit_stub_clp,
  virtual public ::Auktion::VerkaeuferHomeImplicit_stub_clp
{
  public:
    VerkaeuferHome_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~VerkaeuferHome_stub_clp ();
  protected:
    VerkaeuferHome_stub_clp ();
  private:
    void operator=( const VerkaeuferHome_stub_clp & );
};

#endif // MICO_CONF_NO_POA


/*
 * Base class and common definitions for local interface CCM_VerkaeuferHomeExplicit
 */

class CCM_VerkaeuferHomeExplicit : 
  virtual public ::Components::HomeExecutorBase
{
  public:
    virtual ~CCM_VerkaeuferHomeExplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_VerkaeuferHomeExplicit_ptr _ptr_type;
    typedef CCM_VerkaeuferHomeExplicit_var _var_type;
    #endif

    static CCM_VerkaeuferHomeExplicit_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_VerkaeuferHomeExplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_VerkaeuferHomeExplicit_ptr _duplicate( CCM_VerkaeuferHomeExplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_VerkaeuferHomeExplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_VerkaeuferHomeExplicit() {};
  private:
    CCM_VerkaeuferHomeExplicit( const CCM_VerkaeuferHomeExplicit& );
    void operator=( const CCM_VerkaeuferHomeExplicit& );
};



/*
 * Base class and common definitions for local interface CCM_VerkaeuferHomeImplicit
 */

class CCM_VerkaeuferHomeImplicit : 
  virtual public CORBA::LocalObject
{
  public:
    virtual ~CCM_VerkaeuferHomeImplicit();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_VerkaeuferHomeImplicit_ptr _ptr_type;
    typedef CCM_VerkaeuferHomeImplicit_var _var_type;
    #endif

    static CCM_VerkaeuferHomeImplicit_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_VerkaeuferHomeImplicit_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_VerkaeuferHomeImplicit_ptr _duplicate( CCM_VerkaeuferHomeImplicit_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_VerkaeuferHomeImplicit_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::Components::EnterpriseComponent_ptr create() = 0;

  protected:
    CCM_VerkaeuferHomeImplicit() {};
  private:
    CCM_VerkaeuferHomeImplicit( const CCM_VerkaeuferHomeImplicit& );
    void operator=( const CCM_VerkaeuferHomeImplicit& );
};



/*
 * Base class and common definitions for local interface CCM_VerkaeuferHome
 */

class CCM_VerkaeuferHome : 
  virtual public ::Auktion::CCM_VerkaeuferHomeExplicit,
  virtual public ::Auktion::CCM_VerkaeuferHomeImplicit
{
  public:
    virtual ~CCM_VerkaeuferHome();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CCM_VerkaeuferHome_ptr _ptr_type;
    typedef CCM_VerkaeuferHome_var _var_type;
    #endif

    static CCM_VerkaeuferHome_ptr _narrow( CORBA::Object_ptr obj );
    static CCM_VerkaeuferHome_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static CCM_VerkaeuferHome_ptr _duplicate( CCM_VerkaeuferHome_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static CCM_VerkaeuferHome_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

  protected:
    CCM_VerkaeuferHome() {};
  private:
    CCM_VerkaeuferHome( const CCM_VerkaeuferHome& );
    void operator=( const CCM_VerkaeuferHome& );
};


}


#ifndef MICO_CONF_NO_POA



namespace POA_Auktion
{

class Kaeufer : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~Kaeufer ();
    Auktion::Kaeufer_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Kaeufer * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual void zuschlag( ::Auktion::Versteigerung_ptr gegenstand, ::Auktion::Verkaeufer_ptr v ) = 0;

  protected:
    Kaeufer () {};

  private:
    Kaeufer (const Kaeufer &);
    void operator= (const Kaeufer &);
};

class Bieter : 
  virtual public POA_Components::CCMObject,
  virtual public POA_Auktion::Kaeufer
{
  public:
    virtual ~Bieter ();
    Auktion::Bieter_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Bieter * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::Auktion::GebotConsumer_ptr get_consumer_gebote() = 0;
    virtual ::Components::Cookie* connect_versteigerungen( ::Auktion::Versteigerung_ptr connection ) = 0;
    virtual ::Auktion::Versteigerung_ptr disconnect_versteigerungen( ::Components::Cookie* ck ) = 0;
    virtual ::Auktion::Bieter::versteigerungenConnections* get_connections_versteigerungen() = 0;

  protected:
    Bieter () {};

  private:
    Bieter (const Bieter &);
    void operator= (const Bieter &);
};

class GebotConsumer : 
  virtual public POA_Components::EventConsumerBase
{
  public:
    virtual ~GebotConsumer ();
    Auktion::GebotConsumer_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static GebotConsumer * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual void push_Gebot( ::Auktion::Gebot* event ) = 0;

  protected:
    GebotConsumer () {};

  private:
    GebotConsumer (const GebotConsumer &);
    void operator= (const GebotConsumer &);
};

class Versteigerung : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~Versteigerung ();
    Auktion::Versteigerung_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Versteigerung * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual char* name() = 0;
    virtual CORBA::Long aktuelles_gebot() = 0;

    virtual void biete( CORBA::Long gebot, ::Auktion::Bieter_ptr potentieller_kaeufer ) = 0;

  protected:
    Versteigerung () {};

  private:
    Versteigerung (const Versteigerung &);
    void operator= (const Versteigerung &);
};

class Verkaeufer : 
  virtual public POA_Components::CCMObject
{
  public:
    virtual ~Verkaeufer ();
    Auktion::Verkaeufer_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Verkaeufer * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual void connect_handelsplatz( ::Auktion::VersteigerungsFabrik_ptr conxn ) = 0;
    virtual ::Auktion::VersteigerungsFabrik_ptr disconnect_handelsplatz() = 0;
    virtual ::Auktion::VersteigerungsFabrik_ptr get_connection_handelsplatz() = 0;
    virtual ::Auktion::KaufConsumer_ptr get_consumer_zuschlag() = 0;

  protected:
    Verkaeufer () {};

  private:
    Verkaeufer (const Verkaeufer &);
    void operator= (const Verkaeufer &);
};

class VersteigerungsFabrik : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~VersteigerungsFabrik ();
    Auktion::VersteigerungsFabrik_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static VersteigerungsFabrik * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::Auktion::Versteigerung_ptr neue_auktion( const char* name, CORBA::Long minimalgebot, ::Auktion::Verkaeufer_ptr besitzer ) = 0;

  protected:
    VersteigerungsFabrik () {};

  private:
    VersteigerungsFabrik (const VersteigerungsFabrik &);
    void operator= (const VersteigerungsFabrik &);
};

class KaufConsumer : 
  virtual public POA_Components::EventConsumerBase
{
  public:
    virtual ~KaufConsumer ();
    Auktion::KaufConsumer_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static KaufConsumer * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual void push_Kauf( ::Auktion::Kauf* event ) = 0;

  protected:
    KaufConsumer () {};

  private:
    KaufConsumer (const KaufConsumer &);
    void operator= (const KaufConsumer &);
};

class Auktionshaus : 
  virtual public POA_Components::CCMObject
{
  public:
    virtual ~Auktionshaus ();
    Auktion::Auktionshaus_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Auktionshaus * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::Auktion::VersteigerungsFabrik_ptr provide_auktionen() = 0;
    virtual ::Components::Cookie* subscribe_gebote( ::Auktion::GebotConsumer_ptr consumer ) = 0;
    virtual ::Auktion::GebotConsumer_ptr unsubscribe_gebote( ::Components::Cookie* ck ) = 0;

  protected:
    Auktionshaus () {};

  private:
    Auktionshaus (const Auktionshaus &);
    void operator= (const Auktionshaus &);
};

class WeltExplicit : 
  virtual public POA_Components::CCMHome
{
  public:
    virtual ~WeltExplicit ();
    Auktion::WeltExplicit_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static WeltExplicit * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    WeltExplicit () {};

  private:
    WeltExplicit (const WeltExplicit &);
    void operator= (const WeltExplicit &);
};

class WeltImplicit : 
  virtual public POA_Components::KeylessCCMHome
{
  public:
    virtual ~WeltImplicit ();
    Auktion::WeltImplicit_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static WeltImplicit * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::Auktion::Auktionshaus_ptr create() = 0;

  protected:
    WeltImplicit () {};

  private:
    WeltImplicit (const WeltImplicit &);
    void operator= (const WeltImplicit &);
};

class Welt : 
  virtual public POA_Auktion::WeltExplicit,
  virtual public POA_Auktion::WeltImplicit
{
  public:
    virtual ~Welt ();
    Auktion::Welt_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Welt * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    Welt () {};

  private:
    Welt (const Welt &);
    void operator= (const Welt &);
};

class ProduktFilter : 
  virtual public POA_Components::CCMObject
{
  public:
    virtual ~ProduktFilter ();
    Auktion::ProduktFilter_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static ProduktFilter * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual char* interessanter_gegenstand() = 0;
    virtual void interessanter_gegenstand( const char* value ) = 0;

    virtual ::Auktion::GebotConsumer_ptr get_consumer_eingehende_gebote() = 0;
    virtual ::Components::Cookie* subscribe_interessante_gebote( ::Auktion::GebotConsumer_ptr consumer ) = 0;
    virtual ::Auktion::GebotConsumer_ptr unsubscribe_interessante_gebote( ::Components::Cookie* ck ) = 0;

  protected:
    ProduktFilter () {};

  private:
    ProduktFilter (const ProduktFilter &);
    void operator= (const ProduktFilter &);
};

class FilterHomeExplicit : 
  virtual public POA_Components::CCMHome
{
  public:
    virtual ~FilterHomeExplicit ();
    Auktion::FilterHomeExplicit_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static FilterHomeExplicit * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::Auktion::ProduktFilter_ptr new_filter( const char* gegenstand ) = 0;

  protected:
    FilterHomeExplicit () {};

  private:
    FilterHomeExplicit (const FilterHomeExplicit &);
    void operator= (const FilterHomeExplicit &);
};

class FilterHomeImplicit : 
  virtual public POA_Components::KeylessCCMHome
{
  public:
    virtual ~FilterHomeImplicit ();
    Auktion::FilterHomeImplicit_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static FilterHomeImplicit * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::Auktion::ProduktFilter_ptr create() = 0;

  protected:
    FilterHomeImplicit () {};

  private:
    FilterHomeImplicit (const FilterHomeImplicit &);
    void operator= (const FilterHomeImplicit &);
};

class FilterHome : 
  virtual public POA_Auktion::FilterHomeExplicit,
  virtual public POA_Auktion::FilterHomeImplicit
{
  public:
    virtual ~FilterHome ();
    Auktion::FilterHome_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static FilterHome * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    FilterHome () {};

  private:
    FilterHome (const FilterHome &);
    void operator= (const FilterHome &);
};

class BieterHomeExplicit : 
  virtual public POA_Components::CCMHome
{
  public:
    virtual ~BieterHomeExplicit ();
    Auktion::BieterHomeExplicit_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static BieterHomeExplicit * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    BieterHomeExplicit () {};

  private:
    BieterHomeExplicit (const BieterHomeExplicit &);
    void operator= (const BieterHomeExplicit &);
};

class BieterHomeImplicit : 
  virtual public POA_Components::KeylessCCMHome
{
  public:
    virtual ~BieterHomeImplicit ();
    Auktion::BieterHomeImplicit_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static BieterHomeImplicit * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::Auktion::Bieter_ptr create() = 0;

  protected:
    BieterHomeImplicit () {};

  private:
    BieterHomeImplicit (const BieterHomeImplicit &);
    void operator= (const BieterHomeImplicit &);
};

class BieterHome : 
  virtual public POA_Auktion::BieterHomeExplicit,
  virtual public POA_Auktion::BieterHomeImplicit
{
  public:
    virtual ~BieterHome ();
    Auktion::BieterHome_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static BieterHome * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    BieterHome () {};

  private:
    BieterHome (const BieterHome &);
    void operator= (const BieterHome &);
};

class VerkaeuferHomeExplicit : 
  virtual public POA_Components::CCMHome
{
  public:
    virtual ~VerkaeuferHomeExplicit ();
    Auktion::VerkaeuferHomeExplicit_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static VerkaeuferHomeExplicit * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    VerkaeuferHomeExplicit () {};

  private:
    VerkaeuferHomeExplicit (const VerkaeuferHomeExplicit &);
    void operator= (const VerkaeuferHomeExplicit &);
};

class VerkaeuferHomeImplicit : 
  virtual public POA_Components::KeylessCCMHome
{
  public:
    virtual ~VerkaeuferHomeImplicit ();
    Auktion::VerkaeuferHomeImplicit_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static VerkaeuferHomeImplicit * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::Auktion::Verkaeufer_ptr create() = 0;

  protected:
    VerkaeuferHomeImplicit () {};

  private:
    VerkaeuferHomeImplicit (const VerkaeuferHomeImplicit &);
    void operator= (const VerkaeuferHomeImplicit &);
};

class VerkaeuferHome : 
  virtual public POA_Auktion::VerkaeuferHomeExplicit,
  virtual public POA_Auktion::VerkaeuferHomeImplicit
{
  public:
    virtual ~VerkaeuferHome ();
    Auktion::VerkaeuferHome_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static VerkaeuferHome * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

  protected:
    VerkaeuferHome () {};

  private:
    VerkaeuferHome (const VerkaeuferHome &);
    void operator= (const VerkaeuferHome &);
};

}


#endif // MICO_CONF_NO_POA



namespace OBV_Auktion
{


// OBV class for valuetype Gebot
class Gebot : virtual public Auktion::Gebot
{
  protected:
    Gebot ();
    Gebot (::Auktion::Versteigerung_ptr _gegenstand, CORBA::Long _angebot);
    virtual ~Gebot();

  public:
    void gegenstand( ::Auktion::Versteigerung_ptr _p );
    ::Auktion::Versteigerung_ptr gegenstand() const;

    void angebot( CORBA::Long _p );
    CORBA::Long angebot() const;


  private:
    struct _M {
      ::Auktion::Versteigerung_var gegenstand;
      CORBA::Long angebot;
    } _m;
};


// OBV class for valuetype Kauf
class Kauf :
  virtual public Auktion::Kauf,
  virtual public OBV_Auktion::Gebot
{
  protected:
    Kauf ();
    Kauf (::Auktion::Kaeufer_ptr _kaeufer);
    virtual ~Kauf();

  public:
    void kaeufer( ::Auktion::Kaeufer_ptr _p );
    ::Auktion::Kaeufer_ptr kaeufer() const;


  private:
    struct _M {
      ::Auktion::Kaeufer_var kaeufer;
    } _m;
};

}


extern CORBA::StaticTypeInfo *_marshaller_Auktion_Kaeufer;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_Bieter_versteigerungenConnection;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_Bieter;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_Gebot;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_GebotConsumer;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_Versteigerung;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_Verkaeufer;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_VersteigerungsFabrik;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_Kauf;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_KaufConsumer;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_Auktionshaus;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_WeltExplicit;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_WeltImplicit;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_Welt;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_ProduktFilter;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_FilterHomeExplicit;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_FilterHomeImplicit;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_FilterHome;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_BieterHomeExplicit;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_BieterHomeImplicit;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_BieterHome;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_VerkaeuferHomeExplicit;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_VerkaeuferHomeImplicit;

extern CORBA::StaticTypeInfo *_marshaller_Auktion_VerkaeuferHome;

extern CORBA::StaticTypeInfo *_marshaller__seq_Auktion_Bieter_versteigerungenConnection;

#endif