ChangeLogTag:Mon May 22 22:12:22 2000 Marina Spivak <marina@cs.wustl.edu>

1 files changed, 2440 insertions, 0 deletions

diff --git a/TAO/tao/RTCORBAC.h b/TAO/tao/RTCORBAC.h
new file mode 100644
index 00000000000..15f583a726f
--- /dev/null
+++ b/TAO/tao/RTCORBAC.h
@@ -0,0 +1,2440 @@
+/* -*- 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_ORIG_RTCORBAC_H_
+#define _TAO_IDL_ORIG_RTCORBAC_H_
+
+#include "ace/pre.h"
+#include "tao/orbconf.h"
+
+#if (TAO_HAS_RT_CORBA == 1)
+
+#include "corbafwd.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "IOPC.h"
+#include "tao/PolicyC.h"
+#include "TimeBaseC.h"
+
+#if defined (TAO_EXPORT_MACRO)
+#undef TAO_EXPORT_MACRO
+#endif
+#define TAO_EXPORT_MACRO TAO_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_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 */
+
+class TAO_Priority_Mapping;
+
+TAO_NAMESPACE  RTCORBA
+{
+  typedef CORBA::Short NativePriority;
+  typedef CORBA::Short_out NativePriority_out;
+    TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_NativePriority;
+
+  typedef CORBA::Short Priority;
+  typedef CORBA::Short_out Priority_out;
+    TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Priority;
+
+  TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short minPriority;
+
+  TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short maxPriority;
+
+  typedef TAO_Priority_Mapping PriorityMapping;
+  typedef CORBA::ULong ThreadpoolId;
+  typedef CORBA::ULong_out ThreadpoolId_out;
+    TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ThreadpoolId;
+
+  struct ThreadpoolLane;
+  class ThreadpoolLane_var;
+
+  struct TAO_Export ThreadpoolLane
+  {
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef ThreadpoolLane_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    static void _tao_any_destructor (void*);
+
+    ACE_NESTED_CLASS (RTCORBA, Priority) lane_priority;
+    CORBA::ULong static_threads;
+    CORBA::ULong dynamic_threads;
+  };
+
+  class TAO_Export ThreadpoolLane_var
+  {
+  public:
+    ThreadpoolLane_var (void); // default constructor
+    ThreadpoolLane_var (ThreadpoolLane *);
+    ThreadpoolLane_var (const ThreadpoolLane_var &); // copy constructor
+    ThreadpoolLane_var (const ThreadpoolLane &); // fixed-size types only
+    ~ThreadpoolLane_var (void); // destructor
+
+    ThreadpoolLane_var &operator= (ThreadpoolLane *);
+    ThreadpoolLane_var &operator= (const ThreadpoolLane_var &);
+    ThreadpoolLane_var &operator= (const ThreadpoolLane &); // fixed-size types only
+    ThreadpoolLane *operator-> (void);
+    const ThreadpoolLane *operator-> (void) const;
+
+    operator const ThreadpoolLane &() const;
+    operator ThreadpoolLane &();
+    operator ThreadpoolLane &() const;
+
+    // in, inout, out, _retn
+    const ThreadpoolLane &in (void) const;
+    ThreadpoolLane &inout (void);
+    ThreadpoolLane &out (void);
+    ThreadpoolLane _retn (void);
+    ThreadpoolLane *ptr (void) const;
+
+  private:
+    ThreadpoolLane *ptr_;
+  };
+
+  typedef ThreadpoolLane &ThreadpoolLane_out;
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ThreadpoolLane;
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_THREADPOOLLANES_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_THREADPOOLLANES_CH_
+
+    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+
+      _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (void); // Default constructor.
+      _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (CORBA::ULong maximum);
+      _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (CORBA::ULong maximum,
+        CORBA::ULong length,
+        ThreadpoolLane *data,
+        CORBA::Boolean release = 0);
+      _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (const _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes &rhs);
+      _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes &operator= (const _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes &rhs);
+      virtual ~_TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes (void); // Dtor.
+      // = Accessors.
+      ThreadpoolLane &operator[] (CORBA::ULong i);
+      const ThreadpoolLane &operator[] (CORBA::ULong i) const;
+      // = Static operations.
+      static ThreadpoolLane *allocbuf (CORBA::ULong size);
+      static void freebuf (ThreadpoolLane *buffer);
+      virtual void _allocate_buffer (CORBA::ULong length);
+      virtual void _deallocate_buffer (void);
+      // Implement the TAO_Base_Sequence methods (see Sequence.h)
+
+      ThreadpoolLane *get_buffer (CORBA::Boolean orphan = 0);
+      const ThreadpoolLane *get_buffer (void) const;
+      void replace (CORBA::ULong max,
+        CORBA::ULong length,
+        ThreadpoolLane *data,
+        CORBA::Boolean release);
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+
+#if !defined (_RTCORBA_THREADPOOLLANES_CH_)
+#define _RTCORBA_THREADPOOLLANES_CH_
+
+  class ThreadpoolLanes;
+  class ThreadpoolLanes_var;
+
+  // *************************************************************
+  // ThreadpoolLanes
+  // *************************************************************
+
+  class TAO_Export ThreadpoolLanes : public
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    _TAO_Unbounded_Sequence_RTCORBA_ThreadpoolLanes
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+    TAO_Unbounded_Sequence<ThreadpoolLane>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  {
+  public:
+    ThreadpoolLanes (void); // default ctor
+    ThreadpoolLanes (CORBA::ULong max); // uses max size
+    ThreadpoolLanes (
+      CORBA::ULong max,
+      CORBA::ULong length,
+      ThreadpoolLane *buffer,
+      CORBA::Boolean release=0
+    );
+    ThreadpoolLanes (const ThreadpoolLanes &); // copy ctor
+    ~ThreadpoolLanes (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef ThreadpoolLanes_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_THREADPOOLLANES___VAR_CH_)
+#define _RTCORBA_THREADPOOLLANES___VAR_CH_
+
+  // *************************************************************
+  // class RTCORBA::ThreadpoolLanes_var
+  // *************************************************************
+
+  class TAO_Export ThreadpoolLanes_var
+  {
+  public:
+    ThreadpoolLanes_var (void); // default constructor
+    ThreadpoolLanes_var (ThreadpoolLanes *);
+    ThreadpoolLanes_var (const ThreadpoolLanes_var &); // copy constructor
+    ThreadpoolLanes_var (const ThreadpoolLanes &); // fixed-size base types only
+    ~ThreadpoolLanes_var (void); // destructor
+
+    ThreadpoolLanes_var &operator= (ThreadpoolLanes *);
+    ThreadpoolLanes_var &operator= (const ThreadpoolLanes_var &);
+    ThreadpoolLanes_var &operator= (const ThreadpoolLanes &); // fixed-size base types only
+    ThreadpoolLanes *operator-> (void);
+    const ThreadpoolLanes *operator-> (void) const;
+
+    operator const ThreadpoolLanes &() const;
+    operator ThreadpoolLanes &();
+    operator ThreadpoolLanes &() const;
+
+    ThreadpoolLane &operator[] (CORBA::ULong index);
+    // in, inout, out, _retn
+    const ThreadpoolLanes &in (void) const;
+    ThreadpoolLanes &inout (void);
+    ThreadpoolLanes *&out (void);
+    ThreadpoolLanes *_retn (void);
+    ThreadpoolLanes *ptr (void) const;
+
+  private:
+    ThreadpoolLanes *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_THREADPOOLLANES___OUT_CH_)
+#define _RTCORBA_THREADPOOLLANES___OUT_CH_
+
+  class TAO_Export ThreadpoolLanes_out
+  {
+  public:
+    ThreadpoolLanes_out (ThreadpoolLanes *&);
+    ThreadpoolLanes_out (ThreadpoolLanes_var &);
+    ThreadpoolLanes_out (const ThreadpoolLanes_out &);
+    ThreadpoolLanes_out &operator= (const ThreadpoolLanes_out &);
+    ThreadpoolLanes_out &operator= (ThreadpoolLanes *);
+    operator ThreadpoolLanes *&();
+    ThreadpoolLanes *&ptr (void);
+    ThreadpoolLanes *operator-> (void);
+    ThreadpoolLane &operator[] (CORBA::ULong index);
+
+  private:
+    ThreadpoolLanes *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const ThreadpoolLanes_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ThreadpoolLanes;
+
+  TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong PRIORITY_MODEL_POLICY_TYPE;
+
+  enum PriorityModel
+  {
+        CLIENT_PROPAGATED,
+        SERVER_DECLARED,
+        PriorityModel_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF
+  };
+  typedef PriorityModel &PriorityModel_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PriorityModel;
+
+
+#if !defined (_RTCORBA_PRIORITYMODELPOLICY___PTR_CH_)
+#define _RTCORBA_PRIORITYMODELPOLICY___PTR_CH_
+
+  class PriorityModelPolicy;
+  typedef PriorityModelPolicy *PriorityModelPolicy_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PRIORITYMODELPOLICY___VAR_CH_)
+#define _RTCORBA_PRIORITYMODELPOLICY___VAR_CH_
+
+  class TAO_Export PriorityModelPolicy_var : public TAO_Base_var
+  {
+  public:
+    PriorityModelPolicy_var (void); // default constructor
+    PriorityModelPolicy_var (PriorityModelPolicy_ptr);
+    PriorityModelPolicy_var (const PriorityModelPolicy_var &); // copy constructor
+    ~PriorityModelPolicy_var (void); // destructor
+
+    PriorityModelPolicy_var &operator= (PriorityModelPolicy_ptr);
+    PriorityModelPolicy_var &operator= (const PriorityModelPolicy_var &);
+    PriorityModelPolicy_ptr operator-> (void) const;
+
+    operator const PriorityModelPolicy_ptr &() const;
+    operator PriorityModelPolicy_ptr &();
+    // in, inout, out, _retn
+    PriorityModelPolicy_ptr in (void) const;
+    PriorityModelPolicy_ptr &inout (void);
+    PriorityModelPolicy_ptr &out (void);
+    PriorityModelPolicy_ptr _retn (void);
+    PriorityModelPolicy_ptr ptr (void) const;
+
+  private:
+    PriorityModelPolicy_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    PriorityModelPolicy_var (const TAO_Base_var &rhs);
+    PriorityModelPolicy_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PRIORITYMODELPOLICY___OUT_CH_)
+#define _RTCORBA_PRIORITYMODELPOLICY___OUT_CH_
+
+  class TAO_Export PriorityModelPolicy_out
+  {
+  public:
+    PriorityModelPolicy_out (PriorityModelPolicy_ptr &);
+    PriorityModelPolicy_out (PriorityModelPolicy_var &);
+    PriorityModelPolicy_out (const PriorityModelPolicy_out &);
+    PriorityModelPolicy_out &operator= (const PriorityModelPolicy_out &);
+    PriorityModelPolicy_out &operator= (const PriorityModelPolicy_var &);
+    PriorityModelPolicy_out &operator= (PriorityModelPolicy_ptr);
+    operator PriorityModelPolicy_ptr &();
+    PriorityModelPolicy_ptr &ptr (void);
+    PriorityModelPolicy_ptr operator-> (void);
+
+  private:
+    PriorityModelPolicy_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PRIORITYMODELPOLICY_CH_)
+#define _RTCORBA_PRIORITYMODELPOLICY_CH_
+
+class TAO_Export PriorityModelPolicy: public virtual CORBA::Policy
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef PriorityModelPolicy_ptr _ptr_type;
+    typedef PriorityModelPolicy_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static PriorityModelPolicy_ptr _duplicate (PriorityModelPolicy_ptr obj);
+    static PriorityModelPolicy_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static PriorityModelPolicy_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static PriorityModelPolicy_ptr _nil (void)
+      {
+        return (PriorityModelPolicy_ptr)0;
+      }
+
+    virtual RTCORBA::PriorityModel priority_model (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual RTCORBA::Priority server_priority (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    PriorityModelPolicy (void);
+    virtual ~PriorityModelPolicy (void);
+  private:
+    PriorityModelPolicy (const PriorityModelPolicy &);
+    void operator= (const PriorityModelPolicy &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong THREADPOOL_POLICY_TYPE;
+
+
+#if !defined (_RTCORBA_THREADPOOLPOLICY___PTR_CH_)
+#define _RTCORBA_THREADPOOLPOLICY___PTR_CH_
+
+  class ThreadpoolPolicy;
+  typedef ThreadpoolPolicy *ThreadpoolPolicy_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_THREADPOOLPOLICY___VAR_CH_)
+#define _RTCORBA_THREADPOOLPOLICY___VAR_CH_
+
+  class TAO_Export ThreadpoolPolicy_var : public TAO_Base_var
+  {
+  public:
+    ThreadpoolPolicy_var (void); // default constructor
+    ThreadpoolPolicy_var (ThreadpoolPolicy_ptr);
+    ThreadpoolPolicy_var (const ThreadpoolPolicy_var &); // copy constructor
+    ~ThreadpoolPolicy_var (void); // destructor
+
+    ThreadpoolPolicy_var &operator= (ThreadpoolPolicy_ptr);
+    ThreadpoolPolicy_var &operator= (const ThreadpoolPolicy_var &);
+    ThreadpoolPolicy_ptr operator-> (void) const;
+
+    operator const ThreadpoolPolicy_ptr &() const;
+    operator ThreadpoolPolicy_ptr &();
+    // in, inout, out, _retn
+    ThreadpoolPolicy_ptr in (void) const;
+    ThreadpoolPolicy_ptr &inout (void);
+    ThreadpoolPolicy_ptr &out (void);
+    ThreadpoolPolicy_ptr _retn (void);
+    ThreadpoolPolicy_ptr ptr (void) const;
+
+  private:
+    ThreadpoolPolicy_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    ThreadpoolPolicy_var (const TAO_Base_var &rhs);
+    ThreadpoolPolicy_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_THREADPOOLPOLICY___OUT_CH_)
+#define _RTCORBA_THREADPOOLPOLICY___OUT_CH_
+
+  class TAO_Export ThreadpoolPolicy_out
+  {
+  public:
+    ThreadpoolPolicy_out (ThreadpoolPolicy_ptr &);
+    ThreadpoolPolicy_out (ThreadpoolPolicy_var &);
+    ThreadpoolPolicy_out (const ThreadpoolPolicy_out &);
+    ThreadpoolPolicy_out &operator= (const ThreadpoolPolicy_out &);
+    ThreadpoolPolicy_out &operator= (const ThreadpoolPolicy_var &);
+    ThreadpoolPolicy_out &operator= (ThreadpoolPolicy_ptr);
+    operator ThreadpoolPolicy_ptr &();
+    ThreadpoolPolicy_ptr &ptr (void);
+    ThreadpoolPolicy_ptr operator-> (void);
+
+  private:
+    ThreadpoolPolicy_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_THREADPOOLPOLICY_CH_)
+#define _RTCORBA_THREADPOOLPOLICY_CH_
+
+class TAO_Export ThreadpoolPolicy: public virtual CORBA::Policy
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef ThreadpoolPolicy_ptr _ptr_type;
+    typedef ThreadpoolPolicy_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static ThreadpoolPolicy_ptr _duplicate (ThreadpoolPolicy_ptr obj);
+    static ThreadpoolPolicy_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static ThreadpoolPolicy_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static ThreadpoolPolicy_ptr _nil (void)
+      {
+        return (ThreadpoolPolicy_ptr)0;
+      }
+
+    virtual RTCORBA::ThreadpoolId threadpool (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    ThreadpoolPolicy (void);
+    virtual ~ThreadpoolPolicy (void);
+  private:
+    ThreadpoolPolicy (const ThreadpoolPolicy &);
+    void operator= (const ThreadpoolPolicy &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong PRIVATE_CONNECTION_POLICY_TYPE;
+
+
+#if !defined (_RTCORBA_PRIVATECONNECTIONPOLICY___PTR_CH_)
+#define _RTCORBA_PRIVATECONNECTIONPOLICY___PTR_CH_
+
+  class PrivateConnectionPolicy;
+  typedef PrivateConnectionPolicy *PrivateConnectionPolicy_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PRIVATECONNECTIONPOLICY___VAR_CH_)
+#define _RTCORBA_PRIVATECONNECTIONPOLICY___VAR_CH_
+
+  class TAO_Export PrivateConnectionPolicy_var : public TAO_Base_var
+  {
+  public:
+    PrivateConnectionPolicy_var (void); // default constructor
+    PrivateConnectionPolicy_var (PrivateConnectionPolicy_ptr);
+    PrivateConnectionPolicy_var (const PrivateConnectionPolicy_var &); // copy constructor
+    ~PrivateConnectionPolicy_var (void); // destructor
+
+    PrivateConnectionPolicy_var &operator= (PrivateConnectionPolicy_ptr);
+    PrivateConnectionPolicy_var &operator= (const PrivateConnectionPolicy_var &);
+    PrivateConnectionPolicy_ptr operator-> (void) const;
+
+    operator const PrivateConnectionPolicy_ptr &() const;
+    operator PrivateConnectionPolicy_ptr &();
+    // in, inout, out, _retn
+    PrivateConnectionPolicy_ptr in (void) const;
+    PrivateConnectionPolicy_ptr &inout (void);
+    PrivateConnectionPolicy_ptr &out (void);
+    PrivateConnectionPolicy_ptr _retn (void);
+    PrivateConnectionPolicy_ptr ptr (void) const;
+
+  private:
+    PrivateConnectionPolicy_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    PrivateConnectionPolicy_var (const TAO_Base_var &rhs);
+    PrivateConnectionPolicy_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PRIVATECONNECTIONPOLICY___OUT_CH_)
+#define _RTCORBA_PRIVATECONNECTIONPOLICY___OUT_CH_
+
+  class TAO_Export PrivateConnectionPolicy_out
+  {
+  public:
+    PrivateConnectionPolicy_out (PrivateConnectionPolicy_ptr &);
+    PrivateConnectionPolicy_out (PrivateConnectionPolicy_var &);
+    PrivateConnectionPolicy_out (const PrivateConnectionPolicy_out &);
+    PrivateConnectionPolicy_out &operator= (const PrivateConnectionPolicy_out &);
+    PrivateConnectionPolicy_out &operator= (const PrivateConnectionPolicy_var &);
+    PrivateConnectionPolicy_out &operator= (PrivateConnectionPolicy_ptr);
+    operator PrivateConnectionPolicy_ptr &();
+    PrivateConnectionPolicy_ptr &ptr (void);
+    PrivateConnectionPolicy_ptr operator-> (void);
+
+  private:
+    PrivateConnectionPolicy_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PRIVATECONNECTIONPOLICY_CH_)
+#define _RTCORBA_PRIVATECONNECTIONPOLICY_CH_
+
+class TAO_Export PrivateConnectionPolicy: public virtual CORBA::Policy
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef PrivateConnectionPolicy_ptr _ptr_type;
+    typedef PrivateConnectionPolicy_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static PrivateConnectionPolicy_ptr _duplicate (PrivateConnectionPolicy_ptr obj);
+    static PrivateConnectionPolicy_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static PrivateConnectionPolicy_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static PrivateConnectionPolicy_ptr _nil (void)
+      {
+        return (PrivateConnectionPolicy_ptr)0;
+      }
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    PrivateConnectionPolicy (void);
+    virtual ~PrivateConnectionPolicy (void);
+  private:
+    PrivateConnectionPolicy (const PrivateConnectionPolicy &);
+    void operator= (const PrivateConnectionPolicy &);
+  };
+
+
+#endif /* end #if !defined */
+
+  struct PriorityBand;
+  class PriorityBand_var;
+
+  struct TAO_Export PriorityBand
+  {
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef PriorityBand_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    static void _tao_any_destructor (void*);
+
+    ACE_NESTED_CLASS (RTCORBA, Priority) low;
+    ACE_NESTED_CLASS (RTCORBA, Priority) high;
+  };
+
+  class TAO_Export PriorityBand_var
+  {
+  public:
+    PriorityBand_var (void); // default constructor
+    PriorityBand_var (PriorityBand *);
+    PriorityBand_var (const PriorityBand_var &); // copy constructor
+    PriorityBand_var (const PriorityBand &); // fixed-size types only
+    ~PriorityBand_var (void); // destructor
+
+    PriorityBand_var &operator= (PriorityBand *);
+    PriorityBand_var &operator= (const PriorityBand_var &);
+    PriorityBand_var &operator= (const PriorityBand &); // fixed-size types only
+    PriorityBand *operator-> (void);
+    const PriorityBand *operator-> (void) const;
+
+    operator const PriorityBand &() const;
+    operator PriorityBand &();
+    operator PriorityBand &() const;
+
+    // in, inout, out, _retn
+    const PriorityBand &in (void) const;
+    PriorityBand &inout (void);
+    PriorityBand &out (void);
+    PriorityBand _retn (void);
+    PriorityBand *ptr (void) const;
+
+  private:
+    PriorityBand *ptr_;
+  };
+
+  typedef PriorityBand &PriorityBand_out;
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PriorityBand;
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_PRIORITYBANDS_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_PRIORITYBANDS_CH_
+
+    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_RTCORBA_PriorityBands : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+
+      _TAO_Unbounded_Sequence_RTCORBA_PriorityBands (void); // Default constructor.
+      _TAO_Unbounded_Sequence_RTCORBA_PriorityBands (CORBA::ULong maximum);
+      _TAO_Unbounded_Sequence_RTCORBA_PriorityBands (CORBA::ULong maximum,
+        CORBA::ULong length,
+        PriorityBand *data,
+        CORBA::Boolean release = 0);
+      _TAO_Unbounded_Sequence_RTCORBA_PriorityBands (const _TAO_Unbounded_Sequence_RTCORBA_PriorityBands &rhs);
+      _TAO_Unbounded_Sequence_RTCORBA_PriorityBands &operator= (const _TAO_Unbounded_Sequence_RTCORBA_PriorityBands &rhs);
+      virtual ~_TAO_Unbounded_Sequence_RTCORBA_PriorityBands (void); // Dtor.
+      // = Accessors.
+      PriorityBand &operator[] (CORBA::ULong i);
+      const PriorityBand &operator[] (CORBA::ULong i) const;
+      // = Static operations.
+      static PriorityBand *allocbuf (CORBA::ULong size);
+      static void freebuf (PriorityBand *buffer);
+      virtual void _allocate_buffer (CORBA::ULong length);
+      virtual void _deallocate_buffer (void);
+      // Implement the TAO_Base_Sequence methods (see Sequence.h)
+
+      PriorityBand *get_buffer (CORBA::Boolean orphan = 0);
+      const PriorityBand *get_buffer (void) const;
+      void replace (CORBA::ULong max,
+        CORBA::ULong length,
+        PriorityBand *data,
+        CORBA::Boolean release);
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+
+#if !defined (_RTCORBA_PRIORITYBANDS_CH_)
+#define _RTCORBA_PRIORITYBANDS_CH_
+
+  class PriorityBands;
+  class PriorityBands_var;
+
+  // *************************************************************
+  // PriorityBands
+  // *************************************************************
+
+  class TAO_Export PriorityBands : public
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    _TAO_Unbounded_Sequence_RTCORBA_PriorityBands
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+    TAO_Unbounded_Sequence<PriorityBand>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  {
+  public:
+    PriorityBands (void); // default ctor
+    PriorityBands (CORBA::ULong max); // uses max size
+    PriorityBands (
+      CORBA::ULong max,
+      CORBA::ULong length,
+      PriorityBand *buffer,
+      CORBA::Boolean release=0
+    );
+    PriorityBands (const PriorityBands &); // copy ctor
+    ~PriorityBands (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef PriorityBands_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PRIORITYBANDS___VAR_CH_)
+#define _RTCORBA_PRIORITYBANDS___VAR_CH_
+
+  // *************************************************************
+  // class RTCORBA::PriorityBands_var
+  // *************************************************************
+
+  class TAO_Export PriorityBands_var
+  {
+  public:
+    PriorityBands_var (void); // default constructor
+    PriorityBands_var (PriorityBands *);
+    PriorityBands_var (const PriorityBands_var &); // copy constructor
+    PriorityBands_var (const PriorityBands &); // fixed-size base types only
+    ~PriorityBands_var (void); // destructor
+
+    PriorityBands_var &operator= (PriorityBands *);
+    PriorityBands_var &operator= (const PriorityBands_var &);
+    PriorityBands_var &operator= (const PriorityBands &); // fixed-size base types only
+    PriorityBands *operator-> (void);
+    const PriorityBands *operator-> (void) const;
+
+    operator const PriorityBands &() const;
+    operator PriorityBands &();
+    operator PriorityBands &() const;
+
+    PriorityBand &operator[] (CORBA::ULong index);
+    // in, inout, out, _retn
+    const PriorityBands &in (void) const;
+    PriorityBands &inout (void);
+    PriorityBands *&out (void);
+    PriorityBands *_retn (void);
+    PriorityBands *ptr (void) const;
+
+  private:
+    PriorityBands *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PRIORITYBANDS___OUT_CH_)
+#define _RTCORBA_PRIORITYBANDS___OUT_CH_
+
+  class TAO_Export PriorityBands_out
+  {
+  public:
+    PriorityBands_out (PriorityBands *&);
+    PriorityBands_out (PriorityBands_var &);
+    PriorityBands_out (const PriorityBands_out &);
+    PriorityBands_out &operator= (const PriorityBands_out &);
+    PriorityBands_out &operator= (PriorityBands *);
+    operator PriorityBands *&();
+    PriorityBands *&ptr (void);
+    PriorityBands *operator-> (void);
+    PriorityBand &operator[] (CORBA::ULong index);
+
+  private:
+    PriorityBands *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const PriorityBands_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PriorityBands;
+
+  TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong PRIORITY_BANDED_CONNECTION_POLICY_TYPE;
+
+
+#if !defined (_RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___PTR_CH_)
+#define _RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___PTR_CH_
+
+  class PriorityBandedConnectionPolicy;
+  typedef PriorityBandedConnectionPolicy *PriorityBandedConnectionPolicy_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___VAR_CH_)
+#define _RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___VAR_CH_
+
+  class TAO_Export PriorityBandedConnectionPolicy_var : public TAO_Base_var
+  {
+  public:
+    PriorityBandedConnectionPolicy_var (void); // default constructor
+    PriorityBandedConnectionPolicy_var (PriorityBandedConnectionPolicy_ptr);
+    PriorityBandedConnectionPolicy_var (const PriorityBandedConnectionPolicy_var &); // copy constructor
+    ~PriorityBandedConnectionPolicy_var (void); // destructor
+
+    PriorityBandedConnectionPolicy_var &operator= (PriorityBandedConnectionPolicy_ptr);
+    PriorityBandedConnectionPolicy_var &operator= (const PriorityBandedConnectionPolicy_var &);
+    PriorityBandedConnectionPolicy_ptr operator-> (void) const;
+
+    operator const PriorityBandedConnectionPolicy_ptr &() const;
+    operator PriorityBandedConnectionPolicy_ptr &();
+    // in, inout, out, _retn
+    PriorityBandedConnectionPolicy_ptr in (void) const;
+    PriorityBandedConnectionPolicy_ptr &inout (void);
+    PriorityBandedConnectionPolicy_ptr &out (void);
+    PriorityBandedConnectionPolicy_ptr _retn (void);
+    PriorityBandedConnectionPolicy_ptr ptr (void) const;
+
+  private:
+    PriorityBandedConnectionPolicy_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    PriorityBandedConnectionPolicy_var (const TAO_Base_var &rhs);
+    PriorityBandedConnectionPolicy_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___OUT_CH_)
+#define _RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY___OUT_CH_
+
+  class TAO_Export PriorityBandedConnectionPolicy_out
+  {
+  public:
+    PriorityBandedConnectionPolicy_out (PriorityBandedConnectionPolicy_ptr &);
+    PriorityBandedConnectionPolicy_out (PriorityBandedConnectionPolicy_var &);
+    PriorityBandedConnectionPolicy_out (const PriorityBandedConnectionPolicy_out &);
+    PriorityBandedConnectionPolicy_out &operator= (const PriorityBandedConnectionPolicy_out &);
+    PriorityBandedConnectionPolicy_out &operator= (const PriorityBandedConnectionPolicy_var &);
+    PriorityBandedConnectionPolicy_out &operator= (PriorityBandedConnectionPolicy_ptr);
+    operator PriorityBandedConnectionPolicy_ptr &();
+    PriorityBandedConnectionPolicy_ptr &ptr (void);
+    PriorityBandedConnectionPolicy_ptr operator-> (void);
+
+  private:
+    PriorityBandedConnectionPolicy_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY_CH_)
+#define _RTCORBA_PRIORITYBANDEDCONNECTIONPOLICY_CH_
+
+class TAO_Export PriorityBandedConnectionPolicy: public virtual CORBA::Policy
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef PriorityBandedConnectionPolicy_ptr _ptr_type;
+    typedef PriorityBandedConnectionPolicy_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static PriorityBandedConnectionPolicy_ptr _duplicate (PriorityBandedConnectionPolicy_ptr obj);
+    static PriorityBandedConnectionPolicy_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static PriorityBandedConnectionPolicy_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static PriorityBandedConnectionPolicy_ptr _nil (void)
+      {
+        return (PriorityBandedConnectionPolicy_ptr)0;
+      }
+
+    virtual RTCORBA::PriorityBands * priority_bands (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    PriorityBandedConnectionPolicy (void);
+    virtual ~PriorityBandedConnectionPolicy (void);
+  private:
+    PriorityBandedConnectionPolicy (const PriorityBandedConnectionPolicy &);
+    void operator= (const PriorityBandedConnectionPolicy &);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PROTOCOLPROPERTIES___PTR_CH_)
+#define _RTCORBA_PROTOCOLPROPERTIES___PTR_CH_
+
+  class ProtocolProperties;
+  typedef ProtocolProperties *ProtocolProperties_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PROTOCOLPROPERTIES___VAR_CH_)
+#define _RTCORBA_PROTOCOLPROPERTIES___VAR_CH_
+
+  class TAO_Export ProtocolProperties_var : public TAO_Base_var
+  {
+  public:
+    ProtocolProperties_var (void); // default constructor
+    ProtocolProperties_var (ProtocolProperties_ptr);
+    ProtocolProperties_var (const ProtocolProperties_var &); // copy constructor
+    ~ProtocolProperties_var (void); // destructor
+
+    ProtocolProperties_var &operator= (ProtocolProperties_ptr);
+    ProtocolProperties_var &operator= (const ProtocolProperties_var &);
+    ProtocolProperties_ptr operator-> (void) const;
+
+    operator const ProtocolProperties_ptr &() const;
+    operator ProtocolProperties_ptr &();
+    // in, inout, out, _retn
+    ProtocolProperties_ptr in (void) const;
+    ProtocolProperties_ptr &inout (void);
+    ProtocolProperties_ptr &out (void);
+    ProtocolProperties_ptr _retn (void);
+    ProtocolProperties_ptr ptr (void) const;
+
+  private:
+    ProtocolProperties_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    ProtocolProperties_var (const TAO_Base_var &rhs);
+    ProtocolProperties_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PROTOCOLPROPERTIES___OUT_CH_)
+#define _RTCORBA_PROTOCOLPROPERTIES___OUT_CH_
+
+  class TAO_Export ProtocolProperties_out
+  {
+  public:
+    ProtocolProperties_out (ProtocolProperties_ptr &);
+    ProtocolProperties_out (ProtocolProperties_var &);
+    ProtocolProperties_out (const ProtocolProperties_out &);
+    ProtocolProperties_out &operator= (const ProtocolProperties_out &);
+    ProtocolProperties_out &operator= (const ProtocolProperties_var &);
+    ProtocolProperties_out &operator= (ProtocolProperties_ptr);
+    operator ProtocolProperties_ptr &();
+    ProtocolProperties_ptr &ptr (void);
+    ProtocolProperties_ptr operator-> (void);
+
+  private:
+    ProtocolProperties_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PROTOCOLPROPERTIES_CH_)
+#define _RTCORBA_PROTOCOLPROPERTIES_CH_
+
+class TAO_Export ProtocolProperties : public virtual CORBA_Object
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef ProtocolProperties_ptr _ptr_type;
+    typedef ProtocolProperties_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static ProtocolProperties_ptr _duplicate (ProtocolProperties_ptr obj);
+    static ProtocolProperties_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static ProtocolProperties_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static ProtocolProperties_ptr _nil (void)
+      {
+        return (ProtocolProperties_ptr)0;
+      }
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    ProtocolProperties (void);
+    virtual ~ProtocolProperties (void);
+  private:
+    ProtocolProperties (const ProtocolProperties &);
+    void operator= (const ProtocolProperties &);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_TCPPROTOCOLPROPERTIES___PTR_CH_)
+#define _RTCORBA_TCPPROTOCOLPROPERTIES___PTR_CH_
+
+  class TCPProtocolProperties;
+  typedef TCPProtocolProperties *TCPProtocolProperties_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_TCPPROTOCOLPROPERTIES___VAR_CH_)
+#define _RTCORBA_TCPPROTOCOLPROPERTIES___VAR_CH_
+
+  class TAO_Export TCPProtocolProperties_var : public TAO_Base_var
+  {
+  public:
+    TCPProtocolProperties_var (void); // default constructor
+    TCPProtocolProperties_var (TCPProtocolProperties_ptr);
+    TCPProtocolProperties_var (const TCPProtocolProperties_var &); // copy constructor
+    ~TCPProtocolProperties_var (void); // destructor
+
+    TCPProtocolProperties_var &operator= (TCPProtocolProperties_ptr);
+    TCPProtocolProperties_var &operator= (const TCPProtocolProperties_var &);
+    TCPProtocolProperties_ptr operator-> (void) const;
+
+    operator const TCPProtocolProperties_ptr &() const;
+    operator TCPProtocolProperties_ptr &();
+    // in, inout, out, _retn
+    TCPProtocolProperties_ptr in (void) const;
+    TCPProtocolProperties_ptr &inout (void);
+    TCPProtocolProperties_ptr &out (void);
+    TCPProtocolProperties_ptr _retn (void);
+    TCPProtocolProperties_ptr ptr (void) const;
+
+  private:
+    TCPProtocolProperties_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    TCPProtocolProperties_var (const TAO_Base_var &rhs);
+    TCPProtocolProperties_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_TCPPROTOCOLPROPERTIES___OUT_CH_)
+#define _RTCORBA_TCPPROTOCOLPROPERTIES___OUT_CH_
+
+  class TAO_Export TCPProtocolProperties_out
+  {
+  public:
+    TCPProtocolProperties_out (TCPProtocolProperties_ptr &);
+    TCPProtocolProperties_out (TCPProtocolProperties_var &);
+    TCPProtocolProperties_out (const TCPProtocolProperties_out &);
+    TCPProtocolProperties_out &operator= (const TCPProtocolProperties_out &);
+    TCPProtocolProperties_out &operator= (const TCPProtocolProperties_var &);
+    TCPProtocolProperties_out &operator= (TCPProtocolProperties_ptr);
+    operator TCPProtocolProperties_ptr &();
+    TCPProtocolProperties_ptr &ptr (void);
+    TCPProtocolProperties_ptr operator-> (void);
+
+  private:
+    TCPProtocolProperties_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_TCPPROTOCOLPROPERTIES_CH_)
+#define _RTCORBA_TCPPROTOCOLPROPERTIES_CH_
+
+class TAO_Export TCPProtocolProperties: public virtual ProtocolProperties
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef TCPProtocolProperties_ptr _ptr_type;
+    typedef TCPProtocolProperties_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static TCPProtocolProperties_ptr _duplicate (TCPProtocolProperties_ptr obj);
+    static TCPProtocolProperties_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static TCPProtocolProperties_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static TCPProtocolProperties_ptr _nil (void)
+      {
+        return (TCPProtocolProperties_ptr)0;
+      }
+
+    virtual CORBA::Long send_buffer_size (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void send_buffer_size (
+        CORBA::Long send_buffer_size,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::Long recv_buffer_size (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void recv_buffer_size (
+        CORBA::Long recv_buffer_size,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::Boolean keep_alive (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void keep_alive (
+        CORBA::Boolean keep_alive,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::Boolean dont_route (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void dont_route (
+        CORBA::Boolean dont_route,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::Boolean no_delay (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void no_delay (
+        CORBA::Boolean no_delay,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    TCPProtocolProperties (void);
+    virtual ~TCPProtocolProperties (void);
+  private:
+    TCPProtocolProperties (const TCPProtocolProperties &);
+    void operator= (const TCPProtocolProperties &);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_GIOPPROTOCOLPROPERTIES___PTR_CH_)
+#define _RTCORBA_GIOPPROTOCOLPROPERTIES___PTR_CH_
+
+  class GIOPProtocolProperties;
+  typedef GIOPProtocolProperties *GIOPProtocolProperties_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_GIOPPROTOCOLPROPERTIES___VAR_CH_)
+#define _RTCORBA_GIOPPROTOCOLPROPERTIES___VAR_CH_
+
+  class TAO_Export GIOPProtocolProperties_var : public TAO_Base_var
+  {
+  public:
+    GIOPProtocolProperties_var (void); // default constructor
+    GIOPProtocolProperties_var (GIOPProtocolProperties_ptr);
+    GIOPProtocolProperties_var (const GIOPProtocolProperties_var &); // copy constructor
+    ~GIOPProtocolProperties_var (void); // destructor
+
+    GIOPProtocolProperties_var &operator= (GIOPProtocolProperties_ptr);
+    GIOPProtocolProperties_var &operator= (const GIOPProtocolProperties_var &);
+    GIOPProtocolProperties_ptr operator-> (void) const;
+
+    operator const GIOPProtocolProperties_ptr &() const;
+    operator GIOPProtocolProperties_ptr &();
+    // in, inout, out, _retn
+    GIOPProtocolProperties_ptr in (void) const;
+    GIOPProtocolProperties_ptr &inout (void);
+    GIOPProtocolProperties_ptr &out (void);
+    GIOPProtocolProperties_ptr _retn (void);
+    GIOPProtocolProperties_ptr ptr (void) const;
+
+  private:
+    GIOPProtocolProperties_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    GIOPProtocolProperties_var (const TAO_Base_var &rhs);
+    GIOPProtocolProperties_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_GIOPPROTOCOLPROPERTIES___OUT_CH_)
+#define _RTCORBA_GIOPPROTOCOLPROPERTIES___OUT_CH_
+
+  class TAO_Export GIOPProtocolProperties_out
+  {
+  public:
+    GIOPProtocolProperties_out (GIOPProtocolProperties_ptr &);
+    GIOPProtocolProperties_out (GIOPProtocolProperties_var &);
+    GIOPProtocolProperties_out (const GIOPProtocolProperties_out &);
+    GIOPProtocolProperties_out &operator= (const GIOPProtocolProperties_out &);
+    GIOPProtocolProperties_out &operator= (const GIOPProtocolProperties_var &);
+    GIOPProtocolProperties_out &operator= (GIOPProtocolProperties_ptr);
+    operator GIOPProtocolProperties_ptr &();
+    GIOPProtocolProperties_ptr &ptr (void);
+    GIOPProtocolProperties_ptr operator-> (void);
+
+  private:
+    GIOPProtocolProperties_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_GIOPPROTOCOLPROPERTIES_CH_)
+#define _RTCORBA_GIOPPROTOCOLPROPERTIES_CH_
+
+class TAO_Export GIOPProtocolProperties: public virtual ProtocolProperties
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef GIOPProtocolProperties_ptr _ptr_type;
+    typedef GIOPProtocolProperties_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static GIOPProtocolProperties_ptr _duplicate (GIOPProtocolProperties_ptr obj);
+    static GIOPProtocolProperties_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static GIOPProtocolProperties_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static GIOPProtocolProperties_ptr _nil (void)
+      {
+        return (GIOPProtocolProperties_ptr)0;
+      }
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    GIOPProtocolProperties (void);
+    virtual ~GIOPProtocolProperties (void);
+  private:
+    GIOPProtocolProperties (const GIOPProtocolProperties &);
+    void operator= (const GIOPProtocolProperties &);
+  };
+
+
+#endif /* end #if !defined */
+
+  struct Protocol;
+  class Protocol_var;
+
+  struct TAO_Export Protocol
+  {
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef Protocol_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+        IOP::ProfileId protocol_type;
+    ACE_NESTED_CLASS (RTCORBA, ProtocolProperties_var) orb_protocol_properties;
+    ACE_NESTED_CLASS (RTCORBA, ProtocolProperties_var) transport_protocol_properties;
+  };
+
+  class TAO_Export Protocol_var
+  {
+  public:
+    Protocol_var (void); // default constructor
+    Protocol_var (Protocol *);
+    Protocol_var (const Protocol_var &); // copy constructor
+    ~Protocol_var (void); // destructor
+
+    Protocol_var &operator= (Protocol *);
+    Protocol_var &operator= (const Protocol_var &);
+    Protocol *operator-> (void);
+    const Protocol *operator-> (void) const;
+
+    operator const Protocol &() const;
+    operator Protocol &();
+    operator Protocol &() const;
+    operator Protocol *&(); // variable-size types only
+
+    // in, inout, out, _retn
+    const Protocol &in (void) const;
+    Protocol &inout (void);
+    Protocol *&out (void);
+    Protocol *_retn (void);
+    Protocol *ptr (void) const;
+
+  private:
+    Protocol *ptr_;
+  };
+
+  class TAO_Export Protocol_out
+  {
+  public:
+    Protocol_out (Protocol *&);
+    Protocol_out (Protocol_var &);
+    Protocol_out (const Protocol_out &);
+    Protocol_out &operator= (const Protocol_out &);
+    Protocol_out &operator= (Protocol *);
+    operator Protocol *&();
+    Protocol *&ptr (void);
+    Protocol *operator-> (void);
+
+  private:
+    Protocol *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const Protocol_var &);
+  };
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_RTCORBA_PROTOCOLLIST_CH_
+
+    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_RTCORBA_ProtocolList : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+
+      _TAO_Unbounded_Sequence_RTCORBA_ProtocolList (void); // Default constructor.
+      _TAO_Unbounded_Sequence_RTCORBA_ProtocolList (CORBA::ULong maximum);
+      _TAO_Unbounded_Sequence_RTCORBA_ProtocolList (CORBA::ULong maximum,
+        CORBA::ULong length,
+        Protocol *data,
+        CORBA::Boolean release = 0);
+      _TAO_Unbounded_Sequence_RTCORBA_ProtocolList (const _TAO_Unbounded_Sequence_RTCORBA_ProtocolList &rhs);
+      _TAO_Unbounded_Sequence_RTCORBA_ProtocolList &operator= (const _TAO_Unbounded_Sequence_RTCORBA_ProtocolList &rhs);
+      virtual ~_TAO_Unbounded_Sequence_RTCORBA_ProtocolList (void); // Dtor.
+      // = Accessors.
+      Protocol &operator[] (CORBA::ULong i);
+      const Protocol &operator[] (CORBA::ULong i) const;
+      // = Static operations.
+      static Protocol *allocbuf (CORBA::ULong size);
+      static void freebuf (Protocol *buffer);
+      virtual void _allocate_buffer (CORBA::ULong length);
+      virtual void _deallocate_buffer (void);
+      // Implement the TAO_Base_Sequence methods (see Sequence.h)
+
+      Protocol *get_buffer (CORBA::Boolean orphan = 0);
+      const Protocol *get_buffer (void) const;
+      void replace (CORBA::ULong max,
+        CORBA::ULong length,
+        Protocol *data,
+        CORBA::Boolean release);
+    };
+
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+
+#if !defined (_RTCORBA_PROTOCOLLIST_CH_)
+#define _RTCORBA_PROTOCOLLIST_CH_
+
+  class ProtocolList;
+  class ProtocolList_var;
+
+  // *************************************************************
+  // ProtocolList
+  // *************************************************************
+
+  class TAO_Export ProtocolList : public
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    _TAO_Unbounded_Sequence_RTCORBA_ProtocolList
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+    TAO_Unbounded_Sequence<Protocol>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  {
+  public:
+    ProtocolList (void); // default ctor
+    ProtocolList (CORBA::ULong max); // uses max size
+    ProtocolList (
+      CORBA::ULong max,
+      CORBA::ULong length,
+      Protocol *buffer,
+      CORBA::Boolean release=0
+    );
+    ProtocolList (const ProtocolList &); // copy ctor
+    ~ProtocolList (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef ProtocolList_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  };
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PROTOCOLLIST___VAR_CH_)
+#define _RTCORBA_PROTOCOLLIST___VAR_CH_
+
+  // *************************************************************
+  // class RTCORBA::ProtocolList_var
+  // *************************************************************
+
+  class TAO_Export ProtocolList_var
+  {
+  public:
+    ProtocolList_var (void); // default constructor
+    ProtocolList_var (ProtocolList *);
+    ProtocolList_var (const ProtocolList_var &); // copy constructor
+    ~ProtocolList_var (void); // destructor
+
+    ProtocolList_var &operator= (ProtocolList *);
+    ProtocolList_var &operator= (const ProtocolList_var &);
+    ProtocolList *operator-> (void);
+    const ProtocolList *operator-> (void) const;
+
+    operator const ProtocolList &() const;
+    operator ProtocolList &();
+    operator ProtocolList &() const;
+    operator ProtocolList *&(); // variable-size base types only
+
+    Protocol &operator[] (CORBA::ULong index);
+    // in, inout, out, _retn
+    const ProtocolList &in (void) const;
+    ProtocolList &inout (void);
+    ProtocolList *&out (void);
+    ProtocolList *_retn (void);
+    ProtocolList *ptr (void) const;
+
+  private:
+    ProtocolList *ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_PROTOCOLLIST___OUT_CH_)
+#define _RTCORBA_PROTOCOLLIST___OUT_CH_
+
+  class TAO_Export ProtocolList_out
+  {
+  public:
+    ProtocolList_out (ProtocolList *&);
+    ProtocolList_out (ProtocolList_var &);
+    ProtocolList_out (const ProtocolList_out &);
+    ProtocolList_out &operator= (const ProtocolList_out &);
+    ProtocolList_out &operator= (ProtocolList *);
+    operator ProtocolList *&();
+    ProtocolList *&ptr (void);
+    ProtocolList *operator-> (void);
+    Protocol &operator[] (CORBA::ULong index);
+
+  private:
+    ProtocolList *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const ProtocolList_var &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong SERVER_PROTOCOL_POLICY_TYPE;
+
+
+#if !defined (_RTCORBA_SERVERPROTOCOLPOLICY___PTR_CH_)
+#define _RTCORBA_SERVERPROTOCOLPOLICY___PTR_CH_
+
+  class ServerProtocolPolicy;
+  typedef ServerProtocolPolicy *ServerProtocolPolicy_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_SERVERPROTOCOLPOLICY___VAR_CH_)
+#define _RTCORBA_SERVERPROTOCOLPOLICY___VAR_CH_
+
+  class TAO_Export ServerProtocolPolicy_var : public TAO_Base_var
+  {
+  public:
+    ServerProtocolPolicy_var (void); // default constructor
+    ServerProtocolPolicy_var (ServerProtocolPolicy_ptr);
+    ServerProtocolPolicy_var (const ServerProtocolPolicy_var &); // copy constructor
+    ~ServerProtocolPolicy_var (void); // destructor
+
+    ServerProtocolPolicy_var &operator= (ServerProtocolPolicy_ptr);
+    ServerProtocolPolicy_var &operator= (const ServerProtocolPolicy_var &);
+    ServerProtocolPolicy_ptr operator-> (void) const;
+
+    operator const ServerProtocolPolicy_ptr &() const;
+    operator ServerProtocolPolicy_ptr &();
+    // in, inout, out, _retn
+    ServerProtocolPolicy_ptr in (void) const;
+    ServerProtocolPolicy_ptr &inout (void);
+    ServerProtocolPolicy_ptr &out (void);
+    ServerProtocolPolicy_ptr _retn (void);
+    ServerProtocolPolicy_ptr ptr (void) const;
+
+  private:
+    ServerProtocolPolicy_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    ServerProtocolPolicy_var (const TAO_Base_var &rhs);
+    ServerProtocolPolicy_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_SERVERPROTOCOLPOLICY___OUT_CH_)
+#define _RTCORBA_SERVERPROTOCOLPOLICY___OUT_CH_
+
+  class TAO_Export ServerProtocolPolicy_out
+  {
+  public:
+    ServerProtocolPolicy_out (ServerProtocolPolicy_ptr &);
+    ServerProtocolPolicy_out (ServerProtocolPolicy_var &);
+    ServerProtocolPolicy_out (const ServerProtocolPolicy_out &);
+    ServerProtocolPolicy_out &operator= (const ServerProtocolPolicy_out &);
+    ServerProtocolPolicy_out &operator= (const ServerProtocolPolicy_var &);
+    ServerProtocolPolicy_out &operator= (ServerProtocolPolicy_ptr);
+    operator ServerProtocolPolicy_ptr &();
+    ServerProtocolPolicy_ptr &ptr (void);
+    ServerProtocolPolicy_ptr operator-> (void);
+
+  private:
+    ServerProtocolPolicy_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_SERVERPROTOCOLPOLICY_CH_)
+#define _RTCORBA_SERVERPROTOCOLPOLICY_CH_
+
+class TAO_Export ServerProtocolPolicy: public virtual CORBA::Policy
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef ServerProtocolPolicy_ptr _ptr_type;
+    typedef ServerProtocolPolicy_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static ServerProtocolPolicy_ptr _duplicate (ServerProtocolPolicy_ptr obj);
+    static ServerProtocolPolicy_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static ServerProtocolPolicy_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static ServerProtocolPolicy_ptr _nil (void)
+      {
+        return (ServerProtocolPolicy_ptr)0;
+      }
+
+    virtual RTCORBA::ProtocolList * protocols (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    ServerProtocolPolicy (void);
+    virtual ~ServerProtocolPolicy (void);
+  private:
+    ServerProtocolPolicy (const ServerProtocolPolicy &);
+    void operator= (const ServerProtocolPolicy &);
+  };
+
+
+#endif /* end #if !defined */
+
+  TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong CLIENT_PROTOCOL_POLICY_TYPE;
+
+
+#if !defined (_RTCORBA_CLIENTPROTOCOLPOLICY___PTR_CH_)
+#define _RTCORBA_CLIENTPROTOCOLPOLICY___PTR_CH_
+
+  class ClientProtocolPolicy;
+  typedef ClientProtocolPolicy *ClientProtocolPolicy_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_CLIENTPROTOCOLPOLICY___VAR_CH_)
+#define _RTCORBA_CLIENTPROTOCOLPOLICY___VAR_CH_
+
+  class TAO_Export ClientProtocolPolicy_var : public TAO_Base_var
+  {
+  public:
+    ClientProtocolPolicy_var (void); // default constructor
+    ClientProtocolPolicy_var (ClientProtocolPolicy_ptr);
+    ClientProtocolPolicy_var (const ClientProtocolPolicy_var &); // copy constructor
+    ~ClientProtocolPolicy_var (void); // destructor
+
+    ClientProtocolPolicy_var &operator= (ClientProtocolPolicy_ptr);
+    ClientProtocolPolicy_var &operator= (const ClientProtocolPolicy_var &);
+    ClientProtocolPolicy_ptr operator-> (void) const;
+
+    operator const ClientProtocolPolicy_ptr &() const;
+    operator ClientProtocolPolicy_ptr &();
+    // in, inout, out, _retn
+    ClientProtocolPolicy_ptr in (void) const;
+    ClientProtocolPolicy_ptr &inout (void);
+    ClientProtocolPolicy_ptr &out (void);
+    ClientProtocolPolicy_ptr _retn (void);
+    ClientProtocolPolicy_ptr ptr (void) const;
+
+  private:
+    ClientProtocolPolicy_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    ClientProtocolPolicy_var (const TAO_Base_var &rhs);
+    ClientProtocolPolicy_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_CLIENTPROTOCOLPOLICY___OUT_CH_)
+#define _RTCORBA_CLIENTPROTOCOLPOLICY___OUT_CH_
+
+  class TAO_Export ClientProtocolPolicy_out
+  {
+  public:
+    ClientProtocolPolicy_out (ClientProtocolPolicy_ptr &);
+    ClientProtocolPolicy_out (ClientProtocolPolicy_var &);
+    ClientProtocolPolicy_out (const ClientProtocolPolicy_out &);
+    ClientProtocolPolicy_out &operator= (const ClientProtocolPolicy_out &);
+    ClientProtocolPolicy_out &operator= (const ClientProtocolPolicy_var &);
+    ClientProtocolPolicy_out &operator= (ClientProtocolPolicy_ptr);
+    operator ClientProtocolPolicy_ptr &();
+    ClientProtocolPolicy_ptr &ptr (void);
+    ClientProtocolPolicy_ptr operator-> (void);
+
+  private:
+    ClientProtocolPolicy_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_CLIENTPROTOCOLPOLICY_CH_)
+#define _RTCORBA_CLIENTPROTOCOLPOLICY_CH_
+
+class TAO_Export ClientProtocolPolicy: public virtual CORBA::Policy
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef ClientProtocolPolicy_ptr _ptr_type;
+    typedef ClientProtocolPolicy_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static ClientProtocolPolicy_ptr _duplicate (ClientProtocolPolicy_ptr obj);
+    static ClientProtocolPolicy_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static ClientProtocolPolicy_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static ClientProtocolPolicy_ptr _nil (void)
+      {
+        return (ClientProtocolPolicy_ptr)0;
+      }
+
+    virtual RTCORBA::ProtocolList * protocols (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    ClientProtocolPolicy (void);
+    virtual ~ClientProtocolPolicy (void);
+  private:
+    ClientProtocolPolicy (const ClientProtocolPolicy &);
+    void operator= (const ClientProtocolPolicy &);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_CURRENT___PTR_CH_)
+#define _RTCORBA_CURRENT___PTR_CH_
+
+  class Current;
+  typedef Current *Current_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_CURRENT___VAR_CH_)
+#define _RTCORBA_CURRENT___VAR_CH_
+
+  class TAO_Export Current_var : public TAO_Base_var
+  {
+  public:
+    Current_var (void); // default constructor
+    Current_var (Current_ptr);
+    Current_var (const Current_var &); // copy constructor
+    ~Current_var (void); // destructor
+
+    Current_var &operator= (Current_ptr);
+    Current_var &operator= (const Current_var &);
+    Current_ptr operator-> (void) const;
+
+    operator const Current_ptr &() const;
+    operator Current_ptr &();
+    // in, inout, out, _retn
+    Current_ptr in (void) const;
+    Current_ptr &inout (void);
+    Current_ptr &out (void);
+    Current_ptr _retn (void);
+    Current_ptr ptr (void) const;
+
+  private:
+    Current_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    Current_var (const TAO_Base_var &rhs);
+    Current_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_CURRENT___OUT_CH_)
+#define _RTCORBA_CURRENT___OUT_CH_
+
+  class TAO_Export Current_out
+  {
+  public:
+    Current_out (Current_ptr &);
+    Current_out (Current_var &);
+    Current_out (const Current_out &);
+    Current_out &operator= (const Current_out &);
+    Current_out &operator= (const Current_var &);
+    Current_out &operator= (Current_ptr);
+    operator Current_ptr &();
+    Current_ptr &ptr (void);
+    Current_ptr operator-> (void);
+
+  private:
+    Current_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_CURRENT_CH_)
+#define _RTCORBA_CURRENT_CH_
+
+class TAO_Export Current: public virtual CORBA::Current
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef Current_ptr _ptr_type;
+    typedef Current_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static Current_ptr _duplicate (Current_ptr obj);
+    static Current_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static Current_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static Current_ptr _nil (void)
+      {
+        return (Current_ptr)0;
+      }
+
+    virtual RTCORBA::Priority the_priority (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void the_priority (
+        RTCORBA::Priority the_priority,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    Current (void);
+    virtual ~Current (void);
+  private:
+    Current (const Current &);
+    void operator= (const Current &);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_MUTEX___PTR_CH_)
+#define _RTCORBA_MUTEX___PTR_CH_
+
+  class Mutex;
+  typedef Mutex *Mutex_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_MUTEX___VAR_CH_)
+#define _RTCORBA_MUTEX___VAR_CH_
+
+  class TAO_Export Mutex_var : public TAO_Base_var
+  {
+  public:
+    Mutex_var (void); // default constructor
+    Mutex_var (Mutex_ptr);
+    Mutex_var (const Mutex_var &); // copy constructor
+    ~Mutex_var (void); // destructor
+
+    Mutex_var &operator= (Mutex_ptr);
+    Mutex_var &operator= (const Mutex_var &);
+    Mutex_ptr operator-> (void) const;
+
+    operator const Mutex_ptr &() const;
+    operator Mutex_ptr &();
+    // in, inout, out, _retn
+    Mutex_ptr in (void) const;
+    Mutex_ptr &inout (void);
+    Mutex_ptr &out (void);
+    Mutex_ptr _retn (void);
+    Mutex_ptr ptr (void) const;
+
+  private:
+    Mutex_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    Mutex_var (const TAO_Base_var &rhs);
+    Mutex_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_MUTEX___OUT_CH_)
+#define _RTCORBA_MUTEX___OUT_CH_
+
+  class TAO_Export Mutex_out
+  {
+  public:
+    Mutex_out (Mutex_ptr &);
+    Mutex_out (Mutex_var &);
+    Mutex_out (const Mutex_out &);
+    Mutex_out &operator= (const Mutex_out &);
+    Mutex_out &operator= (const Mutex_var &);
+    Mutex_out &operator= (Mutex_ptr);
+    operator Mutex_ptr &();
+    Mutex_ptr &ptr (void);
+    Mutex_ptr operator-> (void);
+
+  private:
+    Mutex_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_MUTEX_CH_)
+#define _RTCORBA_MUTEX_CH_
+
+class TAO_Export Mutex : public virtual CORBA_Object
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef Mutex_ptr _ptr_type;
+    typedef Mutex_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static Mutex_ptr _duplicate (Mutex_ptr obj);
+    static Mutex_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static Mutex_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static Mutex_ptr _nil (void)
+      {
+        return (Mutex_ptr)0;
+      }
+
+    virtual void lock (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void unlock (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::Boolean try_lock (
+        TimeBase::TimeT max_wait,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+    virtual const char* _interface_repository_id (void) const;
+
+  protected:
+    Mutex (void);
+    virtual ~Mutex (void);
+  private:
+    Mutex (const Mutex &);
+    void operator= (const Mutex &);
+  };
+
+
+#endif /* end #if !defined */
+
+#if !defined (_RTCORBA_RTORB___PTR_CH_)
+#define _RTCORBA_RTORB___PTR_CH_
+
+  class RTORB;
+  typedef RTORB *RTORB_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_RTORB___VAR_CH_)
+#define _RTCORBA_RTORB___VAR_CH_
+
+  class TAO_Export RTORB_var : public TAO_Base_var
+  {
+  public:
+    RTORB_var (void); // default constructor
+    RTORB_var (RTORB_ptr);
+    RTORB_var (const RTORB_var &); // copy constructor
+    ~RTORB_var (void); // destructor
+
+    RTORB_var &operator= (RTORB_ptr);
+    RTORB_var &operator= (const RTORB_var &);
+    RTORB_ptr operator-> (void) const;
+
+    operator const RTORB_ptr &() const;
+    operator RTORB_ptr &();
+    // in, inout, out, _retn
+    RTORB_ptr in (void) const;
+    RTORB_ptr &inout (void);
+    RTORB_ptr &out (void);
+    RTORB_ptr _retn (void);
+    RTORB_ptr ptr (void) const;
+
+  private:
+    RTORB_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    RTORB_var (const TAO_Base_var &rhs);
+    RTORB_var &operator= (const TAO_Base_var &rhs);
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_RTORB___OUT_CH_)
+#define _RTCORBA_RTORB___OUT_CH_
+
+  class TAO_Export RTORB_out
+  {
+  public:
+    RTORB_out (RTORB_ptr &);
+    RTORB_out (RTORB_var &);
+    RTORB_out (const RTORB_out &);
+    RTORB_out &operator= (const RTORB_out &);
+    RTORB_out &operator= (const RTORB_var &);
+    RTORB_out &operator= (RTORB_ptr);
+    operator RTORB_ptr &();
+    RTORB_ptr &ptr (void);
+    RTORB_ptr operator-> (void);
+
+  private:
+    RTORB_ptr &ptr_;
+  };
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_RTCORBA_RTORB_CH_)
+#define _RTCORBA_RTORB_CH_
+
+class TAO_Export RTORB : public virtual CORBA_Object
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef RTORB_ptr _ptr_type;
+    typedef RTORB_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static RTORB_ptr _duplicate (RTORB_ptr obj);
+    static RTORB_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static RTORB_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static RTORB_ptr _nil (void)
+      {
+        return (RTORB_ptr)0;
+      }
+
+    virtual RTCORBA::Mutex_ptr create_mutex (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void destroy_mutex (
+        RTCORBA::Mutex_ptr the_mutex,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+
+#if !defined (_RTCORBA_RTORB_INVALIDTHREADPOOL_CH_)
+#define _RTCORBA_RTORB_INVALIDTHREADPOOL_CH_
+
+    class TAO_Export InvalidThreadpool : public CORBA::UserException
+    {
+    public:
+
+
+    InvalidThreadpool (void); // default ctor
+    InvalidThreadpool (const InvalidThreadpool &); // copy ctor
+    ~InvalidThreadpool (void);
+    InvalidThreadpool &operator= (const InvalidThreadpool &);
+
+
+    virtual void _raise (void);
+
+    virtual void _tao_encode (
+        TAO_OutputCDR &,
+        CORBA::Environment &) const;
+    virtual void _tao_decode (
+        TAO_InputCDR &,
+        CORBA::Environment &);
+
+    static InvalidThreadpool *_narrow (CORBA::Exception *);
+
+
+    // = TAO extension
+    static CORBA::Exception *_alloc (void);
+
+  }; // exception RTCORBA::RTORB::InvalidThreadpool
+
+
+#endif /* end #if !defined */
+
+  virtual RTCORBA::ThreadpoolId create_threadpool (
+      CORBA::ULong stacksize,
+      CORBA::ULong static_threads,
+      CORBA::ULong dynamic_threads,
+      RTCORBA::Priority default_priority,
+      CORBA::Boolean allow_request_buffering,
+      CORBA::ULong max_buffered_requests,
+      CORBA::ULong max_request_buffer_size,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual RTCORBA::ThreadpoolId create_threadpool_with_lanes (
+      CORBA::ULong stacksize,
+      const RTCORBA::ThreadpoolLanes & lanes,
+      CORBA::Boolean allow_borrowing,
+      CORBA::Boolean allow_request_buffering,
+      CORBA::ULong max_buffered_requests,
+      CORBA::ULong max_request_buffer_size,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void destroy_threadpool (
+      RTCORBA::ThreadpoolId threadpool,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException,
+      RTCORBA::RTORB::InvalidThreadpool
+    )) = 0;
+
+  virtual RTCORBA::PriorityModelPolicy_ptr create_priority_model_policy (
+      RTCORBA::PriorityModel priority_model,
+      RTCORBA::Priority server_priority,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual RTCORBA::ThreadpoolPolicy_ptr create_threadpool_policy (
+      RTCORBA::ThreadpoolId threadpool,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual RTCORBA::PriorityBandedConnectionPolicy_ptr create_priority_banded_connection_policy (
+      const RTCORBA::PriorityBands & priority_bands,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual RTCORBA::PrivateConnectionPolicy_ptr create_private_connection_policy (
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual RTCORBA::ServerProtocolPolicy_ptr create_server_protocol_policy (
+      const RTCORBA::ProtocolList & protocols,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual RTCORBA::ClientProtocolPolicy_ptr create_client_protocol_policy (
+      const RTCORBA::ProtocolList & protocols,
+      CORBA::Environment &ACE_TRY_ENV =
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    )) = 0;
+
+  virtual void *_tao_QueryInterface (ptr_arith_t type);
+
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  RTORB (void);
+  virtual ~RTORB (void);
+private:
+  RTORB (const RTORB &);
+  void operator= (const RTORB &);
+};
+
+
+#endif /* end #if !defined */
+
+}
+TAO_NAMESPACE_CLOSE // module RTCORBA
+
+TAO_Export void operator<<= (CORBA::Any &, const RTCORBA::ThreadpoolLane &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, RTCORBA::ThreadpoolLane*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::ThreadpoolLane *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const RTCORBA::ThreadpoolLane *&);
+TAO_Export void operator<<= (CORBA::Any &, const RTCORBA::ThreadpoolLanes &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, RTCORBA::ThreadpoolLanes*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::ThreadpoolLanes *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const RTCORBA::ThreadpoolLanes *&);
+TAO_Export void operator<<= (CORBA::Any &, RTCORBA::PriorityModel);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::PriorityModel &);
+TAO_Export void operator<<= (CORBA::Any &, const RTCORBA::PriorityBand &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, RTCORBA::PriorityBand*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::PriorityBand *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const RTCORBA::PriorityBand *&);
+TAO_Export void operator<<= (CORBA::Any &, const RTCORBA::PriorityBands &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, RTCORBA::PriorityBands*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, RTCORBA::PriorityBands *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const RTCORBA::PriorityBands *&);
+
+#ifndef __ACE_INLINE__
+
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const RTCORBA::ThreadpoolLane &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, RTCORBA::ThreadpoolLane &);
+
+#if !defined _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_H_
+#define _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const RTCORBA::ThreadpoolLanes &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    RTCORBA::ThreadpoolLanes &
+  );
+
+#endif /* _TAO_CDR_OP_RTCORBA_ThreadpoolLanes_H_ */
+
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const RTCORBA::PriorityModel &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, RTCORBA::PriorityModel &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const RTCORBA::PriorityBand &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, RTCORBA::PriorityBand &);
+
+#if !defined _TAO_CDR_OP_RTCORBA_PriorityBands_H_
+#define _TAO_CDR_OP_RTCORBA_PriorityBands_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const RTCORBA::PriorityBands &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    RTCORBA::PriorityBands &
+  );
+
+#endif /* _TAO_CDR_OP_RTCORBA_PriorityBands_H_ */
+
+
+#endif /* __ACE_INLINE__ */
+
+
+#if defined (__ACE_INLINE__)
+#include "RTCORBAC.i"
+#endif /* defined INLINE */
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#pragma warning(pop)
+#endif /* _MSC_VER */
+
+#endif /* TAO_HAS_RT_CORBA */
+
+#include "ace/post.h"
+#endif /* ifndef */