ChangeLogTag:Wed May 30 21:41:53 2001 Ossama Othman <ossama@uci.edu>

1 files changed, 444 insertions, 482 deletions

diff --git a/TAO/tao/PolicyC.h b/TAO/tao/PolicyC.h
index f3e07b3349b..a5cf9be1f72 100644
--- a/TAO/tao/PolicyC.h
+++ b/TAO/tao/PolicyC.h
@@ -23,19 +23,20 @@
 #define _TAO_IDL_ORIG_POLICYC_H_
 
 #include "ace/pre.h"
-#include "tao/CurrentC.h"
+
+#include "TAO_Export.h"
 
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-#include "TAO_Export.h"
 #include "Encodable.h"
 #include "Exception.h"
 #include "Environment.h"
 #include "Sequence.h"
 #include "CDR.h"
 #include "Remote_Object_Proxy_Impl.h"
+#include "CurrentC.h"
 
 #if defined (TAO_EXPORT_MACRO)
 #undef TAO_EXPORT_MACRO
@@ -50,7 +51,7 @@
 #endif /* TAO_EXPORT_NESTED_CLASSES */
 
 #if defined(_MSC_VER)
-#if (_MSC_VER >= 1200)
+#if (_MSC_VER >= 1]200)
 #pragma warning(push)
 #endif /* _MSC_VER >= 1200 */
 #pragma warning(disable:4250)
@@ -66,45 +67,43 @@
 class TAO_Export CORBA_PolicyError : public CORBA::UserException
 {
 public:
-  CORBA::PolicyErrorCode reason;
-
-  CORBA_PolicyError (void);
-  // Default constructor.
-  
-  CORBA_PolicyError (const CORBA_PolicyError &);
-  // Copy constructor.
-  
-  ~CORBA_PolicyError (void);
-  // Destructor.
-  
-  static void _tao_any_destructor (void*);
-  
-  CORBA_PolicyError &operator= (const CORBA_PolicyError &);
-  
-  virtual void _raise (void);
-
-  virtual void _tao_encode (
-      TAO_OutputCDR &,
-      CORBA::Environment &
-    ) const;
-  
-  virtual void _tao_decode (
-      TAO_InputCDR &,
-      CORBA::Environment &
-    );
-  
-  static CORBA_PolicyError *_downcast (CORBA::Exception *);
+    CORBA::PolicyErrorCode reason;
 
-  CORBA_PolicyError (
-      CORBA::PolicyErrorCode _tao_reason
-    );
-  
-  // = TAO extension.
-  static CORBA::Exception *_alloc (void);
-  virtual CORBA::TypeCode_ptr _type (void) const;
-}; // Exception CORBA_PolicyError.
+    CORBA_PolicyError (void);
+    // Default constructor.
+
+    CORBA_PolicyError (const CORBA_PolicyError &);
+    // Copy constructor.
 
-extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_PolicyError;
+    ~CORBA_PolicyError (void);
+    // Destructor.
+
+    static void _tao_any_destructor (void*);
+
+    CORBA_PolicyError &operator= (const CORBA_PolicyError &);
+
+    virtual void _raise (void);
+
+    virtual void _tao_encode (
+        TAO_OutputCDR &,
+        CORBA::Environment &
+      ) const;
+
+    virtual void _tao_decode (
+        TAO_InputCDR &,
+        CORBA::Environment &
+      );
+
+    static CORBA_PolicyError *_downcast (CORBA::Exception *);
+
+    CORBA_PolicyError (
+        CORBA::PolicyErrorCode _tao_reason
+      );
+
+    // = TAO extension.
+    static CORBA::Exception *_alloc (void);
+    virtual CORBA::TypeCode_ptr _type (void) const;
+  }; // Exception CORBA::PolicyError.
 
 
 #endif /* end #if !defined */
@@ -113,185 +112,173 @@ extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_PolicyError;
 #if !defined (_CORBA_INVALIDPOLICIES_CH_)
 #define _CORBA_INVALIDPOLICIES_CH_
 
