diff options
Diffstat (limited to 'TAO/tao/diffs/PolicyC.h.diff')
| -rw-r--r-- | TAO/tao/diffs/PolicyC.h.diff | 1733 |
1 files changed, 1630 insertions, 103 deletions
diff --git a/TAO/tao/diffs/PolicyC.h.diff b/TAO/tao/diffs/PolicyC.h.diff index 76c3cc2f2fb..dc47b2d6d01 100644 --- a/TAO/tao/diffs/PolicyC.h.diff +++ b/TAO/tao/diffs/PolicyC.h.diff @@ -1,199 +1,1726 @@ ---- PolicyC.h Sat Jun 24 01:58:09 2000 -+++ PolicyC.h.mod Sat Jun 24 02:09:13 2000 -@@ -11,7 +11,7 @@ - #define _TAO_IDL_POLICYC_H_ +--- orig/PolicyC.h Thu Jun 15 14:01:44 2000 ++++ PolicyC.h Fri Jun 9 13:00:52 2000 +@@ -1,1290 +1,638 @@ +-/* -*- C++ -*- $Id$ */ ++/* -*- 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. ++// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* ++// TAO ORB and the TAO IDL Compiler have been developed by Washington ++// University Computer Science's Distributed Object Computing Group. + // +-// Information about TAO is available at: ++// Information on TAO is available at + // http://www.cs.wustl.edu/~schmidt/TAO.html + +-#ifndef _TAO_IDL_ORIG_POLICYC_H_ +-#define _TAO_IDL_ORIG_POLICYC_H_ +- ++#ifndef TAO_IDL_POLICYC_H ++#define TAO_IDL_POLICYC_H #include "ace/pre.h" -#include "tao/corba.h" + +-#if defined (ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION) +-#include "ace/streams.h" +-#endif /* ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION */ +#include "tao/CurrentC.h" - #if defined (ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION) - #include "ace/streams.h" -@@ -21,7 +21,12 @@ + #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ --#include "tao/corbafwd.h" -+#include "tao/Encodable.h" -+#include "tao/Exception.h" -+#include "tao/Sequence.h" +-#include "corbafwd.h" +#include "tao/CDR.h" -+#include "tao/Typecode.h" +#include "tao/Environment.h" ++#include "tao/Exception.h" ++#include "tao/Sequence.h" - #if defined (TAO_EXPORT_MACRO) - #undef TAO_EXPORT_MACRO -@@ -42,30 +47,6 @@ - #pragma warning(disable:4250) - #endif /* _MSC_VER */ +-#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 */ ++#include "tao/Encodable.h" -TAO_NAMESPACE CORBA --{ ++class TAO_Export CORBA_PolicyError : public CORBA::UserException + { - typedef CORBA::Short PolicyErrorCode; - typedef CORBA::Short_out PolicyErrorCode_out; - TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PolicyErrorCode; - -- typedef CORBA::ULong PolicyType; -- typedef CORBA::ULong_out PolicyType_out; -- TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PolicyType; +- TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short BAD_POLICY; +- +- TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short UNSUPPORTED_POLICY; - -- enum SetOverrideType +- TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short BAD_POLICY_TYPE; +- +- TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short BAD_POLICY_VALUE; +- +- TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short UNSUPPORTED_POLICY_VALUE; +- ++public: ++ CORBA::PolicyErrorCode reason; + +-#if !defined (_CORBA_POLICYERROR_CH_) +-#define _CORBA_POLICYERROR_CH_ ++ CORBA_PolicyError (void); // default ctor ++ CORBA_PolicyError (const CORBA::PolicyError &); // copy ctor ++ ~CORBA_PolicyError (void); // dtor ++ CORBA_PolicyError &operator= (const CORBA_PolicyError &); + +- class TAO_Export PolicyError : public CORBA::UserException - { -- SET_OVERRIDE, -- ADD_OVERRIDE, -- SetOverrideType_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF -- }; -- typedef SetOverrideType &SetOverrideType_out; -- TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_SetOverrideType; +- public: ++ virtual void _raise (void); + +- ACE_NESTED_CLASS (CORBA, PolicyErrorCode) reason; ++ virtual void _tao_encode (TAO_OutputCDR &cdr, ++ CORBA::Environment &) const; ++ virtual void _tao_decode (TAO_InputCDR &cdr, ++ CORBA::Environment &); + +- PolicyError (void); // default ctor +- PolicyError (const PolicyError &); // copy ctor +- ~PolicyError (void); ++ static CORBA_PolicyError *_downcast (CORBA::Exception *); + static void _tao_any_destructor (void*); +- PolicyError &operator= (const PolicyError &); - + +- virtual void _raise (void); - --} --TAO_NAMESPACE_CLOSE // module CORBA +- virtual void _tao_encode ( +- TAO_OutputCDR &, +- CORBA::Environment &) const; +- virtual void _tao_decode ( +- TAO_InputCDR &, +- CORBA::Environment &); +- +- static PolicyError *_downcast (CORBA::Exception *); +- +- PolicyError ( +- ACE_NESTED_CLASS (CORBA, PolicyErrorCode) _tao_reason +- ); ++ CORBA_PolicyError( ++ CORBA::PolicyErrorCode _tao_reason); + + // = TAO extension + static CORBA::Exception *_alloc (void); +- + }; // exception CORBA::PolicyError + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PolicyError; ++// **************************************************************** + ++class CORBA_InvalidPolicies; ++typedef CORBA_InvalidPolicies *CORBA_InvalidPolicies_ptr; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_INVALIDPOLICIES_CH_) +-#define _CORBA_INVALIDPOLICIES_CH_ +- +-class TAO_Export InvalidPolicies : public CORBA::UserException ++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 ++ class TAO_Export _tao_seq_UShort : public TAO_Unbounded_Sequence<CORBA::UShort> + { + 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); ++ _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); // dtor + }; ++ typedef _tao_seq_UShort *_tao_seq_UShort_ptr; ++ static CORBA::TypeCode_ptr _tc__tao_seq_UShort; + +-#endif /* end #if !defined */ +- +- +-#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 +-#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +- _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*); +- +-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef _tao_seq_UShort_var _var_type; +-#endif /* ! __GNUC__ || g++ >= 2.8 */ - +-}; +- +-#endif /* end #if !defined */ +- ++ _tao_seq_UShort indices; + +-#if !defined (_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT___VAR_CH_) +-#define _CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT___VAR_CH_ ++ CORBA_InvalidPolicies (void); // default ctor ++ CORBA_InvalidPolicies (const CORBA_InvalidPolicies &); // copy ctor ++ ~CORBA_InvalidPolicies (void); // dtor ++ CORBA_InvalidPolicies &operator= (const CORBA_InvalidPolicies &); + +-// ************************************************************* +-// class CORBA::InvalidPolicies::_tao_seq_UShort_var +-// ************************************************************* +- +-class TAO_Export _tao_seq_UShort_var +-{ +-public: +- _tao_seq_UShort_var (void); // default constructor +- _tao_seq_UShort_var (_tao_seq_UShort *); +- _tao_seq_UShort_var (const _tao_seq_UShort_var &); // copy constructor +- _tao_seq_UShort_var (const _tao_seq_UShort &); // fixed-size base types only +- ~_tao_seq_UShort_var (void); // destructor +- +- _tao_seq_UShort_var &operator= (_tao_seq_UShort *); +- _tao_seq_UShort_var &operator= (const _tao_seq_UShort_var &); +- _tao_seq_UShort_var &operator= (const _tao_seq_UShort &); // fixed-size base types only +- _tao_seq_UShort *operator-> (void); +- const _tao_seq_UShort *operator-> (void) const; +- +- operator const _tao_seq_UShort &() const; +- operator _tao_seq_UShort &(); +- operator _tao_seq_UShort &() const; +- +- CORBA::UShort &operator[] (CORBA::ULong index); +- // in, inout, out, _retn +- const _tao_seq_UShort &in (void) const; +- _tao_seq_UShort &inout (void); +- _tao_seq_UShort *&out (void); +- _tao_seq_UShort *_retn (void); +- _tao_seq_UShort *ptr (void) const; +- +-private: +- _tao_seq_UShort *ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT___OUT_CH_) +-#define _CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT___OUT_CH_ +- +-class TAO_Export _tao_seq_UShort_out +-{ +-public: +- _tao_seq_UShort_out (_tao_seq_UShort *&); +- _tao_seq_UShort_out (_tao_seq_UShort_var &); +- _tao_seq_UShort_out (const _tao_seq_UShort_out &); +- _tao_seq_UShort_out &operator= (const _tao_seq_UShort_out &); +- _tao_seq_UShort_out &operator= (_tao_seq_UShort *); +- operator _tao_seq_UShort *&(); +- _tao_seq_UShort *&ptr (void); +- _tao_seq_UShort *operator-> (void); +- CORBA::UShort &operator[] (CORBA::ULong index); +- +-private: +- _tao_seq_UShort *&ptr_; +- // assignment from T_var not allowed +- void operator= (const _tao_seq_UShort_var &); +-}; +- +- +-#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 */ ++ virtual void _raise (void); + +- _tao_seq_UShort indices; ++ virtual void _tao_encode (TAO_OutputCDR &cdr, ++ CORBA::Environment &) const; ++ virtual void _tao_decode (TAO_InputCDR &cdr, ++ CORBA::Environment &); + +- InvalidPolicies (void); // default ctor +- InvalidPolicies (const InvalidPolicies &); // copy ctor +- ~InvalidPolicies (void); ++ static CORBA_InvalidPolicies *_downcast (CORBA::Exception *); + static void _tao_any_destructor (void*); +- InvalidPolicies &operator= (const InvalidPolicies &); +- +- +- virtual void _raise (void); + +- virtual void _tao_encode ( +- TAO_OutputCDR &, +- CORBA::Environment &) const; +- virtual void _tao_decode ( +- TAO_InputCDR &, +- CORBA::Environment &); +- +- static InvalidPolicies *_downcast (CORBA::Exception *); +- +- InvalidPolicies ( +- const _tao_seq_UShort & _tao_indices +- ); ++ CORBA_InvalidPolicies( ++ const _tao_seq_UShort & _tao_indices); + + // = TAO extension + static CORBA::Exception *_alloc (void); - - #if !defined (_CORBA_POLICYERROR_CH_) - #define _CORBA_POLICYERROR_CH_ + }; // exception CORBA::InvalidPolicies -@@ -434,6 +415,14 @@ - +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InvalidPolicies; +- +- +-#endif /* end #if !defined */ +- +-typedef CORBA::ULong PolicyType; +-typedef CORBA::ULong_out PolicyType_out; +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PolicyType; +- ++// **************************************************************** + +-#if !defined (_CORBA_POLICY___PTR_CH_) +-#define _CORBA_POLICY___PTR_CH_ ++class CORBA_Policy; ++typedef CORBA_Policy *CORBA_Policy_ptr; + +-class Policy; +-typedef Policy *Policy_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_POLICY___VAR_CH_) +-#define _CORBA_POLICY___VAR_CH_ +- +-class TAO_Export Policy_var : public TAO_Base_var ++class TAO_Export CORBA_Policy_var : public TAO_Base_var + { + public: +- Policy_var (void); // default constructor +- Policy_var (Policy_ptr); +- Policy_var (const Policy_var &); // copy constructor +- ~Policy_var (void); // destructor +- +- Policy_var &operator= (Policy_ptr); +- Policy_var &operator= (const Policy_var &); +- Policy_ptr operator-> (void) const; +- +- operator const Policy_ptr &() const; +- operator Policy_ptr &(); +- // in, inout, out, _retn +- Policy_ptr in (void) const; +- Policy_ptr &inout (void); +- Policy_ptr &out (void); +- Policy_ptr _retn (void); +- Policy_ptr ptr (void) const; ++ CORBA_Policy_var (void); // default constructor ++ CORBA_Policy_var (CORBA_Policy_ptr); ++ 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; + + private: +- Policy_ptr ptr_; ++ CORBA_Policy_ptr ptr_; + // Unimplemented - prevents widening assignment. +- Policy_var (const TAO_Base_var &rhs); +- Policy_var &operator= (const TAO_Base_var &rhs); ++ 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___OUT_CH_) +-#define _CORBA_POLICY___OUT_CH_ +- +-class TAO_Export Policy_out ++class TAO_Export CORBA_Policy_out + { + public: +- Policy_out (Policy_ptr &); +- Policy_out (Policy_var &); +- Policy_out (const Policy_out &); +- Policy_out &operator= (const Policy_out &); +- Policy_out &operator= (const Policy_var &); +- Policy_out &operator= (Policy_ptr); +- operator Policy_ptr &(); +- Policy_ptr &ptr (void); +- Policy_ptr operator-> (void); +- ++ CORBA_Policy_out (CORBA_Policy_ptr &); ++ CORBA_Policy_out (CORBA_Policy_var &); ++ CORBA_Policy_out (CORBA_Policy_out &); ++ CORBA_Policy_out &operator= (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: +- Policy_ptr &ptr_; ++ CORBA_Policy_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_POLICY_CH_) +-#define _CORBA_POLICY_CH_ +- +-class TAO_Export Policy : public virtual CORBA_Object ++class TAO_Export CORBA_Policy : public virtual CORBA_Object, ++ public TAO_Encodable + { + public: +-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef Policy_ptr _ptr_type; +- typedef Policy_var _var_type; +-#endif /* ! __GNUC__ || g++ >= 2.8 */ ++#if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 ++ typedef CORBA_Policy_ptr _ptr_type; ++ typedef CORBA_Policy_var _var_type; ++#endif /* __GNUC__ */ + + // the static operations +- static Policy_ptr _duplicate (Policy_ptr obj); +- static Policy_ptr _narrow ( ++ static CORBA_Policy_ptr _duplicate (CORBA_Policy_ptr obj); ++ static CORBA_Policy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static Policy_ptr _unchecked_narrow ( +- CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- static Policy_ptr _nil (void) +- { +- return (Policy_ptr)0; +- } +- ++ static CORBA_Policy_ptr _nil (void); + static void _tao_any_destructor (void*); + ++#if !defined (TAO_HAS_LOCALITY_CONSTRAINT_POLICIES) + virtual CORBA::PolicyType policy_type ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual CORBA::Policy_ptr copy ( +- CORBA::Environment &ACE_TRY_ENV = ++ ); ++ 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 () ++ ); ++#else ++ virtual CORBA::PolicyType policy_type ( ++ CORBA_Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ) = 0; ++ virtual CORBA_Policy_ptr copy ( ++ CORBA_Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ) = 0; + virtual void destroy ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); ++ ) = 0; ++#endif /* !TAO_HAS_LOCALITY_CONSTRAINT_POLICIES */ + + virtual CORBA::Boolean _is_a ( +- const CORBA::Char *type_id, +- CORBA::Environment &ACE_TRY_ENV = ++ 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; ++ // The following methods are used for embedding client-exposed ++ // policies into an IOR. These methods are not part of the idl ++ // compiler generated code: they were added by hand. ++ + virtual CORBA::Boolean _tao_encode (TAO_OutputCDR &out_cdr); -+ // Encode the Policy into a CDR representation. Returns true ++ // Encode the Policy into a CDR representation. Returns true + // on success and false on failure. + + virtual CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr); -+ // Decode the Policy from a CDR representation. Returns true ++ // Decode the Policy from a CDR representation. Returns true + // on success and false on failure. + protected: - CORBA_Policy (void); - CORBA_Policy (TAO_Stub *objref, -@@ -886,118 +875,6 @@ - #endif /* end #if !defined */ - +- Policy (void); +- Policy (TAO_Stub *objref, +- TAO_ServantBase *_tao_servant = 0, +- CORBA::Boolean _tao_collocated = 0 +- ); +- virtual ~Policy (void); ++ CORBA_Policy (void); // default constructor ++ CORBA_Policy (TAO_Stub *objref, ++ TAO_ServantBase *_tao_servant = 0, ++ CORBA::Boolean _tao_collocated = 0 ++ ); ++ virtual ~CORBA_Policy (void); + private: +- Policy (const Policy &); +- void operator= (const Policy &); ++ CORBA_Policy (const CORBA_Policy &); ++ void operator= (const CORBA_Policy &); + }; --#if !defined (_CORBA_CURRENT___PTR_CH_) --#define _CORBA_CURRENT___PTR_CH_ - --class CORBA_Current; --typedef CORBA_Current *CORBA_Current_ptr; +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Policy; +- +- +-#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +- +-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CH_) +-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CH_ +- +- class _TAO_Unbounded_Object_Sequence_CORBA_PolicyList : public TAO_Unbounded_Base_Sequence +- { +- 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, +- CORBA::ULong length, +- Policy* *value, +- CORBA::Boolean release = 0); +- _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; +- static Policy **allocbuf (CORBA::ULong nelems); +- static void freebuf (Policy **buffer); +- // The Base_Sequence functions, please see tao/Sequence.h +- virtual void _allocate_buffer (CORBA::ULong length); +- virtual void _deallocate_buffer (void); +- Policy* *get_buffer (CORBA::Boolean orphan = 0); +- const Policy* *get_buffer (void) const; +- virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); +- virtual void _downcast ( +- void* target, +- CORBA_Object *src, +- CORBA_Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- virtual CORBA_Object* _upcast (void *src) const; +- +- }; - -#endif /* end #if !defined */ - - --#if !defined (_CORBA_CURRENT___VAR_CH_) --#define _CORBA_CURRENT___VAR_CH_ +-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ - --class TAO_Export CORBA_Current_var : public TAO_Base_var --{ --public: -- CORBA_Current_var (void); // default constructor -- CORBA_Current_var (CORBA_Current_ptr p) : ptr_ (p) {} -- CORBA_Current_var (const CORBA_Current_var &); // copy constructor -- ~CORBA_Current_var (void); // destructor +-#if !defined (_CORBA_POLICYLIST_CH_) +-#define _CORBA_POLICYLIST_CH_ +- +-class PolicyList; +-class PolicyList_var; +- + // ************************************************************* +-// PolicyList ++// CORBA_PolicyList + // ************************************************************* + +-class TAO_Export PolicyList : public +-#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +- _TAO_Unbounded_Object_Sequence_CORBA_PolicyList +-#else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<Policy,Policy_var> +-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ ++class TAO_Export CORBA_PolicyList : public TAO_Unbounded_Object_Sequence<CORBA_Policy,CORBA_Policy_var> + { + public: +- PolicyList (void); // default ctor +- PolicyList (CORBA::ULong max); // uses max size +- PolicyList ( +- CORBA::ULong max, +- CORBA::ULong length, +- Policy_ptr *buffer, +- CORBA::Boolean release=0 +- ); +- PolicyList (const PolicyList &); // copy ctor +- ~PolicyList (void); +- static void _tao_any_destructor (void*); ++#if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 ++ typedef CORBA_PolicyList_var _var_type; ++#endif /* __GNUC__ */ + +-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef PolicyList_var _var_type; +-#endif /* ! __GNUC__ || g++ >= 2.8 */ ++ 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::Boolean release=0 ++ ); ++ CORBA_PolicyList (const CORBA_PolicyList &); // copy ctor ++ ~CORBA_PolicyList (void); // dtor + ++ static void _tao_any_destructor (void*); + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_POLICYLIST___VAR_CH_) +-#define _CORBA_POLICYLIST___VAR_CH_ +- + // ************************************************************* + // class CORBA::PolicyList_var + // ************************************************************* + +-class TAO_Export PolicyList_var ++class TAO_Export CORBA_PolicyList_var + { + public: +- PolicyList_var (void); // default constructor +- PolicyList_var (PolicyList *); +- PolicyList_var (const PolicyList_var &); // copy constructor +- ~PolicyList_var (void); // destructor +- +- PolicyList_var &operator= (PolicyList *); +- PolicyList_var &operator= (const PolicyList_var &); +- PolicyList *operator-> (void); +- const PolicyList *operator-> (void) const; - -- CORBA_Current_var &operator= (CORBA_Current_ptr); -- CORBA_Current_var &operator= (const CORBA_Current_var &); -- CORBA_Current_ptr operator-> (void) const; +- operator const PolicyList &() const; +- operator PolicyList &(); +- operator PolicyList &() const; +- operator PolicyList *&(); // variable-size base types only - -- operator const CORBA_Current_ptr &() const; -- operator CORBA_Current_ptr &(); +- TAO_Object_Manager<Policy, Policy_var> operator[] (CORBA::ULong index); - // in, inout, out, _retn -- CORBA_Current_ptr in (void) const; -- CORBA_Current_ptr &inout (void); -- CORBA_Current_ptr &out (void); -- CORBA_Current_ptr _retn (void); -- CORBA_Current_ptr ptr (void) const; +- const PolicyList &in (void) const; +- PolicyList &inout (void); +- PolicyList *&out (void); +- PolicyList *_retn (void); +- PolicyList *ptr (void) const; - -private: -- CORBA_Current_ptr ptr_; -- // Unimplemented - prevents widening assignment. -- CORBA_Current_var (const TAO_Base_var &rhs); -- CORBA_Current_var &operator= (const TAO_Base_var &rhs); +- PolicyList *ptr_; -}; ++ CORBA_PolicyList_var (void); // default constructor ++ 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; + +-#endif /* end #if !defined */ ++ operator const CORBA_PolicyList &() const; ++ operator CORBA_PolicyList &(); ++ operator CORBA_PolicyList &() const; ++ TAO_Object_Manager <CORBA_Policy,CORBA_Policy_var > operator[] (CORBA::ULong index); ++ // in, inout, out, _retn ++ const CORBA_PolicyList &in (void) const; ++ CORBA_PolicyList &inout (void); ++ CORBA_PolicyList *&out (void); ++ CORBA_PolicyList *_retn (void); ++ CORBA_PolicyList *ptr (void) const; + ++private: ++ CORBA_PolicyList *ptr_; ++}; + +-#if !defined (_CORBA_POLICYLIST___OUT_CH_) +-#define _CORBA_POLICYLIST___OUT_CH_ - +-class TAO_Export PolicyList_out ++class TAO_Export CORBA_PolicyList_out + { + public: +- PolicyList_out (PolicyList *&); +- PolicyList_out (PolicyList_var &); +- PolicyList_out (const PolicyList_out &); +- PolicyList_out &operator= (const PolicyList_out &); +- PolicyList_out &operator= (PolicyList *); +- operator PolicyList *&(); +- PolicyList *&ptr (void); +- PolicyList *operator-> (void); +- TAO_Object_Manager<Policy, Policy_var> operator[] (CORBA::ULong index); +- ++ CORBA_PolicyList_out (CORBA_PolicyList *&); ++ CORBA_PolicyList_out (CORBA_PolicyList_var &); ++ CORBA_PolicyList_out (const CORBA_PolicyList_out &); ++ CORBA_PolicyList_out &operator= (CORBA_PolicyList_out &); ++ CORBA_PolicyList_out &operator= (CORBA_PolicyList *); ++ operator CORBA_PolicyList *&(); ++ CORBA_PolicyList *&ptr (void); ++ CORBA_PolicyList *operator-> (void); ++ TAO_Object_Manager <CORBA_Policy,CORBA_Policy_var> operator[] (CORBA::ULong index); ++ + private: +- PolicyList *&ptr_; ++ CORBA_PolicyList *&ptr_; + // assignment from T_var not allowed +- void operator= (const PolicyList_var &); ++ void operator= (const CORBA_PolicyList_var &); + }; + - -#endif /* end #if !defined */ - +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PolicyList; - --#if !defined (_CORBA_CURRENT___OUT_CH_) --#define _CORBA_CURRENT___OUT_CH_ - --class TAO_Export CORBA_Current_out +-#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +- +-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CH_) +-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CH_ +- +- class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq : public TAO_Unbounded_Base_Sequence +- { +- 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, +- CORBA::ULong length, +- CORBA::ULong *data, +- CORBA::Boolean release = 0); +- _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (const _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &rhs); +- _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &rhs); +- virtual ~_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (void); // Dtor. +- // = Accessors. +- CORBA::ULong &operator[] (CORBA::ULong i); +- const CORBA::ULong &operator[] (CORBA::ULong i) const; +- // = Static operations. +- static CORBA::ULong *allocbuf (CORBA::ULong size); +- static void freebuf (CORBA::ULong *buffer); +- 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, +- CORBA::ULong length, +- CORBA::ULong *data, +- CORBA::Boolean release); +- }; +- +-#endif /* end #if !defined */ +- +- +-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +- +-#if !defined (_CORBA_POLICYTYPESEQ_CH_) +-#define _CORBA_POLICYTYPESEQ_CH_ +- +-class PolicyTypeSeq; +-class PolicyTypeSeq_var; +- + // ************************************************************* + // PolicyTypeSeq + // ************************************************************* + +-class TAO_Export 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 */ ++class TAO_Export CORBA_PolicyTypeSeq : public TAO_Unbounded_Sequence<CORBA::ULong> + { + public: +- PolicyTypeSeq (void); // default ctor +- PolicyTypeSeq (CORBA::ULong max); // uses max size +- PolicyTypeSeq ( +- CORBA::ULong max, +- CORBA::ULong length, +- CORBA::ULong *buffer, +- CORBA::Boolean release=0 +- ); +- PolicyTypeSeq (const PolicyTypeSeq &); // copy ctor +- ~PolicyTypeSeq (void); +- static void _tao_any_destructor (void*); +- +-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef PolicyTypeSeq_var _var_type; +-#endif /* ! __GNUC__ || g++ >= 2.8 */ ++ 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::Boolean release=0 ++ ); ++ CORBA_PolicyTypeSeq (const CORBA_PolicyTypeSeq &); // copy ctor ++ ~CORBA_PolicyTypeSeq (void); // dtor + ++ static void _tao_any_destructor (void*); + }; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_POLICYTYPESEQ___VAR_CH_) +-#define _CORBA_POLICYTYPESEQ___VAR_CH_ ++typedef CORBA_PolicyTypeSeq *CORBA_PolicyTypeSeq_ptr; + + // ************************************************************* + // class CORBA::PolicyTypeSeq_var + // ************************************************************* + +-class TAO_Export PolicyTypeSeq_var ++class TAO_Export CORBA_PolicyTypeSeq_var + { + public: +- PolicyTypeSeq_var (void); // default constructor +- PolicyTypeSeq_var (PolicyTypeSeq *); +- PolicyTypeSeq_var (const PolicyTypeSeq_var &); // copy constructor +- PolicyTypeSeq_var (const PolicyTypeSeq &); // fixed-size base types only +- ~PolicyTypeSeq_var (void); // destructor +- +- PolicyTypeSeq_var &operator= (PolicyTypeSeq *); +- PolicyTypeSeq_var &operator= (const PolicyTypeSeq_var &); +- PolicyTypeSeq_var &operator= (const PolicyTypeSeq &); // fixed-size base types only +- PolicyTypeSeq *operator-> (void); +- const PolicyTypeSeq *operator-> (void) const; +- +- operator const PolicyTypeSeq &() const; +- operator PolicyTypeSeq &(); +- operator PolicyTypeSeq &() const; +- +- PolicyType &operator[] (CORBA::ULong index); +- // in, inout, out, _retn +- const PolicyTypeSeq &in (void) const; +- PolicyTypeSeq &inout (void); +- PolicyTypeSeq *&out (void); +- PolicyTypeSeq *_retn (void); +- PolicyTypeSeq *ptr (void) const; +- +-private: +- PolicyTypeSeq *ptr_; +-}; +- ++ CORBA_PolicyTypeSeq_var (void); // default constructor ++ CORBA_PolicyTypeSeq_var (CORBA_PolicyTypeSeq *); ++ CORBA_PolicyTypeSeq_var (const CORBA_PolicyTypeSeq_var &); ++ ~CORBA_PolicyTypeSeq_var (void); // destructor + +-#endif /* end #if !defined */ ++ CORBA_PolicyTypeSeq_var &operator= (CORBA_PolicyTypeSeq *); ++ CORBA_PolicyTypeSeq_var &operator= (const CORBA_PolicyTypeSeq_var &); ++ 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 slot); ++ // in, inout, out, _retn ++ const CORBA_PolicyTypeSeq &in (void) const; ++ CORBA_PolicyTypeSeq &inout (void); ++ CORBA_PolicyTypeSeq *&out (void); ++ CORBA_PolicyTypeSeq *_retn (void); ++ CORBA_PolicyTypeSeq *ptr (void) const; + +-#if !defined (_CORBA_POLICYTYPESEQ___OUT_CH_) +-#define _CORBA_POLICYTYPESEQ___OUT_CH_ +- +-class TAO_Export PolicyTypeSeq_out -{ -public: -- CORBA_Current_out (CORBA_Current_ptr &); -- CORBA_Current_out (CORBA_Current_var &); -- CORBA_Current_out (const CORBA_Current_out &); -- CORBA_Current_out &operator= (const CORBA_Current_out &); -- CORBA_Current_out &operator= (const CORBA_Current_var &); -- CORBA_Current_out &operator= (CORBA_Current_ptr); -- operator CORBA_Current_ptr &(); -- CORBA_Current_ptr &ptr (void); -- CORBA_Current_ptr operator-> (void); +- PolicyTypeSeq_out (PolicyTypeSeq *&); +- PolicyTypeSeq_out (PolicyTypeSeq_var &); +- PolicyTypeSeq_out (const PolicyTypeSeq_out &); +- PolicyTypeSeq_out &operator= (const PolicyTypeSeq_out &); +- PolicyTypeSeq_out &operator= (PolicyTypeSeq *); +- operator PolicyTypeSeq *&(); +- PolicyTypeSeq *&ptr (void); +- PolicyTypeSeq *operator-> (void); +- PolicyType &operator[] (CORBA::ULong index); - --private: -- CORBA_Current_ptr &ptr_; + private: +- PolicyTypeSeq *&ptr_; +- // assignment from T_var not allowed +- void operator= (const PolicyTypeSeq_var &); -}; - - -#endif /* end #if !defined */ - +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PolicyTypeSeq; - --#if !defined (_CORBA_CURRENT_CH_) --#define _CORBA_CURRENT_CH_ +-enum SetOverrideType +-{ +- SET_OVERRIDE, +- ADD_OVERRIDE, +- SetOverrideType_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF ++ CORBA_PolicyTypeSeq *ptr_; + }; +-typedef SetOverrideType &SetOverrideType_out; +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_SetOverrideType; +- +- +-#if !defined (_CORBA_POLICYMANAGER___PTR_CH_) +-#define _CORBA_POLICYMANAGER___PTR_CH_ + +-class PolicyManager; +-typedef PolicyManager *PolicyManager_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_POLICYMANAGER___VAR_CH_) +-#define _CORBA_POLICYMANAGER___VAR_CH_ +- +-class TAO_Export PolicyManager_var : public TAO_Base_var ++class TAO_Export CORBA_PolicyTypeSeq_out + { + public: +- PolicyManager_var (void); // default constructor +- PolicyManager_var (PolicyManager_ptr); +- PolicyManager_var (const PolicyManager_var &); // copy constructor +- ~PolicyManager_var (void); // destructor +- +- PolicyManager_var &operator= (PolicyManager_ptr); +- PolicyManager_var &operator= (const PolicyManager_var &); +- PolicyManager_ptr operator-> (void) const; +- +- operator const PolicyManager_ptr &() const; +- operator PolicyManager_ptr &(); +- // in, inout, out, _retn +- PolicyManager_ptr in (void) const; +- PolicyManager_ptr &inout (void); +- PolicyManager_ptr &out (void); +- PolicyManager_ptr _retn (void); +- PolicyManager_ptr ptr (void) const; ++ CORBA_PolicyTypeSeq_out (CORBA_PolicyTypeSeq *&); ++ CORBA_PolicyTypeSeq_out (CORBA_PolicyTypeSeq_var &); ++ CORBA_PolicyTypeSeq_out (const CORBA_PolicyTypeSeq_out &); ++ CORBA_PolicyTypeSeq_out &operator= (const CORBA_PolicyTypeSeq_out &); ++ CORBA_PolicyTypeSeq_out &operator= (CORBA_PolicyTypeSeq *); ++ operator CORBA_PolicyTypeSeq *&(); ++ CORBA_PolicyTypeSeq *&ptr (void); ++ CORBA_PolicyTypeSeq *operator-> (void); ++ CORBA::PolicyType &operator[] (CORBA::ULong slot); + + private: +- PolicyManager_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- PolicyManager_var (const TAO_Base_var &rhs); +- PolicyManager_var &operator= (const TAO_Base_var &rhs); ++ CORBA_PolicyTypeSeq *&ptr_; ++ // assignment from T_var not allowed ++ void operator= (const CORBA_PolicyTypeSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_POLICYMANAGER___OUT_CH_) +-#define _CORBA_POLICYMANAGER___OUT_CH_ +- +-class TAO_Export PolicyManager_out ++class TAO_Export CORBA_PolicyManager_var : public TAO_Base_var + { + public: +- PolicyManager_out (PolicyManager_ptr &); +- PolicyManager_out (PolicyManager_var &); +- PolicyManager_out (const PolicyManager_out &); +- PolicyManager_out &operator= (const PolicyManager_out &); +- PolicyManager_out &operator= (const PolicyManager_var &); +- PolicyManager_out &operator= (PolicyManager_ptr); +- operator PolicyManager_ptr &(); +- PolicyManager_ptr &ptr (void); +- PolicyManager_ptr operator-> (void); +- +-private: +- PolicyManager_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ - --class TAO_Export CORBA_Current : public virtual CORBA_Object ++ CORBA_PolicyManager_var (void); // default constructor ++ CORBA_PolicyManager_var (CORBA_PolicyManager_ptr); ++ CORBA_PolicyManager_var (const CORBA_PolicyManager_var &); ++ ~CORBA_PolicyManager_var (void); // destructor + +-#if !defined (_CORBA_POLICYMANAGER_CH_) +-#define _CORBA_POLICYMANAGER_CH_ ++ CORBA_PolicyManager_var &operator= (CORBA_PolicyManager_ptr); ++ CORBA_PolicyManager_var &operator= (const CORBA_PolicyManager_var &); ++ CORBA_PolicyManager_ptr operator-> (void) const; + +-class TAO_Export PolicyManager : public virtual CORBA_Object -{ -public: -#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) -- typedef CORBA_Current_ptr _ptr_type; -- typedef CORBA_Current_var _var_type; +- typedef PolicyManager_ptr _ptr_type; +- typedef PolicyManager_var _var_type; -#endif /* ! __GNUC__ || g++ >= 2.8 */ - - // the static operations -- static CORBA_Current_ptr _duplicate (CORBA_Current_ptr obj); -- static CORBA_Current_ptr _narrow ( +- static PolicyManager_ptr _duplicate (PolicyManager_ptr obj); +- static PolicyManager_ptr _narrow ( - CORBA::Object_ptr obj, - CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment () - ); -- static CORBA_Current_ptr _unchecked_narrow ( +- static PolicyManager_ptr _unchecked_narrow ( - CORBA::Object_ptr obj, - CORBA::Environment &ACE_TRY_ENV = - TAO_default_environment () - ); -- static CORBA_Current_ptr _nil (void) +- static PolicyManager_ptr _nil (void) - { -- return (CORBA_Current_ptr)0; +- return (PolicyManager_ptr)0; - } ++ operator const CORBA_PolicyManager_ptr &() const; ++ operator CORBA_PolicyManager_ptr &(); ++ // in, inout, out, _retn ++ CORBA_PolicyManager_ptr in (void) const; ++ CORBA_PolicyManager_ptr &inout (void); ++ CORBA_PolicyManager_ptr &out (void); ++ CORBA_PolicyManager_ptr _retn (void); ++ CORBA_PolicyManager_ptr ptr (void) const; + +- static void _tao_any_destructor (void*); +- +- virtual CORBA::PolicyList * get_policy_overrides ( +- const CORBA::PolicyTypeSeq & ts, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual void set_policy_overrides ( +- const CORBA::PolicyList & policies, +- CORBA::SetOverrideType set_add, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException, +- CORBA::InvalidPolicies +- )); - +- 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; - -protected: -- CORBA_Current (void); -- virtual ~CORBA_Current (void); --private: -- CORBA_Current (const CORBA_Current &); -- void operator= (const CORBA_Current &); +- PolicyManager (void); +- PolicyManager (TAO_Stub *objref, +- TAO_ServantBase *_tao_servant = 0, +- CORBA::Boolean _tao_collocated = 0 +- ); +- virtual ~PolicyManager (void); + private: +- PolicyManager (const PolicyManager &); +- void operator= (const PolicyManager &); -}; - - -#endif /* end #if !defined */ - +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PolicyManager; +- +- +-#if !defined (_CORBA_CURRENT___PTR_CH_) +-#define _CORBA_CURRENT___PTR_CH_ +- +-class Current; +-typedef Current *Current_ptr; +- +-#endif /* end #if !defined */ +- - - #if !defined (_CORBA_POLICYCURRENT___PTR_CH_) - #define _CORBA_POLICYCURRENT___PTR_CH_ +-#if !defined (_CORBA_CURRENT___VAR_CH_) +-#define _CORBA_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_; ++ CORBA_PolicyManager_ptr ptr_; + // Unimplemented - prevents widening assignment. +- Current_var (const TAO_Base_var &rhs); +- Current_var &operator= (const TAO_Base_var &rhs); ++ CORBA_PolicyManager_var (const TAO_Base_var &rhs); ++ CORBA_PolicyManager_var &operator= (const TAO_Base_var &rhs); + }; -@@ -1206,7 +1083,7 @@ +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_CURRENT___OUT_CH_) +-#define _CORBA_CURRENT___OUT_CH_ +- +-class TAO_Export Current_out ++class TAO_Export CORBA_PolicyManager_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); +- ++ CORBA_PolicyManager_out (CORBA_PolicyManager_ptr &); ++ CORBA_PolicyManager_out (CORBA_PolicyManager_var &); ++ CORBA_PolicyManager_out (const CORBA_PolicyManager_out &); ++ CORBA_PolicyManager_out &operator= (const CORBA_PolicyManager_out &); ++ CORBA_PolicyManager_out &operator= (const CORBA_PolicyManager_var &); ++ CORBA_PolicyManager_out &operator= (CORBA_PolicyManager_ptr); ++ operator CORBA_PolicyManager_ptr &(); ++ CORBA_PolicyManager_ptr &ptr (void); ++ CORBA_PolicyManager_ptr operator-> (void); ++ + private: +- Current_ptr &ptr_; ++ CORBA_PolicyManager_ptr &ptr_; + }; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_CURRENT_CH_) +-#define _CORBA_CURRENT_CH_ +- +-class TAO_Export Current : public virtual CORBA_Object ++class TAO_Export CORBA_PolicyManager : public virtual CORBA_Object + { + 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 */ ++#if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 ++ typedef CORBA_PolicyManager_ptr _ptr_type; ++ typedef CORBA_PolicyManager_var _var_type; ++#endif /* __GNUC__ */ - #if defined (__ACE_INLINE__) --#include "PolicyC.i" + // 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; +- } +- ++ static CORBA_PolicyManager_ptr _duplicate (CORBA_PolicyManager_ptr obj); ++ static CORBA_PolicyManager_ptr _narrow ( ++ CORBA::Object_ptr obj, ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ); ++ static CORBA_PolicyManager_ptr _nil (void); + static void _tao_any_destructor (void*); + ++ virtual CORBA_PolicyList * get_policy_overrides ( ++ const CORBA_PolicyTypeSeq & ts, ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ); ++ virtual void set_policy_overrides ( ++ const CORBA_PolicyList & policies, ++ CORBA::SetOverrideType set_add, ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ); + 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); +- ++ const CORBA::Char *type_id, ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ); + virtual const char* _interface_repository_id (void) const; +- + protected: +- Current (void); +- Current (TAO_Stub *objref, +- TAO_ServantBase *_tao_servant = 0, +- CORBA::Boolean _tao_collocated = 0 +- ); +- virtual ~Current (void); ++ CORBA_PolicyManager (void); // default constructor ++ CORBA_PolicyManager (TAO_Stub *objref, ++ TAO_ServantBase *_tao_servant = 0, ++ CORBA::Boolean _tao_collocated = 0 ++ ); ++ virtual ~CORBA_PolicyManager (void); + private: +- Current (const Current &); +- void operator= (const Current &); ++ CORBA_PolicyManager (const CORBA_PolicyManager &); ++ void operator= (const CORBA_PolicyManager &); + }; + ++// **************************************************************** + +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Current; +- +- +-#if !defined (_CORBA_POLICYCURRENT___PTR_CH_) +-#define _CORBA_POLICYCURRENT___PTR_CH_ +- +-class PolicyCurrent; +-typedef PolicyCurrent *PolicyCurrent_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_POLICYCURRENT___VAR_CH_) +-#define _CORBA_POLICYCURRENT___VAR_CH_ +- +-class TAO_Export PolicyCurrent_var : public TAO_Base_var ++class TAO_Export CORBA_PolicyCurrent_var : public TAO_Base_var + { + public: +- PolicyCurrent_var (void); // default constructor +- PolicyCurrent_var (PolicyCurrent_ptr); +- PolicyCurrent_var (const PolicyCurrent_var &); // copy constructor +- ~PolicyCurrent_var (void); // destructor +- +- PolicyCurrent_var &operator= (PolicyCurrent_ptr); +- PolicyCurrent_var &operator= (const PolicyCurrent_var &); +- PolicyCurrent_ptr operator-> (void) const; +- +- operator const PolicyCurrent_ptr &() const; +- operator PolicyCurrent_ptr &(); +- // in, inout, out, _retn +- PolicyCurrent_ptr in (void) const; +- PolicyCurrent_ptr &inout (void); +- PolicyCurrent_ptr &out (void); +- PolicyCurrent_ptr _retn (void); +- PolicyCurrent_ptr ptr (void) const; ++ CORBA_PolicyCurrent_var (void); // default constructor ++ CORBA_PolicyCurrent_var (CORBA_PolicyCurrent_ptr); ++ CORBA_PolicyCurrent_var (const CORBA_PolicyCurrent_var &); ++ ~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 ++ CORBA_PolicyCurrent_ptr in (void) const; ++ CORBA_PolicyCurrent_ptr &inout (void); ++ CORBA_PolicyCurrent_ptr &out (void); ++ CORBA_PolicyCurrent_ptr _retn (void); ++ CORBA_PolicyCurrent_ptr ptr (void) const; + + private: +- PolicyCurrent_ptr ptr_; ++ CORBA_PolicyCurrent_ptr ptr_; + // Unimplemented - prevents widening assignment. +- PolicyCurrent_var (const TAO_Base_var &rhs); +- PolicyCurrent_var &operator= (const TAO_Base_var &rhs); ++ CORBA_PolicyCurrent_var (const TAO_Base_var &rhs); ++ CORBA_PolicyCurrent_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_POLICYCURRENT___OUT_CH_) +-#define _CORBA_POLICYCURRENT___OUT_CH_ +- +-class TAO_Export PolicyCurrent_out ++class TAO_Export CORBA_PolicyCurrent_out + { + public: +- PolicyCurrent_out (PolicyCurrent_ptr &); +- PolicyCurrent_out (PolicyCurrent_var &); +- PolicyCurrent_out (const PolicyCurrent_out &); +- PolicyCurrent_out &operator= (const PolicyCurrent_out &); +- PolicyCurrent_out &operator= (const PolicyCurrent_var &); +- PolicyCurrent_out &operator= (PolicyCurrent_ptr); +- operator PolicyCurrent_ptr &(); +- PolicyCurrent_ptr &ptr (void); +- PolicyCurrent_ptr operator-> (void); +- ++ CORBA_PolicyCurrent_out (CORBA_PolicyCurrent_ptr &); ++ CORBA_PolicyCurrent_out (CORBA_PolicyCurrent_var &); ++ CORBA_PolicyCurrent_out (const CORBA_PolicyCurrent_out &); ++ CORBA_PolicyCurrent_out &operator= (const CORBA_PolicyCurrent_out &); ++ CORBA_PolicyCurrent_out &operator= (const CORBA_PolicyCurrent_var &); ++ CORBA_PolicyCurrent_out &operator= (CORBA_PolicyCurrent_ptr); ++ operator CORBA_PolicyCurrent_ptr &(); ++ CORBA_PolicyCurrent_ptr &ptr (void); ++ CORBA_PolicyCurrent_ptr operator-> (void); ++ + private: +- PolicyCurrent_ptr &ptr_; ++ CORBA_PolicyCurrent_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_CORBA_POLICYCURRENT_CH_) +-#define _CORBA_POLICYCURRENT_CH_ +- +-class TAO_Export PolicyCurrent: public virtual PolicyManager, public virtual Current ++class TAO_Export CORBA_PolicyCurrent: public virtual CORBA_PolicyManager, public virtual CORBA_Current + { + public: +-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef PolicyCurrent_ptr _ptr_type; +- typedef PolicyCurrent_var _var_type; +-#endif /* ! __GNUC__ || g++ >= 2.8 */ ++#if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8 ++ typedef CORBA_PolicyCurrent_ptr _ptr_type; ++ typedef CORBA_PolicyCurrent_var _var_type; ++#endif /* __GNUC__ */ + + // the static operations +- static PolicyCurrent_ptr _duplicate (PolicyCurrent_ptr obj); +- static PolicyCurrent_ptr _narrow ( +- CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- static PolicyCurrent_ptr _unchecked_narrow ( +- CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- static PolicyCurrent_ptr _nil (void) +- { +- return (PolicyCurrent_ptr)0; +- } +- ++ static CORBA_PolicyCurrent_ptr _duplicate (CORBA_PolicyCurrent_ptr obj); ++ static CORBA_PolicyCurrent_ptr _narrow ( ++ CORBA::Object_ptr obj, ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ); ++ static CORBA_PolicyCurrent_ptr _nil (void); + static void _tao_any_destructor (void*); + + 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); +- ++ const CORBA::Char *type_id, ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ); + virtual const char* _interface_repository_id (void) const; +- + protected: +- PolicyCurrent (void); +- PolicyCurrent (TAO_Stub *objref, +- TAO_ServantBase *_tao_servant = 0, +- CORBA::Boolean _tao_collocated = 0 +- ); +- virtual ~PolicyCurrent (void); ++ CORBA_PolicyCurrent (void); // default constructor ++ CORBA_PolicyCurrent (TAO_Stub *objref, ++ TAO_ServantBase *_tao_servant = 0, ++ CORBA::Boolean _tao_collocated = 0 ++ ); ++ virtual ~CORBA_PolicyCurrent (void); + private: +- PolicyCurrent (const PolicyCurrent &); +- void operator= (const PolicyCurrent &); ++ CORBA_PolicyCurrent (const CORBA_PolicyCurrent &); ++ void operator= (const CORBA_PolicyCurrent &); + }; + ++// **************************************************************** + +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PolicyCurrent; +- ++TAO_Export void operator<<= (CORBA::Any &, ++ const CORBA::PolicyError &); ++TAO_Export void operator<<= (CORBA::Any &, ++ CORBA::PolicyError*); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ CORBA::PolicyError *&); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ const CORBA::PolicyError *&); ++TAO_Export void operator<<= (CORBA::Any &, ++ const CORBA::InvalidPolicies &); ++TAO_Export void operator<<= (CORBA::Any &, ++ CORBA::InvalidPolicies*); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ CORBA::InvalidPolicies *&); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ const CORBA::InvalidPolicies *&); + +-} +-TAO_NAMESPACE_CLOSE // module CORBA +- +-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 *&); +-extern TAO_Export CORBA::Policy_ptr (*_TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer) ( +- CORBA::Object_ptr obj +- ); + // 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 &); +-extern TAO_Export CORBA::PolicyManager_ptr (*_TAO_collocation_CORBA_PolicyManager_Stub_Factory_function_pointer) ( +- CORBA::Object_ptr obj +- ); +-// Any operators for interface CORBA::PolicyManager +-TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyManager_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyManager *&); +-extern TAO_Export CORBA::Current_ptr (*_TAO_collocation_CORBA_Current_Stub_Factory_function_pointer) ( +- CORBA::Object_ptr obj +- ); +-// Any operators for interface CORBA::Current +-TAO_Export void operator<<= (CORBA::Any &, CORBA::Current_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Current *&); +-extern TAO_Export CORBA::PolicyCurrent_ptr (*_TAO_collocation_CORBA_PolicyCurrent_Stub_Factory_function_pointer) ( +- CORBA::Object_ptr obj +- ); +-// Any operators for interface CORBA::PolicyCurrent +-TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyCurrent_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyCurrent *&); ++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 &); ++TAO_Export void operator<<= (CORBA::Any &, ++ CORBA::PolicyList*); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ CORBA::PolicyList *&); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ const CORBA::PolicyList *&); ++TAO_Export void operator<<= (CORBA::Any &, ++ const CORBA::PolicyTypeSeq &); ++TAO_Export void operator<<= (CORBA::Any &, ++ CORBA::PolicyTypeSeq*); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ CORBA::PolicyTypeSeq *&); ++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 &, ++ CORBA::PolicyManager_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ CORBA::PolicyManager *&); ++TAO_Export void operator<<= (CORBA::Any &, ++ CORBA::PolicyCurrent_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, ++ CORBA::PolicyCurrent *&); + +-#ifndef __ACE_INLINE__ ++// **************************************************************** ++ ++#if defined (__ACE_INLINE__) +#include "tao/PolicyC.i" ++#else + + TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PolicyError &); + TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PolicyError &); +- +-# if !defined (ACE_LACKS_IOSTREAM_TOTALLY) +- +-TAO_Export ostream& operator<< (ostream &, const CORBA::PolicyError &); +- +-# endif /* ACE_LACKS_IOSTREAM_TOTALLY */ + 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 & +- ); +-TAO_Export CORBA::Boolean operator>> ( +- TAO_InputCDR &, +- CORBA::InvalidPolicies::_tao_seq_UShort & +- ); +- +-#endif /* _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_H_ */ +- +- +-# if !defined (ACE_LACKS_IOSTREAM_TOTALLY) +- +-TAO_Export ostream& operator<< (ostream &, const CORBA::InvalidPolicies &); +- +-# endif /* ACE_LACKS_IOSTREAM_TOTALLY */ ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::InvalidPolicies::_tao_seq_UShort &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::InvalidPolicies::_tao_seq_UShort &); + 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 & +- ); +-TAO_Export CORBA::Boolean operator>> ( +- TAO_InputCDR &, +- CORBA::PolicyList & +- ); +- +-#endif /* _TAO_CDR_OP_CORBA_PolicyList_H_ */ +- +- +-#if !defined _TAO_CDR_OP_CORBA_PolicyTypeSeq_H_ +-#define _TAO_CDR_OP_CORBA_PolicyTypeSeq_H_ +- +-TAO_Export CORBA::Boolean operator<< ( +- TAO_OutputCDR &, +- const CORBA::PolicyTypeSeq & +- ); +-TAO_Export CORBA::Boolean operator>> ( +- TAO_InputCDR &, +- 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_OutputCDR &, const CORBA::PolicyList &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PolicyList &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PolicyTypeSeq &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PolicyTypeSeq &); ++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::PolicyManager_ptr ); + TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PolicyManager_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Current_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Current_ptr &); + TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::PolicyCurrent_ptr ); + TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::PolicyCurrent_ptr &); + +-#endif /* __ACE_INLINE__ */ +- +- +-#if defined (__ACE_INLINE__) +-#include "PolicyC.i" #endif /* defined INLINE */ - #if defined(_MSC_VER) && (_MSC_VER >= 1200) +-#if defined(_MSC_VER) && (_MSC_VER >= 1200) +-#pragma warning(pop) +-#endif /* _MSC_VER */ +- + #include "ace/post.h" +-#endif /* ifndef */ ++#endif /* TAO_IDL_POLICYC_H */ |