/* -*- C++ -*- $Id$ */

// ******  Code generated by the The ACE ORB (TAO) IDL Compiler *******
// TAO and the TAO IDL Compiler have been developed by the Center for
// Distributed Object Computing at Washington University, St. Louis.
//
// Information about TAO is available at:
//                 http://www.cs.wustl.edu/~schmidt/TAO.html

#ifndef _TAO_IDL_COSEVENTCOMMC_H_
#define _TAO_IDL_COSEVENTCOMMC_H_

#include "tao/corba.h"

#if defined (ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION)
#include "ace/streams.h"
#endif /* ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION */

#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */

#include "orbsvcs_export.h"

#if defined (TAO_EXPORT_MACRO)
#undef TAO_EXPORT_MACRO
#endif
#define TAO_EXPORT_MACRO TAO_ORBSVCS_Export

#if defined (TAO_EXPORT_NESTED_CLASSES)
#  if defined (TAO_EXPORT_NESTED_MACRO)
#    undef TAO_EXPORT_NESTED_MACRO
#  endif /* defined (TAO_EXPORT_NESTED_MACRO) */
#  define TAO_EXPORT_NESTED_MACRO TAO_ORBSVCS_Export
#endif /* TAO_EXPORT_NESTED_CLASSES */

#if defined(_MSC_VER)
#if (_MSC_VER >= 1200)
#pragma warning(push)
#endif /* _MSC_VER >= 1200 */
#pragma warning(disable:4250)
#endif /* _MSC_VER */