-class TAO_Export CORBA_InvalidPolicies : public CORBA::UserException
-{
-public:
+  class TAO_Export CORBA_InvalidPolicies : public CORBA::UserException
+  {
+  public:
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    
+
 #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CH_)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CH_
 
-    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
-      
-      _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (void); // Default constructor.
-      _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (CORBA::ULong maximum); 
-      _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA::UShort *data,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (const _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &rhs);
-      _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &operator= (const _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &rhs);
-      virtual ~_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (void); // Dtor.
-      // = Accessors.
-      CORBA::UShort &operator[] (CORBA::ULong i);
-      const CORBA::UShort &operator[] (CORBA::ULong i) const;
-      // = Static operations.
-      static CORBA::UShort *allocbuf (CORBA::ULong size);
-      static void freebuf (CORBA::UShort *buffer);
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      // Implement the TAO_Base_Sequence methods (see Sequence.h)
-      
-      CORBA::UShort *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA::UShort *get_buffer (void) const;
-      void replace (CORBA::ULong max,
-        CORBA::ULong length,
-        CORBA::UShort *data,
-        CORBA::Boolean release);
-    };
+      class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort : public TAO_Unbounded_Base_Sequence
+      {
+      public:
+        // = Initialization and termination methods.
+
+        _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (void); // Default constructor.
+        _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (CORBA::ULong maximum);
+        _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (CORBA::ULong maximum,
+          CORBA::ULong length,
+          CORBA::UShort *data,
+          CORBA::Boolean release = 0);
+        _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (const _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &rhs);
+        _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &operator= (const _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort &rhs);
+        virtual ~_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (void); // Dtor.
+        // = Accessors.
+        CORBA::UShort &operator[] (CORBA::ULong i);
+        const CORBA::UShort &operator[] (CORBA::ULong i) const;
+        // = Static operations.
+        static CORBA::UShort *allocbuf (CORBA::ULong size);
+        static void freebuf (CORBA::UShort *buffer);
+        virtual void _allocate_buffer (CORBA::ULong length);
+        virtual void _deallocate_buffer (void);
+        // Implement the TAO_Base_Sequence methods (see Sequence.h)
+
+        CORBA::UShort *get_buffer (CORBA::Boolean orphan = 0);
+        const CORBA::UShort *get_buffer (void) const;
+        void replace (CORBA::ULong max,
+          CORBA::ULong length,
+          CORBA::UShort *data,
+          CORBA::Boolean release);
+      };
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-  
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+
 #if !defined (_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CH_)
 #define _CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CH_
 
-  class _tao_seq_UShort;
-  class _tao_seq_UShort_var;
-  
-  // *************************************************************
-  // _tao_seq_UShort
-  // *************************************************************
-  
-  class TAO_Export _tao_seq_UShort : public 
+    class _tao_seq_UShort;
+    class _tao_seq_UShort_var;
+
+    // *************************************************************
+    // _tao_seq_UShort
+    // *************************************************************
+
+    class TAO_Export _tao_seq_UShort : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort
+      _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Sequence<CORBA::UShort>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
-  {
-  public:
-    _tao_seq_UShort (void); // default ctor
-    _tao_seq_UShort (CORBA::ULong max); // uses max size
-    _tao_seq_UShort (
-      CORBA::ULong max, 
-      CORBA::ULong length, 
-      CORBA::UShort *buffer, 
-      CORBA::Boolean release = 0
-    );
-    _tao_seq_UShort (const _tao_seq_UShort &); // copy ctor
-    ~_tao_seq_UShort (void);
-    static void _tao_any_destructor (void*);
+      TAO_Unbounded_Sequence<CORBA::UShort>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+    {
+    public:
+      _tao_seq_UShort (void); // default ctor
+      _tao_seq_UShort (CORBA::ULong max); // uses max size
+      _tao_seq_UShort (
+        CORBA::ULong max,
+        CORBA::ULong length,
+        CORBA::UShort *buffer,
+        CORBA::Boolean release = 0
+      );
+      _tao_seq_UShort (const _tao_seq_UShort &); // copy ctor
+      ~_tao_seq_UShort (void);
+      static void _tao_any_destructor (void*);
 
 #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-    typedef _tao_seq_UShort_var _var_type;
+      typedef _tao_seq_UShort_var _var_type;
 #endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  };
-  
+    };
+
 #endif /* end #if !defined */
 
 #if !defined (__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef _tao_seq_UShort _indices_seq;
-#endif /* ! __GNUC__ || ACE_HAS_GNUG_PRE_2_8 */
-
-    _tao_seq_UShort indices;
-
-  CORBA_InvalidPolicies (void);
-  // Default constructor.
-  
-  CORBA_InvalidPolicies (const CORBA_InvalidPolicies &);
-  // Copy constructor.
-  
-  ~CORBA_InvalidPolicies (void);
-  // Destructor.
-  
-  static void _tao_any_destructor (void*);
-  
-  CORBA_InvalidPolicies &operator= (const CORBA_InvalidPolicies &);
-  
-  virtual void _raise (void);
-
-  virtual void _tao_encode (
-      TAO_OutputCDR &,
-      CORBA::Environment &
-    ) const;
-  
-  virtual void _tao_decode (
-      TAO_InputCDR &,
-      CORBA::Environment &
-    );
-  
-  static CORBA_InvalidPolicies *_downcast (CORBA::Exception *);
+    typedef _tao_seq_UShort _indices_seq;
+  #endif /* ! __GNUC__ || ACE_HAS_GNUG_PRE_2_8 */
 
-  CORBA_InvalidPolicies (
-      const _tao_seq_UShort & _tao_indices
-    );
-  
-  // = TAO extension.
-  static CORBA::Exception *_alloc (void);
-  virtual CORBA::TypeCode_ptr _type (void) const;
-}; // Exception CORBA_InvalidPolicies.
+          _tao_seq_UShort indices;
 
-extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_InvalidPolicies;
+    CORBA_InvalidPolicies (void);
+    // Default constructor.
 
+    CORBA_InvalidPolicies (const CORBA_InvalidPolicies &);
+    // Copy constructor.
 
-#endif /* end #if !defined */
+    ~CORBA_InvalidPolicies (void);
+    // Destructor.
 
+    static void _tao_any_destructor (void*);
 
-#if !defined (_CORBA_POLICY___PTR_CH_)
-#define _CORBA_POLICY___PTR_CH_
+    CORBA_InvalidPolicies &operator= (const CORBA_InvalidPolicies &);
 
-class CORBA_Policy;
-typedef CORBA_Policy *CORBA_Policy_ptr;
+    virtual void _raise (void);
 
-#endif /* end #if !defined */
+    virtual void _tao_encode (
+        TAO_OutputCDR &,
+        CORBA::Environment &
+      ) const;
 
+    virtual void _tao_decode (
+        TAO_InputCDR &,
+        CORBA::Environment &
+      );
 
-#if !defined (_CORBA_POLICY___VAR_CH_)
-#define _CORBA_POLICY___VAR_CH_
+    static CORBA_InvalidPolicies *_downcast (CORBA::Exception *);
 
-class TAO_Export CORBA_Policy_var : public TAO_Base_var
-{
-public:
-  CORBA_Policy_var (void); // default constructor
-  CORBA_Policy_var (CORBA_Policy_ptr p) : ptr_ (p) {} 
-  CORBA_Policy_var (const CORBA_Policy_var &); // copy constructor
-  ~CORBA_Policy_var (void); // destructor
-  
-  CORBA_Policy_var &operator= (CORBA_Policy_ptr);
-  CORBA_Policy_var &operator= (const CORBA_Policy_var &);
-  CORBA_Policy_ptr operator-> (void) const;
-  
-  operator const CORBA_Policy_ptr &() const;
-  operator CORBA_Policy_ptr &();
-  // in, inout, out, _retn 
-  CORBA_Policy_ptr in (void) const;
-  CORBA_Policy_ptr &inout (void);
-  CORBA_Policy_ptr &out (void);
-  CORBA_Policy_ptr _retn (void);
-  CORBA_Policy_ptr ptr (void) const;
+    CORBA_InvalidPolicies (
+        const _tao_seq_UShort & _tao_indices
+      );
 
-  // Hooks used by template sequence and object manager classes
-  // for non-defined forward declared interfaces.
-  static CORBA_Policy_ptr duplicate (CORBA_Policy_ptr);
-  static void release (CORBA_Policy_ptr);
-  static CORBA_Policy_ptr nil (void);
-  static CORBA_Policy_ptr narrow (CORBA::Object *, CORBA::Environment &);
-  static CORBA::Object * upcast (void *);
+    // = TAO extension.
+    static CORBA::Exception *_alloc (void);
+    virtual CORBA::TypeCode_ptr _type (void) const;
+  }; // Exception CORBA::InvalidPolicies.
 
-private:
-  CORBA_Policy_ptr ptr_;
-  // Unimplemented - prevents widening assignment.
-  CORBA_Policy_var (const TAO_Base_var &rhs);
-  CORBA_Policy_var &operator= (const TAO_Base_var &rhs);
-};
+
+#endif /* end #if !defined */
+
+#if !defined (_CORBA_POLICY___VAR_CH_)
+#define _CORBA_POLICY___VAR_CH_
+
+  class TAO_Export CORBA_Policy_var : public TAO_Base_var
+  {
+  public:
+    CORBA_Policy_var (void); // default constructor
+    CORBA_Policy_var (CORBA_Policy_ptr p) : ptr_ (p) {}
+    CORBA_Policy_var (const CORBA_Policy_var &); // copy constructor
+    ~CORBA_Policy_var (void); // destructor
+
+    CORBA_Policy_var &operator= (CORBA_Policy_ptr);
+    CORBA_Policy_var &operator= (const CORBA_Policy_var &);
+    CORBA_Policy_ptr operator-> (void) const;
+
+    operator const CORBA_Policy_ptr &() const;
+    operator CORBA_Policy_ptr &();
+    // in, inout, out, _retn
+    CORBA_Policy_ptr in (void) const;
+    CORBA_Policy_ptr &inout (void);
+    CORBA_Policy_ptr &out (void);
+    CORBA_Policy_ptr _retn (void);
+    CORBA_Policy_ptr ptr (void) const;
+
+    // Hooks used by template sequence and object manager classes
+    // for non-defined forward declared interfaces.
+    static CORBA_Policy_ptr duplicate (CORBA_Policy_ptr);
+    static void release (CORBA_Policy_ptr);
+    static CORBA_Policy_ptr nil (void);
+    static CORBA_Policy_ptr narrow (CORBA::Object *, CORBA::Environment &);
+    static CORBA::Object * upcast (void *);
+
+  private:
+    CORBA_Policy_ptr ptr_;
+    // Unimplemented - prevents widening assignment.
+    CORBA_Policy_var (const TAO_Base_var &rhs);
+    CORBA_Policy_var &operator= (const TAO_Base_var &rhs);
+  };
 
 
 #endif /* end #if !defined */
@@ -300,22 +287,22 @@ private:
 #if !defined (_CORBA_POLICY___OUT_CH_)
 #define _CORBA_POLICY___OUT_CH_
 
-class TAO_Export CORBA_Policy_out
-{
-public:
-  CORBA_Policy_out (CORBA_Policy_ptr &);
-  CORBA_Policy_out (CORBA_Policy_var &);
-  CORBA_Policy_out (const CORBA_Policy_out &);
-  CORBA_Policy_out &operator= (const CORBA_Policy_out &);
-  CORBA_Policy_out &operator= (const CORBA_Policy_var &);
-  CORBA_Policy_out &operator= (CORBA_Policy_ptr);
-  operator CORBA_Policy_ptr &();
-  CORBA_Policy_ptr &ptr (void);
-  CORBA_Policy_ptr operator-> (void);
-  
-private:
-  CORBA_Policy_ptr &ptr_;
-};
+  class TAO_Export CORBA_Policy_out
+  {
+  public:
+    CORBA_Policy_out (CORBA_Policy_ptr &);
+    CORBA_Policy_out (CORBA_Policy_var &);
+    CORBA_Policy_out (const CORBA_Policy_out &);
+    CORBA_Policy_out &operator= (const CORBA_Policy_out &);
+    CORBA_Policy_out &operator= (const CORBA_Policy_var &);
+    CORBA_Policy_out &operator= (CORBA_Policy_ptr);
+    operator CORBA_Policy_ptr &();
+    CORBA_Policy_ptr &ptr (void);
+    CORBA_Policy_ptr operator-> (void);
+
+  private:
+    CORBA_Policy_ptr &ptr_;
+  };
 
 
 #endif /* end #if !defined */
@@ -324,102 +311,103 @@ private:
 #if !defined (_CORBA_POLICY_CH_)
 #define _CORBA_POLICY_CH_
 
-// Forward Classes Declaration
-class _TAO_CORBA_Policy_Proxy_Impl;
-class _TAO_CORBA_Policy_Remote_Proxy_Impl;
-class _TAO_CORBA_Policy_Proxy_Broker;
-class _TAO_CORBA_Policy_Remote_Proxy_Broker;
+  // Forward Classes Declaration
+  class CORBA_TAO_Policy_Proxy_Impl;
+  class CORBA_TAO_Policy_Remote_Proxy_Impl;
+  class CORBA_TAO_Policy_Proxy_Broker;
+  class CORBA_TAO_Policy_Remote_Proxy_Broker;
 