TAO_NAMESPACE  CosEventComm
{

#if !defined (_COSEVENTCOMM_DISCONNECTED___PTR_CH_)
#define _COSEVENTCOMM_DISCONNECTED___PTR_CH_

  class Disconnected;
  typedef Disconnected *Disconnected_ptr;
  
#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_DISCONNECTED_CH_)
#define _COSEVENTCOMM_DISCONNECTED_CH_

  class TAO_ORBSVCS_Export Disconnected : public CORBA::UserException
  {
  public:

#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef Disconnected_ptr _ptr_type;
#endif /* ! __GNUC__ || g++ >= 2.8 */


    Disconnected (void); // default ctor
    Disconnected (const Disconnected &); // copy ctor
    ~Disconnected (void); // dtor
    Disconnected &operator= (const Disconnected &);


    virtual void _raise (void);

    virtual void _tao_encode (
        TAO_OutputCDR &,
        CORBA::Environment &) const;
    virtual void _tao_decode (
        TAO_InputCDR &,
        CORBA::Environment &);

    static Disconnected *_narrow (CORBA::Exception *);


    // = TAO extension
    static CORBA::Exception *_alloc (void);

  }; // exception CosEventComm::Disconnected

    TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Disconnected;


#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PUSHCONSUMER___PTR_CH_)
#define _COSEVENTCOMM_PUSHCONSUMER___PTR_CH_

  class PushConsumer;
  typedef PushConsumer *PushConsumer_ptr;
  
#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PUSHCONSUMER___VAR_CH_)
#define _COSEVENTCOMM_PUSHCONSUMER___VAR_CH_

  class TAO_ORBSVCS_Export PushConsumer_var
  {
  public:
    PushConsumer_var (void); // default constructor
    PushConsumer_var (PushConsumer_ptr);
    PushConsumer_var (const PushConsumer_var &); // copy constructor
    ~PushConsumer_var (void); // destructor
    
    PushConsumer_var &operator= (PushConsumer_ptr);
    PushConsumer_var &operator= (const PushConsumer_var &);
    PushConsumer_ptr operator-> (void) const;
    
    operator const PushConsumer_ptr &() const;
    operator PushConsumer_ptr &();
    // in, inout, out, _retn 
    PushConsumer_ptr in (void) const;
    PushConsumer_ptr &inout (void);
    PushConsumer_ptr &out (void);
    PushConsumer_ptr _retn (void);
    PushConsumer_ptr ptr (void) const;

  private:
    PushConsumer_ptr ptr_;
  };


#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PUSHCONSUMER___OUT_CH_)
#define _COSEVENTCOMM_PUSHCONSUMER___OUT_CH_

  class TAO_ORBSVCS_Export PushConsumer_out
  {
  public:
    PushConsumer_out (PushConsumer_ptr &);
    PushConsumer_out (PushConsumer_var &);
    PushConsumer_out (const PushConsumer_out &);
    PushConsumer_out &operator= (const PushConsumer_out &);
    PushConsumer_out &operator= (const PushConsumer_var &);
    PushConsumer_out &operator= (PushConsumer_ptr);
    operator PushConsumer_ptr &();
    PushConsumer_ptr &ptr (void);
    PushConsumer_ptr operator-> (void);
    
  private:
    PushConsumer_ptr &ptr_;
  };


#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PUSHCONSUMER_CH_)
#define _COSEVENTCOMM_PUSHCONSUMER_CH_

class TAO_ORBSVCS_Export PushConsumer : public virtual ACE_CORBA_1 (Object)
  {
  public:
  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
    typedef PushConsumer_ptr _ptr_type;
    typedef PushConsumer_var _var_type;
  #endif /* ! __GNUC__ || g++ >= 2.8 */

    // the static operations
    static PushConsumer_ptr _duplicate (PushConsumer_ptr obj);
    static PushConsumer_ptr _narrow (
        CORBA::Object_ptr obj,
        CORBA::Environment &env = 
          TAO_default_environment ()
      );
    static PushConsumer_ptr _unchecked_narrow (
        CORBA::Object_ptr obj,
        CORBA::Environment &env = 
          TAO_default_environment ()
      );
    static PushConsumer_ptr _nil (void)
      {
        return (PushConsumer_ptr)0;
      }

    virtual void push (
        const CORBA::Any & data,
        CORBA::Environment &ACE_TRY_ENV = 
          TAO_default_environment ()
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException,
        CosEventComm::Disconnected
      ));

    virtual void disconnect_push_consumer (
        CORBA::Environment &ACE_TRY_ENV = 
          TAO_default_environment ()
      )
      ACE_THROW_SPEC ((
        CORBA::SystemException
      ));

    virtual CORBA::Boolean _is_a (
        const CORBA::Char *type_id, 
        CORBA::Environment &env = 
          TAO_default_environment ()
      );
    virtual const char* _interface_repository_id (void) const;

  protected:
    PushConsumer (void);
    PushConsumer (TAO_Stub *objref, 
        TAO_ServantBase *_tao_servant = 0, 
        CORBA::Boolean _tao_collocated = 0
      );
    virtual ~PushConsumer (void);
  private:
    PushConsumer (const PushConsumer &);
    void operator= (const PushConsumer &);
};

class TAO_CosEventComm_PushConsumer_Default_Proxy_Factory
{
public:
  
  TAO_CosEventComm_PushConsumer_Default_Proxy_Factory (int register_proxy_factory = 1);
  
  virtual ~TAO_CosEventComm_PushConsumer_Default_Proxy_Factory (void);
  
  virtual PushConsumer_ptr create_proxy (
      PushConsumer_ptr proxy,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
};

class TAO_CosEventComm_PushConsumer_Proxy_Factory_Adapter
{
public:
  
  friend class ACE_Singleton<TAO_CosEventComm_PushConsumer_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
  
  int register_proxy_factory (
      TAO_CosEventComm_PushConsumer_Default_Proxy_Factory *df,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  
  int unregister_proxy_factory (
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  
  PushConsumer_ptr create_proxy (
      PushConsumer_ptr proxy,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );

protected:
  TAO_CosEventComm_PushConsumer_Proxy_Factory_Adapter (void);
  ~TAO_CosEventComm_PushConsumer_Proxy_Factory_Adapter (void);
  TAO_CosEventComm_PushConsumer_Proxy_Factory_Adapter &operator= (
      const TAO_CosEventComm_PushConsumer_Proxy_Factory_Adapter &
    );
  TAO_CosEventComm_PushConsumer_Default_Proxy_Factory *proxy_factory_;
  int delete_proxy_factory_;
  ACE_SYNCH_RECURSIVE_MUTEX lock_;
  };

  typedef ACE_Singleton<TAO_CosEventComm_PushConsumer_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_CosEventComm_PushConsumer_PROXY_FACTORY_ADAPTER;
  class TAO_CosEventComm_PushConsumer_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (CosEventComm, PushConsumer)
  {
  public:
    TAO_CosEventComm_PushConsumer_Smart_Proxy_Base (::CosEventComm::PushConsumer_ptr proxy);
    ~TAO_CosEventComm_PushConsumer_Smart_Proxy_Base (void);
      virtual void push (
      const CORBA::Any & data,
      CORBA::Environment &ACE_TRY_ENV = 
        TAO_default_environment ()
    )
    ACE_THROW_SPEC ((
      CORBA::SystemException,
      CosEventComm::Disconnected
    ));

  virtual void disconnect_push_consumer (
      CORBA::Environment &ACE_TRY_ENV = 
        TAO_default_environment ()
    )
    ACE_THROW_SPEC ((
      CORBA::SystemException
    ));

private:
  ::CosEventComm::PushConsumer_var base_proxy_;
};


#endif /* end #if !defined */

TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PushConsumer;


#if !defined (_COSEVENTCOMM_PUSHSUPPLIER___PTR_CH_)
#define _COSEVENTCOMM_PUSHSUPPLIER___PTR_CH_

class PushSupplier;
typedef PushSupplier *PushSupplier_ptr;

#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PUSHSUPPLIER___VAR_CH_)
#define _COSEVENTCOMM_PUSHSUPPLIER___VAR_CH_

class TAO_ORBSVCS_Export PushSupplier_var
{
public:
  PushSupplier_var (void); // default constructor
  PushSupplier_var (PushSupplier_ptr);
  PushSupplier_var (const PushSupplier_var &); // copy constructor
  ~PushSupplier_var (void); // destructor
  
  PushSupplier_var &operator= (PushSupplier_ptr);
  PushSupplier_var &operator= (const PushSupplier_var &);
  PushSupplier_ptr operator-> (void) const;
  
  operator const PushSupplier_ptr &() const;
  operator PushSupplier_ptr &();
  // in, inout, out, _retn 
  PushSupplier_ptr in (void) const;
  PushSupplier_ptr &inout (void);
  PushSupplier_ptr &out (void);
  PushSupplier_ptr _retn (void);
  PushSupplier_ptr ptr (void) const;

private:
  PushSupplier_ptr ptr_;
};


#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PUSHSUPPLIER___OUT_CH_)
#define _COSEVENTCOMM_PUSHSUPPLIER___OUT_CH_

class TAO_ORBSVCS_Export PushSupplier_out
{
public:
  PushSupplier_out (PushSupplier_ptr &);
  PushSupplier_out (PushSupplier_var &);
  PushSupplier_out (const PushSupplier_out &);
  PushSupplier_out &operator= (const PushSupplier_out &);
  PushSupplier_out &operator= (const PushSupplier_var &);
  PushSupplier_out &operator= (PushSupplier_ptr);
  operator PushSupplier_ptr &();
  PushSupplier_ptr &ptr (void);
  PushSupplier_ptr operator-> (void);
  
private:
  PushSupplier_ptr &ptr_;
};


#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PUSHSUPPLIER_CH_)
#define _COSEVENTCOMM_PUSHSUPPLIER_CH_

class TAO_ORBSVCS_Export PushSupplier : public virtual ACE_CORBA_1 (Object)
{
public:
#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
  typedef PushSupplier_ptr _ptr_type;
  typedef PushSupplier_var _var_type;
#endif /* ! __GNUC__ || g++ >= 2.8 */

  // the static operations
  static PushSupplier_ptr _duplicate (PushSupplier_ptr obj);
  static PushSupplier_ptr _narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  static PushSupplier_ptr _unchecked_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  static PushSupplier_ptr _nil (void)
    {
      return (PushSupplier_ptr)0;
    }

  virtual void disconnect_push_supplier (
      CORBA::Environment &ACE_TRY_ENV = 
        TAO_default_environment ()
    )
    ACE_THROW_SPEC ((
      CORBA::SystemException
    ));

  virtual CORBA::Boolean _is_a (
      const CORBA::Char *type_id, 
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  virtual const char* _interface_repository_id (void) const;

protected:
  PushSupplier (void);
  PushSupplier (TAO_Stub *objref, 
      TAO_ServantBase *_tao_servant = 0, 
      CORBA::Boolean _tao_collocated = 0
    );
  virtual ~PushSupplier (void);
private:
  PushSupplier (const PushSupplier &);
  void operator= (const PushSupplier &);
};

class TAO_CosEventComm_PushSupplier_Default_Proxy_Factory
{
public:
  
  TAO_CosEventComm_PushSupplier_Default_Proxy_Factory (int register_proxy_factory = 1);
  
  virtual ~TAO_CosEventComm_PushSupplier_Default_Proxy_Factory (void);
  
  virtual PushSupplier_ptr create_proxy (
      PushSupplier_ptr proxy,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
};

class TAO_CosEventComm_PushSupplier_Proxy_Factory_Adapter
{
public:
  
  friend class ACE_Singleton<TAO_CosEventComm_PushSupplier_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
  
  int register_proxy_factory (
      TAO_CosEventComm_PushSupplier_Default_Proxy_Factory *df,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  
  int unregister_proxy_factory (
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  
  PushSupplier_ptr create_proxy (
      PushSupplier_ptr proxy,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );

protected:
  TAO_CosEventComm_PushSupplier_Proxy_Factory_Adapter (void);
  ~TAO_CosEventComm_PushSupplier_Proxy_Factory_Adapter (void);
  TAO_CosEventComm_PushSupplier_Proxy_Factory_Adapter &operator= (
      const TAO_CosEventComm_PushSupplier_Proxy_Factory_Adapter &
    );
  TAO_CosEventComm_PushSupplier_Default_Proxy_Factory *proxy_factory_;
  int delete_proxy_factory_;
  ACE_SYNCH_RECURSIVE_MUTEX lock_;
  };

  typedef ACE_Singleton<TAO_CosEventComm_PushSupplier_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_CosEventComm_PushSupplier_PROXY_FACTORY_ADAPTER;
  class TAO_CosEventComm_PushSupplier_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (CosEventComm, PushSupplier)
  {
  public:
    TAO_CosEventComm_PushSupplier_Smart_Proxy_Base (::CosEventComm::PushSupplier_ptr proxy);
    ~TAO_CosEventComm_PushSupplier_Smart_Proxy_Base (void);
      virtual void disconnect_push_supplier (
      CORBA::Environment &ACE_TRY_ENV = 
        TAO_default_environment ()
    )
    ACE_THROW_SPEC ((
      CORBA::SystemException
    ));

private:
  ::CosEventComm::PushSupplier_var base_proxy_;
};


#endif /* end #if !defined */

TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PushSupplier;


#if !defined (_COSEVENTCOMM_PULLSUPPLIER___PTR_CH_)
#define _COSEVENTCOMM_PULLSUPPLIER___PTR_CH_

class PullSupplier;
typedef PullSupplier *PullSupplier_ptr;

#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PULLSUPPLIER___VAR_CH_)
#define _COSEVENTCOMM_PULLSUPPLIER___VAR_CH_

class TAO_ORBSVCS_Export PullSupplier_var
{
public:
  PullSupplier_var (void); // default constructor
  PullSupplier_var (PullSupplier_ptr);
  PullSupplier_var (const PullSupplier_var &); // copy constructor
  ~PullSupplier_var (void); // destructor
  
  PullSupplier_var &operator= (PullSupplier_ptr);
  PullSupplier_var &operator= (const PullSupplier_var &);
  PullSupplier_ptr operator-> (void) const;
  
  operator const PullSupplier_ptr &() const;
  operator PullSupplier_ptr &();
  // in, inout, out, _retn 
  PullSupplier_ptr in (void) const;
  PullSupplier_ptr &inout (void);
  PullSupplier_ptr &out (void);
  PullSupplier_ptr _retn (void);
  PullSupplier_ptr ptr (void) const;

private:
  PullSupplier_ptr ptr_;
};


#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PULLSUPPLIER___OUT_CH_)
#define _COSEVENTCOMM_PULLSUPPLIER___OUT_CH_

class TAO_ORBSVCS_Export PullSupplier_out
{
public:
  PullSupplier_out (PullSupplier_ptr &);
  PullSupplier_out (PullSupplier_var &);
  PullSupplier_out (const PullSupplier_out &);
  PullSupplier_out &operator= (const PullSupplier_out &);
  PullSupplier_out &operator= (const PullSupplier_var &);
  PullSupplier_out &operator= (PullSupplier_ptr);
  operator PullSupplier_ptr &();
  PullSupplier_ptr &ptr (void);
  PullSupplier_ptr operator-> (void);
  
private:
  PullSupplier_ptr &ptr_;
};


#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PULLSUPPLIER_CH_)
#define _COSEVENTCOMM_PULLSUPPLIER_CH_

class TAO_ORBSVCS_Export PullSupplier : public virtual ACE_CORBA_1 (Object)
{
public:
#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
  typedef PullSupplier_ptr _ptr_type;
  typedef PullSupplier_var _var_type;
#endif /* ! __GNUC__ || g++ >= 2.8 */

  // the static operations
  static PullSupplier_ptr _duplicate (PullSupplier_ptr obj);
  static PullSupplier_ptr _narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  static PullSupplier_ptr _unchecked_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  static PullSupplier_ptr _nil (void)
    {
      return (PullSupplier_ptr)0;
    }

  virtual CORBA::Any * pull (
      CORBA::Environment &ACE_TRY_ENV = 
        TAO_default_environment ()
    )
    ACE_THROW_SPEC ((
      CORBA::SystemException,
      CosEventComm::Disconnected
    ));

  virtual CORBA::Any * try_pull (
      CORBA::Boolean_out has_event,
      CORBA::Environment &ACE_TRY_ENV = 
        TAO_default_environment ()
    )
    ACE_THROW_SPEC ((
      CORBA::SystemException,
      CosEventComm::Disconnected
    ));

  virtual void disconnect_pull_supplier (
      CORBA::Environment &ACE_TRY_ENV = 
        TAO_default_environment ()
    )
    ACE_THROW_SPEC ((
      CORBA::SystemException
    ));

  virtual CORBA::Boolean _is_a (
      const CORBA::Char *type_id, 
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  virtual const char* _interface_repository_id (void) const;

protected:
  PullSupplier (void);
  PullSupplier (TAO_Stub *objref, 
      TAO_ServantBase *_tao_servant = 0, 
      CORBA::Boolean _tao_collocated = 0
    );
  virtual ~PullSupplier (void);
private:
  PullSupplier (const PullSupplier &);
  void operator= (const PullSupplier &);
};

class TAO_CosEventComm_PullSupplier_Default_Proxy_Factory
{
public:
  
  TAO_CosEventComm_PullSupplier_Default_Proxy_Factory (int register_proxy_factory = 1);
  
  virtual ~TAO_CosEventComm_PullSupplier_Default_Proxy_Factory (void);
  
  virtual PullSupplier_ptr create_proxy (
      PullSupplier_ptr proxy,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
};

class TAO_CosEventComm_PullSupplier_Proxy_Factory_Adapter
{
public:
  
  friend class ACE_Singleton<TAO_CosEventComm_PullSupplier_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
  
  int register_proxy_factory (
      TAO_CosEventComm_PullSupplier_Default_Proxy_Factory *df,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  
  int unregister_proxy_factory (
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  
  PullSupplier_ptr create_proxy (
      PullSupplier_ptr proxy,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );

protected:
  TAO_CosEventComm_PullSupplier_Proxy_Factory_Adapter (void);
  ~TAO_CosEventComm_PullSupplier_Proxy_Factory_Adapter (void);
  TAO_CosEventComm_PullSupplier_Proxy_Factory_Adapter &operator= (
      const TAO_CosEventComm_PullSupplier_Proxy_Factory_Adapter &
    );
  TAO_CosEventComm_PullSupplier_Default_Proxy_Factory *proxy_factory_;
  int delete_proxy_factory_;
  ACE_SYNCH_RECURSIVE_MUTEX lock_;
  };

  typedef ACE_Singleton<TAO_CosEventComm_PullSupplier_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_CosEventComm_PullSupplier_PROXY_FACTORY_ADAPTER;
  class TAO_CosEventComm_PullSupplier_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (CosEventComm, PullSupplier)
  {
  public:
    TAO_CosEventComm_PullSupplier_Smart_Proxy_Base (::CosEventComm::PullSupplier_ptr proxy);
    ~TAO_CosEventComm_PullSupplier_Smart_Proxy_Base (void);
      virtual CORBA::Any * pull (
      CORBA::Environment &ACE_TRY_ENV = 
        TAO_default_environment ()
    )
    ACE_THROW_SPEC ((
      CORBA::SystemException,
      CosEventComm::Disconnected
    ));

  virtual CORBA::Any * try_pull (
      CORBA::Boolean_out has_event,
      CORBA::Environment &ACE_TRY_ENV = 
        TAO_default_environment ()
    )
    ACE_THROW_SPEC ((
      CORBA::SystemException,
      CosEventComm::Disconnected
    ));

  virtual void disconnect_pull_supplier (
      CORBA::Environment &ACE_TRY_ENV = 
        TAO_default_environment ()
    )
    ACE_THROW_SPEC ((
      CORBA::SystemException
    ));

private:
  ::CosEventComm::PullSupplier_var base_proxy_;
};


#endif /* end #if !defined */

TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PullSupplier;


#if !defined (_COSEVENTCOMM_PULLCONSUMER___PTR_CH_)
#define _COSEVENTCOMM_PULLCONSUMER___PTR_CH_

class PullConsumer;
typedef PullConsumer *PullConsumer_ptr;

#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PULLCONSUMER___VAR_CH_)
#define _COSEVENTCOMM_PULLCONSUMER___VAR_CH_

class TAO_ORBSVCS_Export PullConsumer_var
{
public:
  PullConsumer_var (void); // default constructor
  PullConsumer_var (PullConsumer_ptr);
  PullConsumer_var (const PullConsumer_var &); // copy constructor
  ~PullConsumer_var (void); // destructor
  
  PullConsumer_var &operator= (PullConsumer_ptr);
  PullConsumer_var &operator= (const PullConsumer_var &);
  PullConsumer_ptr operator-> (void) const;
  
  operator const PullConsumer_ptr &() const;
  operator PullConsumer_ptr &();
  // in, inout, out, _retn 
  PullConsumer_ptr in (void) const;
  PullConsumer_ptr &inout (void);
  PullConsumer_ptr &out (void);
  PullConsumer_ptr _retn (void);
  PullConsumer_ptr ptr (void) const;

private:
  PullConsumer_ptr ptr_;
};


#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PULLCONSUMER___OUT_CH_)
#define _COSEVENTCOMM_PULLCONSUMER___OUT_CH_

class TAO_ORBSVCS_Export PullConsumer_out
{
public:
  PullConsumer_out (PullConsumer_ptr &);
  PullConsumer_out (PullConsumer_var &);
  PullConsumer_out (const PullConsumer_out &);
  PullConsumer_out &operator= (const PullConsumer_out &);
  PullConsumer_out &operator= (const PullConsumer_var &);
  PullConsumer_out &operator= (PullConsumer_ptr);
  operator PullConsumer_ptr &();
  PullConsumer_ptr &ptr (void);
  PullConsumer_ptr operator-> (void);
  
private:
  PullConsumer_ptr &ptr_;
};


#endif /* end #if !defined */


#if !defined (_COSEVENTCOMM_PULLCONSUMER_CH_)
#define _COSEVENTCOMM_PULLCONSUMER_CH_

class TAO_ORBSVCS_Export PullConsumer : public virtual ACE_CORBA_1 (Object)
{
public:
#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
  typedef PullConsumer_ptr _ptr_type;
  typedef PullConsumer_var _var_type;
#endif /* ! __GNUC__ || g++ >= 2.8 */

  // the static operations
  static PullConsumer_ptr _duplicate (PullConsumer_ptr obj);
  static PullConsumer_ptr _narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  static PullConsumer_ptr _unchecked_narrow (
      CORBA::Object_ptr obj,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  static PullConsumer_ptr _nil (void)
    {
      return (PullConsumer_ptr)0;
    }

  virtual void disconnect_pull_consumer (
      CORBA::Environment &ACE_TRY_ENV = 
        TAO_default_environment ()
    )
    ACE_THROW_SPEC ((
      CORBA::SystemException
    ));

  virtual CORBA::Boolean _is_a (
      const CORBA::Char *type_id, 
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  virtual const char* _interface_repository_id (void) const;

protected:
  PullConsumer (void);
  PullConsumer (TAO_Stub *objref, 
      TAO_ServantBase *_tao_servant = 0, 
      CORBA::Boolean _tao_collocated = 0
    );
  virtual ~PullConsumer (void);
private:
  PullConsumer (const PullConsumer &);
  void operator= (const PullConsumer &);
};

class TAO_CosEventComm_PullConsumer_Default_Proxy_Factory
{
public:
  
  TAO_CosEventComm_PullConsumer_Default_Proxy_Factory (int register_proxy_factory = 1);
  
  virtual ~TAO_CosEventComm_PullConsumer_Default_Proxy_Factory (void);
  
  virtual PullConsumer_ptr create_proxy (
      PullConsumer_ptr proxy,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
};

class TAO_CosEventComm_PullConsumer_Proxy_Factory_Adapter
{
public:
  
  friend class ACE_Singleton<TAO_CosEventComm_PullConsumer_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
  
  int register_proxy_factory (
      TAO_CosEventComm_PullConsumer_Default_Proxy_Factory *df,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  
  int unregister_proxy_factory (
      CORBA::Environment &env = 
        TAO_default_environment ()
    );
  
  PullConsumer_ptr create_proxy (
      PullConsumer_ptr proxy,
      CORBA::Environment &env = 
        TAO_default_environment ()
    );

protected:
  TAO_CosEventComm_PullConsumer_Proxy_Factory_Adapter (void);
  ~TAO_CosEventComm_PullConsumer_Proxy_Factory_Adapter (void);
  TAO_CosEventComm_PullConsumer_Proxy_Factory_Adapter &operator= (
      const TAO_CosEventComm_PullConsumer_Proxy_Factory_Adapter &
    );
  TAO_CosEventComm_PullConsumer_Default_Proxy_Factory *proxy_factory_;
  int delete_proxy_factory_;
  ACE_SYNCH_RECURSIVE_MUTEX lock_;
  };

  typedef ACE_Singleton<TAO_CosEventComm_PullConsumer_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_CosEventComm_PullConsumer_PROXY_FACTORY_ADAPTER;
  class TAO_CosEventComm_PullConsumer_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (CosEventComm, PullConsumer)
  {
  public:
    TAO_CosEventComm_PullConsumer_Smart_Proxy_Base (::CosEventComm::PullConsumer_ptr proxy);
    ~TAO_CosEventComm_PullConsumer_Smart_Proxy_Base (void);
      virtual void disconnect_pull_consumer (
      CORBA::Environment &ACE_TRY_ENV = 
        TAO_default_environment ()
    )
    ACE_THROW_SPEC ((
      CORBA::SystemException
    ));

private:
  ::CosEventComm::PullConsumer_var base_proxy_;
};


#endif /* end #if !defined */

TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PullConsumer;


}
TAO_NAMESPACE_CLOSE // module CosEventComm

TAO_ORBSVCS_Export void operator<<= (CORBA::Any &, const CosEventComm::Disconnected &); // copying version
TAO_ORBSVCS_Export void operator<<= (CORBA::Any &, CosEventComm::Disconnected*); // noncopying version
TAO_ORBSVCS_Export CORBA::Boolean operator>>= (const CORBA::Any &, CosEventComm::Disconnected *&); // deprecated
TAO_ORBSVCS_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CosEventComm::Disconnected *&);
extern TAO_ORBSVCS_Export CosEventComm::PushConsumer_ptr (*_TAO_collocation_CosEventComm_PushConsumer_Stub_Factory_function_pointer) (
    CORBA::Object_ptr obj
  );
// Any operators for interface CosEventComm::PushConsumer
TAO_ORBSVCS_Export void operator<<= (CORBA::Any &, CosEventComm::PushConsumer_ptr);
TAO_ORBSVCS_Export CORBA::Boolean operator>>= (const CORBA::Any &, CosEventComm::PushConsumer *&);
extern TAO_ORBSVCS_Export CosEventComm::PushSupplier_ptr (*_TAO_collocation_CosEventComm_PushSupplier_Stub_Factory_function_pointer) (
    CORBA::Object_ptr obj
  );
// Any operators for interface CosEventComm::PushSupplier
TAO_ORBSVCS_Export void operator<<= (CORBA::Any &, CosEventComm::PushSupplier_ptr);
TAO_ORBSVCS_Export CORBA::Boolean operator>>= (const CORBA::Any &, CosEventComm::PushSupplier *&);
extern TAO_ORBSVCS_Export CosEventComm::PullSupplier_ptr (*_TAO_collocation_CosEventComm_PullSupplier_Stub_Factory_function_pointer) (
    CORBA::Object_ptr obj
  );
// Any operators for interface CosEventComm::PullSupplier
TAO_ORBSVCS_Export void operator<<= (CORBA::Any &, CosEventComm::PullSupplier_ptr);
TAO_ORBSVCS_Export CORBA::Boolean operator>>= (const CORBA::Any &, CosEventComm::PullSupplier *&);
extern TAO_ORBSVCS_Export CosEventComm::PullConsumer_ptr (*_TAO_collocation_CosEventComm_PullConsumer_Stub_Factory_function_pointer) (
    CORBA::Object_ptr obj
  );
// Any operators for interface CosEventComm::PullConsumer
TAO_ORBSVCS_Export void operator<<= (CORBA::Any &, CosEventComm::PullConsumer_ptr);
TAO_ORBSVCS_Export CORBA::Boolean operator>>= (const CORBA::Any &, CosEventComm::PullConsumer *&);

#ifndef __ACE_INLINE__

TAO_ORBSVCS_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CosEventComm::Disconnected &);
TAO_ORBSVCS_Export CORBA::Boolean operator>> (TAO_InputCDR &, CosEventComm::Disconnected &);

# if !defined (ACE_LACKS_IOSTREAM_TOTALLY)

TAO_ORBSVCS_Export ostream& operator<< (ostream &, const CosEventComm::Disconnected &);

# endif /* ACE_LACKS_IOSTREAM_TOTALLY */
TAO_ORBSVCS_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CosEventComm::PushConsumer_ptr );
TAO_ORBSVCS_Export CORBA::Boolean operator>> (TAO_InputCDR &, CosEventComm::PushConsumer_ptr &);
TAO_ORBSVCS_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CosEventComm::PushSupplier_ptr );
TAO_ORBSVCS_Export CORBA::Boolean operator>> (TAO_InputCDR &, CosEventComm::PushSupplier_ptr &);
TAO_ORBSVCS_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CosEventComm::PullSupplier_ptr );
TAO_ORBSVCS_Export CORBA::Boolean operator>> (TAO_InputCDR &, CosEventComm::PullSupplier_ptr &);
TAO_ORBSVCS_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CosEventComm::PullConsumer_ptr );
TAO_ORBSVCS_Export CORBA::Boolean operator>> (TAO_InputCDR &, CosEventComm::PullConsumer_ptr &);

#endif /* __ACE_INLINE__ */


#if defined (__ACE_INLINE__)
#include "CosEventCommC.i"
#endif /* defined INLINE */

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
#pragma warning(pop)
#endif /* _MSC_VER */

#endif /* ifndef */