-class TAO_Export CORBA_Policy : public virtual CORBA_Object
-                              , public virtual TAO_Encodable
-{
-public:
-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
-  typedef CORBA_Policy_ptr _ptr_type;
-  typedef CORBA_Policy_var _var_type;
-#endif /* ! __GNUC__ || g++ >= 2.8 */
+class TAO_Export CORBA_Policy
+  : public virtual CORBA::Object,
+    public virtual TAO_Encodable
+  {
+  public:
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef CORBA_Policy_ptr _ptr_type;
+    typedef CORBA_Policy_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    // the static operations
+    static CORBA_Policy_ptr _duplicate (CORBA_Policy_ptr obj);
+    static CORBA_Policy_ptr _narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static CORBA_Policy_ptr _unchecked_narrow (
+        CORBA::Object_ptr obj,
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    static CORBA_Policy_ptr _nil (void)
+      {
+        return (CORBA_Policy_ptr)0;
+      }
 
-  // the static operations
-  static CORBA_Policy_ptr _duplicate (CORBA_Policy_ptr obj);
-  static CORBA_Policy_ptr _narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV = 
-        TAO_default_environment ()
-    );
-  static CORBA_Policy_ptr _unchecked_narrow (
-      CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV = 
-        TAO_default_environment ()
-    );
-  static CORBA_Policy_ptr _nil (void)
-    {
-      return (CORBA_Policy_ptr)0;
-    }
+    static void _tao_any_destructor (void*);
 
-  static void _tao_any_destructor (void*);
+    virtual CORBA::PolicyType policy_type (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
 
-  virtual CORBA::PolicyType policy_type (
-      CORBA::Environment &ACE_TRY_ENV = 
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
+    virtual CORBA::Policy_ptr copy (
+        CORBA::Environment &ACE_TRY_ENV =
+          TAO_default_environment ()
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ));
 
-  virtual CORBA_Policy_ptr copy (
-      CORBA::Environment &ACE_TRY_ENV = 
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
+    virtual void destroy (
+        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 &ACE_TRY_ENV =
+          TAO_default_environment ()
+      );
+    virtual void *_tao_QueryInterface (ptr_arith_t type);
 
-  virtual void destroy (
-      CORBA::Environment &ACE_TRY_ENV = 
-        TAO_default_environment ()
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    ));
+    virtual const char* _interface_repository_id (void) const;
 
-  virtual CORBA::Boolean _is_a (
-      const CORBA::Char *type_id, 
-      CORBA::Environment &ACE_TRY_ENV = 
-        TAO_default_environment ()
-    );
-  virtual void *_tao_QueryInterface (ptr_arith_t type);
-  
-  virtual const char* _interface_repository_id (void) const;
+    virtual CORBA::Boolean _tao_encode (TAO_OutputCDR &);
+    virtual CORBA::Boolean _tao_decode (TAO_InputCDR &);
 
-  virtual CORBA::Boolean _tao_encode (TAO_OutputCDR &);
-  virtual CORBA::Boolean _tao_decode (TAO_InputCDR &);
+  private:
+    CORBA_TAO_Policy_Proxy_Broker *the_CORBA_TAO_Policy_Proxy_Broker_;
 
-private:
-  _TAO_CORBA_Policy_Proxy_Broker *the_TAO_CORBA_Policy_Proxy_Broker_;
-  
-protected:
-  CORBA_Policy (int collocated = 0);
-  
   protected:
-    // This methods travese the inheritance tree and set the
-    // parents piece of the given class in the right mode
-    virtual void CORBA_Policy_setup_collocation (int collocated);
-    
-    CORBA_Policy (
-      TAO_Stub *objref, 
-      CORBA::Boolean _tao_collocated = 0,
-      TAO_Abstract_ServantBase *servant = 0
-      );
-    
-    friend class _TAO_CORBA_Policy_Remote_Proxy_Impl;
-    friend class _TAO_CORBA_Policy_ThruPOA_Proxy_Impl;
-    friend class _TAO_CORBA_Policy_Direct_Proxy_Impl;
-  
-  virtual ~CORBA_Policy (void);
-private:
-  CORBA_Policy (const CORBA_Policy &);
-  void operator= (const CORBA_Policy &);
-};
+    CORBA_Policy (int collocated = 0);
+
+    protected:
+      // This methods travese the inheritance tree and set the
+      // parents piece of the given class in the right mode
+      virtual void CORBA_Policy_setup_collocation (int collocated);
+
+      CORBA_Policy (
+        TAO_Stub *objref,
+        CORBA::Boolean _tao_collocated = 0,
+        TAO_Abstract_ServantBase *servant = 0
+        );
+
+      friend class CORBA_TAO_Policy_Remote_Proxy_Impl;
+      friend class CORBA_TAO_Policy_ThruPOA_Proxy_Impl;
+      friend class CORBA_TAO_Policy_Direct_Proxy_Impl;
+
+    virtual ~CORBA_Policy (void);
+  private:
+    CORBA_Policy (const CORBA_Policy &);
+    void operator= (const CORBA_Policy &);
+  };
 
 
 // The Proxy Implementations are used by each interface to
@@ -427,79 +415,79 @@ private:
 // an invocation logics.
 
 
-///////////////////////////////////////////////////////////////////////
-//                    Base  Impl. Declaration
-//
-
-class TAO_Export _TAO_CORBA_Policy_Proxy_Impl : public virtual TAO_Object_Proxy_Impl
-{
-public:
-  virtual ~_TAO_CORBA_Policy_Proxy_Impl (void) { }
-  
-    virtual CORBA::PolicyType policy_type (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
-
-  virtual CORBA_Policy_ptr copy (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
+  ///////////////////////////////////////////////////////////////////////
+  //                    Base  Impl. Declaration
+  //
 
-  virtual void destroy (
-      CORBA_Object *_collocated_tao_target_,
-      CORBA::Environment &ACE_TRY_ENV
-    )
-    ACE_THROW_SPEC ((
-      CORBA::SystemException
-    )) = 0;
+  class TAO_Export CORBA_TAO_Policy_Proxy_Impl : public virtual TAO_Object_Proxy_Impl
+  {
+  public:
+    virtual ~CORBA_TAO_Policy_Proxy_Impl (void) { }
+
+        virtual CORBA::PolicyType policy_type (
+        CORBA::Object_ptr _collocated_tao_target_,
+        CORBA::Environment &ACE_TRY_ENV
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual CORBA::Policy_ptr copy (
+        CORBA::Object_ptr _collocated_tao_target_,
+        CORBA::Environment &ACE_TRY_ENV
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
+
+    virtual void destroy (
+        CORBA::Object_ptr _collocated_tao_target_,
+        CORBA::Environment &ACE_TRY_ENV
+      )
+      ACE_THROW_SPEC ((
+        CORBA::SystemException
+      )) = 0;
 
 protected:
-  _TAO_CORBA_Policy_Proxy_Impl (void);
+    CORBA_TAO_Policy_Proxy_Impl (void);
 
-};
-//
-//                Base  Proxy Impl. Declaration
-///////////////////////////////////////////////////////////////////////
+  };
+  //
+  //                Base  Proxy Impl. Declaration
+  ///////////////////////////////////////////////////////////////////////
 
 
 ///////////////////////////////////////////////////////////////////////
 //                    Remote  Impl. Declaration
 //
 
-class TAO_Export _TAO_CORBA_Policy_Remote_Proxy_Impl : 
-  public virtual _TAO_CORBA_Policy_Proxy_Impl,
+class TAO_Export CORBA_TAO_Policy_Remote_Proxy_Impl :
+  public virtual CORBA_TAO_Policy_Proxy_Impl,
   public virtual TAO_Remote_Object_Proxy_Impl
 {
 public:
-  _TAO_CORBA_Policy_Remote_Proxy_Impl (void);
-  
-  virtual ~_TAO_CORBA_Policy_Remote_Proxy_Impl (void) { }
-  
-    virtual CORBA::PolicyType policy_type (
-      CORBA_Object *_collocated_tao_target_,
+  CORBA_TAO_Policy_Remote_Proxy_Impl (void);
+
+  virtual ~CORBA_TAO_Policy_Remote_Proxy_Impl (void) { }
+
+  virtual CORBA::PolicyType policy_type (
+      CORBA::Object_ptr _collocated_tao_target_,
       CORBA::Environment &ACE_TRY_ENV
     )
     ACE_THROW_SPEC ((
       CORBA::SystemException
     ));
 
-  virtual CORBA_Policy_ptr copy (
-      CORBA_Object *_collocated_tao_target_,
+virtual CORBA::Policy_ptr copy (
+      CORBA::Object_ptr _collocated_tao_target_,
       CORBA::Environment &ACE_TRY_ENV
     )
     ACE_THROW_SPEC ((
       CORBA::SystemException
     ));
 
-  virtual void destroy (
-      CORBA_Object *_collocated_tao_target_,
+virtual void destroy (
+      CORBA::Object_ptr _collocated_tao_target_,
       CORBA::Environment &ACE_TRY_ENV
     )
     ACE_THROW_SPEC ((
@@ -514,74 +502,72 @@ public:
 
 
 // The Proxy Brokers are used by each interface to get
-// the right proxy for performing a call. In the new 
+// the right proxy for performing a call. In the new
 // collocation scheme, the proxy to be used can vary on
-// a call by call basis. 
+// a call by call basis.
 
 
 
 ///////////////////////////////////////////////////////////////////////
-//                 Base Proxy Broker Declaration 
+//                 Base Proxy Broker Declaration
 //
 
-class TAO_Export _TAO_CORBA_Policy_Proxy_Broker
+class TAO_Export CORBA_TAO_Policy_Proxy_Broker
 {
 public:
-  virtual ~_TAO_CORBA_Policy_Proxy_Broker (void);
-  virtual _TAO_CORBA_Policy_Proxy_Impl &select_proxy (
+  virtual ~CORBA_TAO_Policy_Proxy_Broker (void);
+  virtual CORBA_TAO_Policy_Proxy_Impl &select_proxy (
     CORBA_Policy *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+    CORBA_Environment &ACE_TRY_ENV
   ) = 0;
 
 protected:
-  _TAO_CORBA_Policy_Proxy_Broker (void);
-  
+  CORBA_TAO_Policy_Proxy_Broker (void);
+
 };
 
 //
-//              End Base Proxy Broker Declaration 
+//              End Base Proxy Broker Declaration
 ///////////////////////////////////////////////////////////////////////
 
 
 ///////////////////////////////////////////////////////////////////////
-//                 Remote Proxy Broker Declaration 
+//                 Remote Proxy Broker Declaration
 //
 
-class TAO_Export _TAO_CORBA_Policy_Remote_Proxy_Broker : public virtual _TAO_CORBA_Policy_Proxy_Broker
+class TAO_Export CORBA_TAO_Policy_Remote_Proxy_Broker : public virtual CORBA_TAO_Policy_Proxy_Broker
 {
-public: 
-  _TAO_CORBA_Policy_Remote_Proxy_Broker (void);
-  
-  virtual ~_TAO_CORBA_Policy_Remote_Proxy_Broker (void);
-  
-  virtual _TAO_CORBA_Policy_Proxy_Impl &select_proxy (
+public:
+  CORBA_TAO_Policy_Remote_Proxy_Broker (void);
+
+  virtual ~CORBA_TAO_Policy_Remote_Proxy_Broker (void);
+
+  virtual CORBA_TAO_Policy_Proxy_Impl &select_proxy (
     CORBA_Policy *object,
-    CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
+    CORBA_Environment &ACE_TRY_ENV
   );
 
 private:
-  _TAO_CORBA_Policy_Remote_Proxy_Impl remote_proxy_impl_;
+  CORBA_TAO_Policy_Remote_Proxy_Impl remote_proxy_impl_;
 // This member function is used to get an handle to the unique instance
 // of the Remote Proxy Broker that is available for a given
 // interface.
 
 public:
-  static _TAO_CORBA_Policy_Remote_Proxy_Broker *the_TAO_CORBA_Policy_Remote_Proxy_Broker (void);
+  static CORBA_TAO_Policy_Remote_Proxy_Broker *the_CORBA_TAO_Policy_Remote_Proxy_Broker (void);
 };
 
 
 //
-//              End Remote Proxy Broker Declaration 
+//              End Remote Proxy Broker Declaration
 ///////////////////////////////////////////////////////////////////////
 
 
 #endif /* end #if !defined */
 
-extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_Policy;
-
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
+
 #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CH_)
 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CH_
 
@@ -589,7 +575,7 @@ extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_Policy;
   {
   public:
     // = Initialization and termination methods.
-    
+
     _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (void);
     _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (CORBA::ULong maximum);
     _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (CORBA::ULong maximum,
@@ -599,7 +585,7 @@ extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_Policy;
     _TAO_Unbounded_Object_Sequence_CORBA_PolicyList(const _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &rhs);
     virtual ~_TAO_Unbounded_Object_Sequence_CORBA_PolicyList (void);
     _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &operator= (const _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &rhs);
-    TAO_Object_Manager<CORBA_Policy,CORBA_Policy_var> operator[] (CORBA::ULong index) const;
+    TAO_Object_Manager<CORBA::Policy,CORBA::Policy_var> operator[] (CORBA::ULong index) const;
     static CORBA_Policy **allocbuf (CORBA::ULong nelems);
     static void freebuf (CORBA_Policy **buffer);
     // The Base_Sequence functions, please see tao/Sequence.h
@@ -611,42 +597,39 @@ extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_Policy;
     virtual void _downcast (
         void* target,
         CORBA_Object *src,
-        CORBA_Environment &ACE_TRY_ENV = 
+        CORBA_Environment &ACE_TRY_ENV =
           TAO_default_environment ()
       );
     virtual CORBA_Object* _upcast (void *src) const;
-    
+
   };
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 
 #if !defined (_CORBA_POLICYLIST_CH_)
 #define _CORBA_POLICYLIST_CH_
 
-class CORBA_PolicyList;
-class CORBA_PolicyList_var;
-
 // *************************************************************
-// CORBA_PolicyList
+// PolicyList
 // *************************************************************
 
-class TAO_Export CORBA_PolicyList : public 
+class TAO_Export CORBA_PolicyList : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Object_Sequence_CORBA_PolicyList
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_Policy,CORBA_Policy_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  TAO_Unbounded_Object_Sequence<Policy,Policy_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 {
 public:
   CORBA_PolicyList (void); // default ctor
   CORBA_PolicyList (CORBA::ULong max); // uses max size
   CORBA_PolicyList (
-    CORBA::ULong max, 
-    CORBA::ULong length, 
-    CORBA_Policy_ptr *buffer, 
+    CORBA::ULong max,
+    CORBA::ULong length,
+    CORBA_Policy_ptr *buffer,
     CORBA::Boolean release = 0
   );
   CORBA_PolicyList (const CORBA_PolicyList &); // copy ctor
@@ -666,7 +649,7 @@ public:
 #define _CORBA_POLICYLIST___VAR_CH_
 
 // *************************************************************
-// class CORBA_PolicyList_var
+// class CORBA::PolicyList_var
 // *************************************************************
 
 class TAO_Export CORBA_PolicyList_var
@@ -676,20 +659,20 @@ public:
   CORBA_PolicyList_var (CORBA_PolicyList *);
   CORBA_PolicyList_var (const CORBA_PolicyList_var &); // copy constructor
   ~CORBA_PolicyList_var (void); // destructor
-  
+
   CORBA_PolicyList_var &operator= (CORBA_PolicyList *);
   CORBA_PolicyList_var &operator= (const CORBA_PolicyList_var &);
   CORBA_PolicyList *operator-> (void);
   const CORBA_PolicyList *operator-> (void) const;
-  
+
   operator const CORBA_PolicyList &() const;
   operator CORBA_PolicyList &();
   operator CORBA_PolicyList &() const;
   operator CORBA_PolicyList *&(); // variable-size base types only
-  
+
   TAO_Object_Manager<CORBA_Policy, CORBA_Policy_var> operator[] (CORBA::ULong index);
-  
-  // in, inout, out, _retn 
+
+  // in, inout, out, _retn
   const CORBA_PolicyList &in (void) const;
   CORBA_PolicyList &inout (void);
   CORBA_PolicyList *&out (void);
@@ -719,7 +702,7 @@ public:
   CORBA_PolicyList *&ptr (void);
   CORBA_PolicyList *operator-> (void);
   TAO_Object_Manager<CORBA_Policy, CORBA_Policy_var> operator[] (CORBA::ULong index);
-  
+
 private:
   CORBA_PolicyList *&ptr_;
   // assignment from T_var not allowed
@@ -729,11 +712,9 @@ private:
 
 #endif /* end #if !defined */
 
-extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_PolicyList;
-
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
+
 #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CH_)
 #define __TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CH_
 
@@ -741,9 +722,9 @@ extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_PolicyList;
   {
   public:
     // = Initialization and termination methods.
-    
+
     _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (void); // Default constructor.
-    _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (CORBA::ULong maximum);
     _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (CORBA::ULong maximum,
       CORBA::ULong length,
       CORBA::ULong *data,
@@ -760,7 +741,7 @@ extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_PolicyList;
     virtual void _allocate_buffer (CORBA::ULong length);
     virtual void _deallocate_buffer (void);
     // Implement the TAO_Base_Sequence methods (see Sequence.h)
-    
+
     CORBA::ULong *get_buffer (CORBA::Boolean orphan = 0);
     const CORBA::ULong *get_buffer (void) const;
     void replace (CORBA::ULong max,
@@ -772,7 +753,7 @@ extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_PolicyList;
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 
 #if !defined (_CORBA_POLICYTYPESEQ_CH_)
 #define _CORBA_POLICYTYPESEQ_CH_
@@ -781,23 +762,23 @@ class CORBA_PolicyTypeSeq;
 class CORBA_PolicyTypeSeq_var;
 
 // *************************************************************
-// CORBA_PolicyTypeSeq
+// PolicyTypeSeq
 // *************************************************************
 
-class TAO_Export CORBA_PolicyTypeSeq : public 
+class TAO_Export CORBA_PolicyTypeSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_Sequence<CORBA::ULong>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
 {
 public:
   CORBA_PolicyTypeSeq (void); // default ctor
   CORBA_PolicyTypeSeq (CORBA::ULong max); // uses max size
   CORBA_PolicyTypeSeq (
-    CORBA::ULong max, 
-    CORBA::ULong length, 
-    CORBA::ULong *buffer, 
+    CORBA::ULong max,
+    CORBA::ULong length,
+    CORBA::ULong *buffer,
     CORBA::Boolean release = 0
   );
   CORBA_PolicyTypeSeq (const CORBA_PolicyTypeSeq &); // copy ctor
@@ -817,7 +798,7 @@ public:
 #define _CORBA_POLICYTYPESEQ___VAR_CH_
 
 // *************************************************************
-// class CORBA_PolicyTypeSeq_var
+// class CORBA::PolicyTypeSeq_var
 // *************************************************************
 
 class TAO_Export CORBA_PolicyTypeSeq_var
@@ -828,21 +809,21 @@ public:
   CORBA_PolicyTypeSeq_var (const CORBA_PolicyTypeSeq_var &); // copy constructor
   CORBA_PolicyTypeSeq_var (const CORBA_PolicyTypeSeq &); // fixed-size base types only
   ~CORBA_PolicyTypeSeq_var (void); // destructor
-  
+
   CORBA_PolicyTypeSeq_var &operator= (CORBA_PolicyTypeSeq *);
   CORBA_PolicyTypeSeq_var &operator= (const CORBA_PolicyTypeSeq_var &);
   CORBA_PolicyTypeSeq_var &operator= (const CORBA_PolicyTypeSeq &); // fixed-size base types only
   CORBA_PolicyTypeSeq *operator-> (void);
   const CORBA_PolicyTypeSeq *operator-> (void) const;
-  
+
   operator const CORBA_PolicyTypeSeq &() const;
   operator CORBA_PolicyTypeSeq &();
   operator CORBA_PolicyTypeSeq &() const;
-  
+
   CORBA::PolicyType & operator[] (CORBA::ULong index);
   const CORBA::PolicyType & operator[] (CORBA::ULong index) const;
-  
-  // in, inout, out, _retn 
+
+  // in, inout, out, _retn
   const CORBA_PolicyTypeSeq &in (void) const;
   CORBA_PolicyTypeSeq &inout (void);
   CORBA_PolicyTypeSeq *&out (void);
@@ -872,7 +853,7 @@ public:
   CORBA_PolicyTypeSeq *&ptr (void);
   CORBA_PolicyTypeSeq *operator-> (void);
   CORBA::PolicyType & operator[] (CORBA::ULong index);
-  
+
 private:
   CORBA_PolicyTypeSeq *&ptr_;
   // assignment from T_var not allowed
@@ -882,17 +863,6 @@ private:
 
 #endif /* end #if !defined */
 
-extern TAO_Export CORBA::TypeCode_ptr  _tc_CORBA_PolicyTypeSeq;
-
-
-#if !defined (_CORBA_POLICYMANAGER___PTR_CH_)
-#define _CORBA_POLICYMANAGER___PTR_CH_
-
-class CORBA_PolicyManager;
-typedef CORBA_PolicyManager *CORBA_PolicyManager_ptr;
-
-#endif /* end #if !defined */
-
 
 #if !defined (_CORBA_POLICYMANAGER___VAR_CH_)
 #define _CORBA_POLICYMANAGER___VAR_CH_
@@ -901,17 +871,17 @@ class TAO_Export CORBA_PolicyManager_var : public TAO_Base_var
 {
 public:
   CORBA_PolicyManager_var (void); // default constructor
-  CORBA_PolicyManager_var (CORBA_PolicyManager_ptr p) : ptr_ (p) {} 
+  CORBA_PolicyManager_var (CORBA_PolicyManager_ptr p) : ptr_ (p) {}
   CORBA_PolicyManager_var (const CORBA_PolicyManager_var &); // copy constructor
   ~CORBA_PolicyManager_var (void); // destructor
-  
+
   CORBA_PolicyManager_var &operator= (CORBA_PolicyManager_ptr);
   CORBA_PolicyManager_var &operator= (const CORBA_PolicyManager_var &);
   CORBA_PolicyManager_ptr operator-> (void) const;
-  
+
   operator const CORBA_PolicyManager_ptr &() const;
   operator CORBA_PolicyManager_ptr &();
-  // in, inout, out, _retn 
+  // in, inout, out, _retn
   CORBA_PolicyManager_ptr in (void) const;
   CORBA_PolicyManager_ptr &inout (void);
   CORBA_PolicyManager_ptr &out (void);
@@ -952,7 +922,7 @@ public:
   operator CORBA_PolicyManager_ptr &();
   CORBA_PolicyManager_ptr &ptr (void);
   CORBA_PolicyManager_ptr operator-> (void);
-  
+
 private:
   CORBA_PolicyManager_ptr &ptr_;
 };
@@ -964,7 +934,7 @@ private:
 #if !defined (_CORBA_POLICYMANAGER_CH_)
 #define _CORBA_POLICYMANAGER_CH_
 
-class TAO_Export CORBA_PolicyManager : public virtual CORBA_Object
+class TAO_Export CORBA_PolicyManager : public virtual CORBA::Object
 {
 public:
 #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
@@ -976,12 +946,12 @@ public:
   static CORBA_PolicyManager_ptr _duplicate (CORBA_PolicyManager_ptr obj);
   static CORBA_PolicyManager_ptr _narrow (
       CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV = 
+      CORBA::Environment &ACE_TRY_ENV =
         TAO_default_environment ()
     );
   static CORBA_PolicyManager_ptr _unchecked_narrow (
       CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV = 
+      CORBA::Environment &ACE_TRY_ENV =
         TAO_default_environment ()
     );
   static CORBA_PolicyManager_ptr _nil (void)
@@ -989,9 +959,9 @@ public:
       return (CORBA_PolicyManager_ptr)0;
     }
 
-  virtual CORBA_PolicyList * get_policy_overrides (
-      const CORBA_PolicyTypeSeq & ts,
-      CORBA::Environment &ACE_TRY_ENV = 
+  virtual CORBA::PolicyList * get_policy_overrides (
+      const CORBA::PolicyTypeSeq & ts,
+      CORBA::Environment &ACE_TRY_ENV =
         TAO_default_environment ()
     )
     ACE_THROW_SPEC ((
@@ -999,23 +969,23 @@ public:
     )) = 0;
 
   virtual void set_policy_overrides (
-      const CORBA_PolicyList & policies,
+      const CORBA::PolicyList & policies,
       CORBA::SetOverrideType set_add,
-      CORBA::Environment &ACE_TRY_ENV = 
+      CORBA::Environment &ACE_TRY_ENV =
         TAO_default_environment ()
     )
     ACE_THROW_SPEC ((
       CORBA::SystemException,
-      CORBA_InvalidPolicies
+      CORBA::InvalidPolicies
     )) = 0;
 
   virtual void *_tao_QueryInterface (ptr_arith_t type);
-  
+
   virtual const char* _interface_repository_id (void) const;
 
 protected:
   CORBA_PolicyManager ();
-  
+
   virtual ~CORBA_PolicyManager (void);
 private:
   CORBA_PolicyManager (const CORBA_PolicyManager &);
@@ -1026,15 +996,6 @@ private:
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_POLICYCURRENT___PTR_CH_)
-#define _CORBA_POLICYCURRENT___PTR_CH_
-
-class CORBA_PolicyCurrent;
-typedef CORBA_PolicyCurrent *CORBA_PolicyCurrent_ptr;
-
-#endif /* end #if !defined */
-
-
 #if !defined (_CORBA_POLICYCURRENT___VAR_CH_)
 #define _CORBA_POLICYCURRENT___VAR_CH_
 
@@ -1042,17 +1003,17 @@ class TAO_Export CORBA_PolicyCurrent_var : public TAO_Base_var
 {
 public:
   CORBA_PolicyCurrent_var (void); // default constructor
-  CORBA_PolicyCurrent_var (CORBA_PolicyCurrent_ptr p) : ptr_ (p) {} 
+  CORBA_PolicyCurrent_var (CORBA_PolicyCurrent_ptr p) : ptr_ (p) {}
   CORBA_PolicyCurrent_var (const CORBA_PolicyCurrent_var &); // copy constructor
   ~CORBA_PolicyCurrent_var (void); // destructor
-  
+
   CORBA_PolicyCurrent_var &operator= (CORBA_PolicyCurrent_ptr);
   CORBA_PolicyCurrent_var &operator= (const CORBA_PolicyCurrent_var &);
   CORBA_PolicyCurrent_ptr operator-> (void) const;
-  
+
   operator const CORBA_PolicyCurrent_ptr &() const;
   operator CORBA_PolicyCurrent_ptr &();
-  // in, inout, out, _retn 
+  // in, inout, out, _retn
   CORBA_PolicyCurrent_ptr in (void) const;
   CORBA_PolicyCurrent_ptr &inout (void);
   CORBA_PolicyCurrent_ptr &out (void);
@@ -1093,7 +1054,7 @@ public:
   operator CORBA_PolicyCurrent_ptr &();
   CORBA_PolicyCurrent_ptr &ptr (void);
   CORBA_PolicyCurrent_ptr operator-> (void);
-  
+
 private:
   CORBA_PolicyCurrent_ptr &ptr_;
 };
@@ -1117,12 +1078,12 @@ public:
   static CORBA_PolicyCurrent_ptr _duplicate (CORBA_PolicyCurrent_ptr obj);
   static CORBA_PolicyCurrent_ptr _narrow (
       CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV = 
+      CORBA::Environment &ACE_TRY_ENV =
         TAO_default_environment ()
     );
   static CORBA_PolicyCurrent_ptr _unchecked_narrow (
       CORBA::Object_ptr obj,
-      CORBA::Environment &ACE_TRY_ENV = 
+      CORBA::Environment &ACE_TRY_ENV =
         TAO_default_environment ()
     );
   static CORBA_PolicyCurrent_ptr _nil (void)
@@ -1131,12 +1092,12 @@ public:
     }
 
   virtual void *_tao_QueryInterface (ptr_arith_t type);
-  
+
   virtual const char* _interface_repository_id (void) const;
 
 protected:
   CORBA_PolicyCurrent ();
-  
+
   virtual ~CORBA_PolicyCurrent (void);
 private:
   CORBA_PolicyCurrent (const CORBA_PolicyCurrent &);
@@ -1146,74 +1107,73 @@ private:
 
 #endif /* end #if !defined */
 
+
 // Proxy Broker Factory function pointer declarations.
 
 extern TAO_Export
-_TAO_CORBA_Policy_Proxy_Broker *
-(*_TAO_CORBA_Policy_Proxy_Broker_Factory_function_pointer) (
+CORBA_TAO_Policy_Proxy_Broker *
+(*CORBA_CORBA_TAO_Policy_Proxy_Broker_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
 
+TAO_Export void operator<<= (CORBA::Any &, const CORBA::PolicyError &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyError*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyError *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::PolicyError *&);
+TAO_Export void operator<<= (CORBA::Any &, const CORBA::InvalidPolicies &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CORBA::InvalidPolicies*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::InvalidPolicies *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::InvalidPolicies *&);
+// Any operators for interface CORBA::Policy
+TAO_Export void operator<<= (CORBA::Any &, CORBA::Policy_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Policy *&);
+TAO_Export void operator<<= (CORBA::Any &, const CORBA::PolicyList &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyList*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyList *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::PolicyList *&);
+TAO_Export void operator<<= (CORBA::Any &, const CORBA::PolicyTypeSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyTypeSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyTypeSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::PolicyTypeSeq *&);
 TAO_Export void operator<<= (CORBA::Any &, CORBA::SetOverrideType);
 TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::SetOverrideType &);
-TAO_Export void operator<<= (CORBA::Any &, const CORBA_PolicyError &); // copying version
-TAO_Export void operator<<= (CORBA::Any &, CORBA_PolicyError*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PolicyError *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_PolicyError *&);
-TAO_Export void operator<<= (CORBA::Any &, const CORBA_InvalidPolicies &); // copying version
-TAO_Export void operator<<= (CORBA::Any &, CORBA_InvalidPolicies*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_InvalidPolicies *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_InvalidPolicies *&);
-// Any operators for interface CORBA_Policy
-TAO_Export void operator<<= (CORBA::Any &, CORBA_Policy_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_Policy *&);
-TAO_Export void operator<<= (CORBA::Any &, const CORBA_PolicyList &); // copying version
-TAO_Export void operator<<= (CORBA::Any &, CORBA_PolicyList*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PolicyList *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_PolicyList *&);
-TAO_Export void operator<<= (CORBA::Any &, const CORBA_PolicyTypeSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &, CORBA_PolicyTypeSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_PolicyTypeSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_PolicyTypeSeq *&);
 
 #ifndef __ACE_INLINE__
 
-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::SetOverrideType &); // 
-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::SetOverrideType &);
-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_PolicyError &);
-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_PolicyError &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PolicyError &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PolicyError &);
 
-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_InvalidPolicies &);
-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_InvalidPolicies &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::InvalidPolicies &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::InvalidPolicies &);
 
 #if !defined _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_H_
 #define _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_H_
 
 TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA_InvalidPolicies::_tao_seq_UShort &
+    const CORBA::InvalidPolicies::_tao_seq_UShort &
   );
 TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA_InvalidPolicies::_tao_seq_UShort &
+    CORBA::InvalidPolicies::_tao_seq_UShort &
   );
 
 #endif /* _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_H_ */
 
 
-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_Policy_ptr );
-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_Policy_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Policy_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Policy_ptr &);
 
 #if !defined _TAO_CDR_OP_CORBA_PolicyList_H_
 #define _TAO_CDR_OP_CORBA_PolicyList_H_
 
 TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA_PolicyList &
+    const CORBA::PolicyList &
   );
 TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA_PolicyList &
+    CORBA::PolicyList &
   );
 
 #endif /* _TAO_CDR_OP_CORBA_PolicyList_H_ */
@@ -1224,15 +1184,17 @@ TAO_Export CORBA::Boolean operator>> (
 
 TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA_PolicyTypeSeq &
+    const CORBA::PolicyTypeSeq &
   );
 TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA_PolicyTypeSeq &
+    CORBA::PolicyTypeSeq &
   );
 
 #endif /* _TAO_CDR_OP_CORBA_PolicyTypeSeq_H_ */
 
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::SetOverrideType &); //
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::SetOverrideType &);
 
 #endif /* __ACE_INLINE__ */