diff options
Diffstat (limited to 'TAO/tao/diffs/MessagingC.h.diff')
| -rw-r--r-- | TAO/tao/diffs/MessagingC.h.diff | 2047 |
1 files changed, 2047 insertions, 0 deletions
diff --git a/TAO/tao/diffs/MessagingC.h.diff b/TAO/tao/diffs/MessagingC.h.diff new file mode 100644 index 00000000000..8931ac1aba0 --- /dev/null +++ b/TAO/tao/diffs/MessagingC.h.diff @@ -0,0 +1,2047 @@ +--- orig/MessagingC.h Fri Apr 28 16:44:03 2000 ++++ MessagingC.h Fri Apr 28 16:58:27 2000 +@@ -7,24 +7,36 @@ + // Information about TAO is available at: + // http://www.cs.wustl.edu/~schmidt/TAO.html + +-#ifndef _TAO_IDL_ORIG_MESSAGINGC_H_ +-#define _TAO_IDL_ORIG_MESSAGINGC_H_ ++#ifndef _TAO_IDL_MESSAGINGC_H_ ++#define _TAO_IDL_MESSAGINGC_H_ ++#include "ace/pre.h" ++ ++#include "tao/orbconf.h" ++ ++#if (TAO_HAS_CORBA_MESSAGING == 1) ++ ++#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1) ++#include "tao/ValueBase.h" ++#include "tao/ValueFactory.h" ++#endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */ + +-#include "tao/corba.h" +- +-#if defined (ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION) +-#include "ace/streams.h" +-#endif /* ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION */ ++#include "tao/corbafwd.h" + + #if !defined (ACE_LACKS_PRAGMA_ONCE) + # pragma once + #endif /* ACE_LACKS_PRAGMA_ONCE */ + +-#include "tao/corbafwd.h" +-#include "TimeBaseC.h" +-#include "IOPC.h" +-#include "PolicyC.h" +-#include "PollableC.h" ++#include "tao/Any.h" ++#include "tao/CDR.h" ++#include "tao/TimeBaseC.h" ++#include "tao/PolicyC.h" ++#include "tao/IOPC.h" ++#include "tao/PollableC.h" ++ ++#if (TAO_HAS_SMART_PROXIES == 1) ++#include "tao/Smart_Proxies.h" ++#include "ace/Singleton.h" ++#endif /*TAO_HAS_SMART_PROXIES == 1*/ + + #if defined (TAO_EXPORT_MACRO) + #undef TAO_EXPORT_MACRO +@@ -45,6 +57,11 @@ + #pragma warning(disable:4250) + #endif /* _MSC_VER */ + ++#if defined(TRANSPARENT) ++// Some platforms define this macro for ioctl() ++#undef TRANSPARENT ++#endif ++ + TAO_NAMESPACE Messaging + { + typedef CORBA::Short RebindMode; +@@ -103,6 +120,8 @@ + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::UShort ORDER_DEADLINE; + ++#if (TAO_HAS_REBIND_POLICY == 1) ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong REBIND_POLICY_TYPE; + + +@@ -111,7 +130,7 @@ + + class RebindPolicy; + typedef RebindPolicy *RebindPolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -125,14 +144,14 @@ + RebindPolicy_var (RebindPolicy_ptr); + RebindPolicy_var (const RebindPolicy_var &); // copy constructor + ~RebindPolicy_var (void); // destructor +- ++ + RebindPolicy_var &operator= (RebindPolicy_ptr); + RebindPolicy_var &operator= (const RebindPolicy_var &); + RebindPolicy_ptr operator-> (void) const; +- ++ + operator const RebindPolicy_ptr &() const; + operator RebindPolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + RebindPolicy_ptr in (void) const; + RebindPolicy_ptr &inout (void); + RebindPolicy_ptr &out (void); +@@ -162,7 +181,7 @@ + operator RebindPolicy_ptr &(); + RebindPolicy_ptr &ptr (void); + RebindPolicy_ptr operator-> (void); +- ++ + private: + RebindPolicy_ptr &ptr_; + }; +@@ -174,7 +193,7 @@ + #if !defined (_MESSAGING_REBINDPOLICY_CH_) + #define _MESSAGING_REBINDPOLICY_CH_ + +-class TAO_Export RebindPolicy: public virtual CORBA::Policy ++ class TAO_Export RebindPolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -186,12 +205,12 @@ + static RebindPolicy_ptr _duplicate (RebindPolicy_ptr obj); + static RebindPolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RebindPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RebindPolicy_ptr _nil (void) +@@ -200,7 +219,7 @@ + } + + virtual Messaging::RebindMode rebind_mode ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -208,7 +227,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -222,6 +241,10 @@ + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_REBIND_POLICY == 1 */ ++ ++#if (TAO_HAS_SYNC_SCOPE_POLICY == 1) ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong SYNC_SCOPE_POLICY_TYPE; + + +@@ -230,7 +253,7 @@ + + class SyncScopePolicy; + typedef SyncScopePolicy *SyncScopePolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -244,14 +267,14 @@ + SyncScopePolicy_var (SyncScopePolicy_ptr); + SyncScopePolicy_var (const SyncScopePolicy_var &); // copy constructor + ~SyncScopePolicy_var (void); // destructor +- ++ + SyncScopePolicy_var &operator= (SyncScopePolicy_ptr); + SyncScopePolicy_var &operator= (const SyncScopePolicy_var &); + SyncScopePolicy_ptr operator-> (void) const; +- ++ + operator const SyncScopePolicy_ptr &() const; + operator SyncScopePolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + SyncScopePolicy_ptr in (void) const; + SyncScopePolicy_ptr &inout (void); + SyncScopePolicy_ptr &out (void); +@@ -281,7 +304,7 @@ + operator SyncScopePolicy_ptr &(); + SyncScopePolicy_ptr &ptr (void); + SyncScopePolicy_ptr operator-> (void); +- ++ + private: + SyncScopePolicy_ptr &ptr_; + }; +@@ -293,7 +316,7 @@ + #if !defined (_MESSAGING_SYNCSCOPEPOLICY_CH_) + #define _MESSAGING_SYNCSCOPEPOLICY_CH_ + +-class TAO_Export SyncScopePolicy: public virtual CORBA::Policy ++ class TAO_Export SyncScopePolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -305,12 +328,12 @@ + static SyncScopePolicy_ptr _duplicate (SyncScopePolicy_ptr obj); + static SyncScopePolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static SyncScopePolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static SyncScopePolicy_ptr _nil (void) +@@ -319,7 +342,7 @@ + } + + virtual Messaging::SyncScope synchronization ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -327,7 +350,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -341,11 +364,15 @@ + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_SYNC_SCOPE_POLICY == 1 */ ++ ++#if (TAO_HAS_PRIORITY_POLICIES == 1) ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong REQUEST_PRIORITY_POLICY_TYPE; + + struct PriorityRange; + class PriorityRange_var; +- ++ + struct TAO_Export PriorityRange + { + +@@ -367,18 +394,18 @@ + PriorityRange_var (const PriorityRange_var &); // copy constructor + PriorityRange_var (const PriorityRange &); // fixed-size types only + ~PriorityRange_var (void); // destructor +- ++ + PriorityRange_var &operator= (PriorityRange *); + PriorityRange_var &operator= (const PriorityRange_var &); + PriorityRange_var &operator= (const PriorityRange &); // fixed-size types only + PriorityRange *operator-> (void); + const PriorityRange *operator-> (void) const; +- ++ + operator const PriorityRange &() const; + operator PriorityRange &(); + operator PriorityRange &() const; +- +- // in, inout, out, _retn ++ ++ // in, inout, out, _retn + const PriorityRange &in (void) const; + PriorityRange &inout (void); + PriorityRange &out (void); +@@ -399,7 +426,7 @@ + + class RequestPriorityPolicy; + typedef RequestPriorityPolicy *RequestPriorityPolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -413,14 +440,14 @@ + RequestPriorityPolicy_var (RequestPriorityPolicy_ptr); + RequestPriorityPolicy_var (const RequestPriorityPolicy_var &); // copy constructor + ~RequestPriorityPolicy_var (void); // destructor +- ++ + RequestPriorityPolicy_var &operator= (RequestPriorityPolicy_ptr); + RequestPriorityPolicy_var &operator= (const RequestPriorityPolicy_var &); + RequestPriorityPolicy_ptr operator-> (void) const; +- ++ + operator const RequestPriorityPolicy_ptr &() const; + operator RequestPriorityPolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + RequestPriorityPolicy_ptr in (void) const; + RequestPriorityPolicy_ptr &inout (void); + RequestPriorityPolicy_ptr &out (void); +@@ -450,7 +477,7 @@ + operator RequestPriorityPolicy_ptr &(); + RequestPriorityPolicy_ptr &ptr (void); + RequestPriorityPolicy_ptr operator-> (void); +- ++ + private: + RequestPriorityPolicy_ptr &ptr_; + }; +@@ -462,7 +489,7 @@ + #if !defined (_MESSAGING_REQUESTPRIORITYPOLICY_CH_) + #define _MESSAGING_REQUESTPRIORITYPOLICY_CH_ + +-class TAO_Export RequestPriorityPolicy: public virtual CORBA::Policy ++ class TAO_Export RequestPriorityPolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -474,12 +501,12 @@ + static RequestPriorityPolicy_ptr _duplicate (RequestPriorityPolicy_ptr obj); + static RequestPriorityPolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RequestPriorityPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RequestPriorityPolicy_ptr _nil (void) +@@ -488,7 +515,7 @@ + } + + virtual Messaging::PriorityRange priority_range ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -496,7 +523,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -518,7 +545,7 @@ + + class ReplyPriorityPolicy; + typedef ReplyPriorityPolicy *ReplyPriorityPolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -532,14 +559,14 @@ + ReplyPriorityPolicy_var (ReplyPriorityPolicy_ptr); + ReplyPriorityPolicy_var (const ReplyPriorityPolicy_var &); // copy constructor + ~ReplyPriorityPolicy_var (void); // destructor +- ++ + ReplyPriorityPolicy_var &operator= (ReplyPriorityPolicy_ptr); + ReplyPriorityPolicy_var &operator= (const ReplyPriorityPolicy_var &); + ReplyPriorityPolicy_ptr operator-> (void) const; +- ++ + operator const ReplyPriorityPolicy_ptr &() const; + operator ReplyPriorityPolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + ReplyPriorityPolicy_ptr in (void) const; + ReplyPriorityPolicy_ptr &inout (void); + ReplyPriorityPolicy_ptr &out (void); +@@ -569,7 +596,7 @@ + operator ReplyPriorityPolicy_ptr &(); + ReplyPriorityPolicy_ptr &ptr (void); + ReplyPriorityPolicy_ptr operator-> (void); +- ++ + private: + ReplyPriorityPolicy_ptr &ptr_; + }; +@@ -581,7 +608,7 @@ + #if !defined (_MESSAGING_REPLYPRIORITYPOLICY_CH_) + #define _MESSAGING_REPLYPRIORITYPOLICY_CH_ + +-class TAO_Export ReplyPriorityPolicy: public virtual CORBA::Policy ++ class TAO_Export ReplyPriorityPolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -593,12 +620,12 @@ + static ReplyPriorityPolicy_ptr _duplicate (ReplyPriorityPolicy_ptr obj); + static ReplyPriorityPolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ReplyPriorityPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ReplyPriorityPolicy_ptr _nil (void) +@@ -607,7 +634,7 @@ + } + + virtual Messaging::PriorityRange priority_range ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -615,7 +642,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -629,6 +656,10 @@ + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_PRIORITY_POLICIES == 1 */ ++ ++#if (TAO_HAS_REQUEST_START_TIME_POLICY == 1) ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong REQUEST_START_TIME_POLICY_TYPE; + + +@@ -637,7 +668,7 @@ + + class RequestStartTimePolicy; + typedef RequestStartTimePolicy *RequestStartTimePolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -651,14 +682,14 @@ + RequestStartTimePolicy_var (RequestStartTimePolicy_ptr); + RequestStartTimePolicy_var (const RequestStartTimePolicy_var &); // copy constructor + ~RequestStartTimePolicy_var (void); // destructor +- ++ + RequestStartTimePolicy_var &operator= (RequestStartTimePolicy_ptr); + RequestStartTimePolicy_var &operator= (const RequestStartTimePolicy_var &); + RequestStartTimePolicy_ptr operator-> (void) const; +- ++ + operator const RequestStartTimePolicy_ptr &() const; + operator RequestStartTimePolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + RequestStartTimePolicy_ptr in (void) const; + RequestStartTimePolicy_ptr &inout (void); + RequestStartTimePolicy_ptr &out (void); +@@ -688,7 +719,7 @@ + operator RequestStartTimePolicy_ptr &(); + RequestStartTimePolicy_ptr &ptr (void); + RequestStartTimePolicy_ptr operator-> (void); +- ++ + private: + RequestStartTimePolicy_ptr &ptr_; + }; +@@ -700,7 +731,7 @@ + #if !defined (_MESSAGING_REQUESTSTARTTIMEPOLICY_CH_) + #define _MESSAGING_REQUESTSTARTTIMEPOLICY_CH_ + +-class TAO_Export RequestStartTimePolicy: public virtual CORBA::Policy ++ class TAO_Export RequestStartTimePolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -712,12 +743,12 @@ + static RequestStartTimePolicy_ptr _duplicate (RequestStartTimePolicy_ptr obj); + static RequestStartTimePolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RequestStartTimePolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RequestStartTimePolicy_ptr _nil (void) +@@ -726,7 +757,7 @@ + } + + virtual TimeBase::UtcT start_time ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -734,7 +765,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -748,6 +779,10 @@ + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_REQUEST_START_TIME_POLICY == 1 */ ++ ++#if (TAO_HAS_REQUEST_END_TIME_POLICY == 1) ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong REQUEST_END_TIME_POLICY_TYPE; + + +@@ -756,7 +791,7 @@ + + class RequestEndTimePolicy; + typedef RequestEndTimePolicy *RequestEndTimePolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -770,14 +805,14 @@ + RequestEndTimePolicy_var (RequestEndTimePolicy_ptr); + RequestEndTimePolicy_var (const RequestEndTimePolicy_var &); // copy constructor + ~RequestEndTimePolicy_var (void); // destructor +- ++ + RequestEndTimePolicy_var &operator= (RequestEndTimePolicy_ptr); + RequestEndTimePolicy_var &operator= (const RequestEndTimePolicy_var &); + RequestEndTimePolicy_ptr operator-> (void) const; +- ++ + operator const RequestEndTimePolicy_ptr &() const; + operator RequestEndTimePolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + RequestEndTimePolicy_ptr in (void) const; + RequestEndTimePolicy_ptr &inout (void); + RequestEndTimePolicy_ptr &out (void); +@@ -807,7 +842,7 @@ + operator RequestEndTimePolicy_ptr &(); + RequestEndTimePolicy_ptr &ptr (void); + RequestEndTimePolicy_ptr operator-> (void); +- ++ + private: + RequestEndTimePolicy_ptr &ptr_; + }; +@@ -819,7 +854,7 @@ + #if !defined (_MESSAGING_REQUESTENDTIMEPOLICY_CH_) + #define _MESSAGING_REQUESTENDTIMEPOLICY_CH_ + +-class TAO_Export RequestEndTimePolicy: public virtual CORBA::Policy ++ class TAO_Export RequestEndTimePolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -831,12 +866,12 @@ + static RequestEndTimePolicy_ptr _duplicate (RequestEndTimePolicy_ptr obj); + static RequestEndTimePolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RequestEndTimePolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RequestEndTimePolicy_ptr _nil (void) +@@ -845,7 +880,7 @@ + } + + virtual TimeBase::UtcT end_time ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -853,7 +888,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -867,6 +902,10 @@ + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_REQUEST_END_TIME_POLICY == 1 */ ++ ++#if (TAO_HAS_REPLY_START_TIME_POLICY == 1) ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong REPLY_START_TIME_POLICY_TYPE; + + +@@ -875,7 +914,7 @@ + + class ReplyStartTimePolicy; + typedef ReplyStartTimePolicy *ReplyStartTimePolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -889,14 +928,14 @@ + ReplyStartTimePolicy_var (ReplyStartTimePolicy_ptr); + ReplyStartTimePolicy_var (const ReplyStartTimePolicy_var &); // copy constructor + ~ReplyStartTimePolicy_var (void); // destructor +- ++ + ReplyStartTimePolicy_var &operator= (ReplyStartTimePolicy_ptr); + ReplyStartTimePolicy_var &operator= (const ReplyStartTimePolicy_var &); + ReplyStartTimePolicy_ptr operator-> (void) const; +- ++ + operator const ReplyStartTimePolicy_ptr &() const; + operator ReplyStartTimePolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + ReplyStartTimePolicy_ptr in (void) const; + ReplyStartTimePolicy_ptr &inout (void); + ReplyStartTimePolicy_ptr &out (void); +@@ -926,7 +965,7 @@ + operator ReplyStartTimePolicy_ptr &(); + ReplyStartTimePolicy_ptr &ptr (void); + ReplyStartTimePolicy_ptr operator-> (void); +- ++ + private: + ReplyStartTimePolicy_ptr &ptr_; + }; +@@ -938,7 +977,7 @@ + #if !defined (_MESSAGING_REPLYSTARTTIMEPOLICY_CH_) + #define _MESSAGING_REPLYSTARTTIMEPOLICY_CH_ + +-class TAO_Export ReplyStartTimePolicy: public virtual CORBA::Policy ++ class TAO_Export ReplyStartTimePolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -950,12 +989,12 @@ + static ReplyStartTimePolicy_ptr _duplicate (ReplyStartTimePolicy_ptr obj); + static ReplyStartTimePolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ReplyStartTimePolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ReplyStartTimePolicy_ptr _nil (void) +@@ -964,7 +1003,7 @@ + } + + virtual TimeBase::UtcT start_time ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -972,7 +1011,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -986,6 +1025,10 @@ + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_REPLY_START_TIME_POLICY == 1 */ ++ ++#if (TAO_HAS_REPLY_END_TIME_POLICY == 1) ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong REPLY_END_TIME_POLICY_TYPE; + + +@@ -994,7 +1037,7 @@ + + class ReplyEndTimePolicy; + typedef ReplyEndTimePolicy *ReplyEndTimePolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -1008,14 +1051,14 @@ + ReplyEndTimePolicy_var (ReplyEndTimePolicy_ptr); + ReplyEndTimePolicy_var (const ReplyEndTimePolicy_var &); // copy constructor + ~ReplyEndTimePolicy_var (void); // destructor +- ++ + ReplyEndTimePolicy_var &operator= (ReplyEndTimePolicy_ptr); + ReplyEndTimePolicy_var &operator= (const ReplyEndTimePolicy_var &); + ReplyEndTimePolicy_ptr operator-> (void) const; +- ++ + operator const ReplyEndTimePolicy_ptr &() const; + operator ReplyEndTimePolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + ReplyEndTimePolicy_ptr in (void) const; + ReplyEndTimePolicy_ptr &inout (void); + ReplyEndTimePolicy_ptr &out (void); +@@ -1045,7 +1088,7 @@ + operator ReplyEndTimePolicy_ptr &(); + ReplyEndTimePolicy_ptr &ptr (void); + ReplyEndTimePolicy_ptr operator-> (void); +- ++ + private: + ReplyEndTimePolicy_ptr &ptr_; + }; +@@ -1057,7 +1100,7 @@ + #if !defined (_MESSAGING_REPLYENDTIMEPOLICY_CH_) + #define _MESSAGING_REPLYENDTIMEPOLICY_CH_ + +-class TAO_Export ReplyEndTimePolicy: public virtual CORBA::Policy ++ class TAO_Export ReplyEndTimePolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -1069,12 +1112,12 @@ + static ReplyEndTimePolicy_ptr _duplicate (ReplyEndTimePolicy_ptr obj); + static ReplyEndTimePolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ReplyEndTimePolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ReplyEndTimePolicy_ptr _nil (void) +@@ -1083,7 +1126,7 @@ + } + + virtual TimeBase::UtcT end_time ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -1091,7 +1134,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -1105,6 +1148,10 @@ + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_REPLY_END_TIME_POLICY == 1 */ ++ ++#if (TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY == 1) ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong RELATIVE_REQ_TIMEOUT_POLICY_TYPE; + + +@@ -1113,7 +1160,7 @@ + + class RelativeRequestTimeoutPolicy; + typedef RelativeRequestTimeoutPolicy *RelativeRequestTimeoutPolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -1127,14 +1174,14 @@ + RelativeRequestTimeoutPolicy_var (RelativeRequestTimeoutPolicy_ptr); + RelativeRequestTimeoutPolicy_var (const RelativeRequestTimeoutPolicy_var &); // copy constructor + ~RelativeRequestTimeoutPolicy_var (void); // destructor +- ++ + RelativeRequestTimeoutPolicy_var &operator= (RelativeRequestTimeoutPolicy_ptr); + RelativeRequestTimeoutPolicy_var &operator= (const RelativeRequestTimeoutPolicy_var &); + RelativeRequestTimeoutPolicy_ptr operator-> (void) const; +- ++ + operator const RelativeRequestTimeoutPolicy_ptr &() const; + operator RelativeRequestTimeoutPolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + RelativeRequestTimeoutPolicy_ptr in (void) const; + RelativeRequestTimeoutPolicy_ptr &inout (void); + RelativeRequestTimeoutPolicy_ptr &out (void); +@@ -1164,7 +1211,7 @@ + operator RelativeRequestTimeoutPolicy_ptr &(); + RelativeRequestTimeoutPolicy_ptr &ptr (void); + RelativeRequestTimeoutPolicy_ptr operator-> (void); +- ++ + private: + RelativeRequestTimeoutPolicy_ptr &ptr_; + }; +@@ -1176,7 +1223,7 @@ + #if !defined (_MESSAGING_RELATIVEREQUESTTIMEOUTPOLICY_CH_) + #define _MESSAGING_RELATIVEREQUESTTIMEOUTPOLICY_CH_ + +-class TAO_Export RelativeRequestTimeoutPolicy: public virtual CORBA::Policy ++ class TAO_Export RelativeRequestTimeoutPolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -1188,12 +1235,12 @@ + static RelativeRequestTimeoutPolicy_ptr _duplicate (RelativeRequestTimeoutPolicy_ptr obj); + static RelativeRequestTimeoutPolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RelativeRequestTimeoutPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RelativeRequestTimeoutPolicy_ptr _nil (void) +@@ -1202,7 +1249,7 @@ + } + + virtual TimeBase::TimeT relative_expiry ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -1210,7 +1257,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -1224,6 +1271,10 @@ + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_RELATIVE_REQUEST_TIMEOUT_POLICY == 1 */ ++ ++#if (TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1) ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong RELATIVE_RT_TIMEOUT_POLICY_TYPE; + + +@@ -1232,7 +1283,7 @@ + + class RelativeRoundtripTimeoutPolicy; + typedef RelativeRoundtripTimeoutPolicy *RelativeRoundtripTimeoutPolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -1246,14 +1297,14 @@ + RelativeRoundtripTimeoutPolicy_var (RelativeRoundtripTimeoutPolicy_ptr); + RelativeRoundtripTimeoutPolicy_var (const RelativeRoundtripTimeoutPolicy_var &); // copy constructor + ~RelativeRoundtripTimeoutPolicy_var (void); // destructor +- ++ + RelativeRoundtripTimeoutPolicy_var &operator= (RelativeRoundtripTimeoutPolicy_ptr); + RelativeRoundtripTimeoutPolicy_var &operator= (const RelativeRoundtripTimeoutPolicy_var &); + RelativeRoundtripTimeoutPolicy_ptr operator-> (void) const; +- ++ + operator const RelativeRoundtripTimeoutPolicy_ptr &() const; + operator RelativeRoundtripTimeoutPolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + RelativeRoundtripTimeoutPolicy_ptr in (void) const; + RelativeRoundtripTimeoutPolicy_ptr &inout (void); + RelativeRoundtripTimeoutPolicy_ptr &out (void); +@@ -1283,7 +1334,7 @@ + operator RelativeRoundtripTimeoutPolicy_ptr &(); + RelativeRoundtripTimeoutPolicy_ptr &ptr (void); + RelativeRoundtripTimeoutPolicy_ptr operator-> (void); +- ++ + private: + RelativeRoundtripTimeoutPolicy_ptr &ptr_; + }; +@@ -1295,7 +1346,7 @@ + #if !defined (_MESSAGING_RELATIVEROUNDTRIPTIMEOUTPOLICY_CH_) + #define _MESSAGING_RELATIVEROUNDTRIPTIMEOUTPOLICY_CH_ + +-class TAO_Export RelativeRoundtripTimeoutPolicy: public virtual CORBA::Policy ++ class TAO_Export RelativeRoundtripTimeoutPolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -1307,12 +1358,12 @@ + static RelativeRoundtripTimeoutPolicy_ptr _duplicate (RelativeRoundtripTimeoutPolicy_ptr obj); + static RelativeRoundtripTimeoutPolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RelativeRoundtripTimeoutPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RelativeRoundtripTimeoutPolicy_ptr _nil (void) +@@ -1321,7 +1372,7 @@ + } + + virtual TimeBase::TimeT relative_expiry ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -1329,7 +1380,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -1343,11 +1394,15 @@ + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_RELATIVE_ROUNDTRIP_TIMEOUT_POLICY == 1 */ ++ ++#if (TAO_HAS_ROUTING_POLICY == 1) ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong ROUTING_POLICY_TYPE; + + struct RoutingTypeRange; + class RoutingTypeRange_var; +- ++ + struct TAO_Export RoutingTypeRange + { + +@@ -1369,18 +1424,18 @@ + RoutingTypeRange_var (const RoutingTypeRange_var &); // copy constructor + RoutingTypeRange_var (const RoutingTypeRange &); // fixed-size types only + ~RoutingTypeRange_var (void); // destructor +- ++ + RoutingTypeRange_var &operator= (RoutingTypeRange *); + RoutingTypeRange_var &operator= (const RoutingTypeRange_var &); + RoutingTypeRange_var &operator= (const RoutingTypeRange &); // fixed-size types only + RoutingTypeRange *operator-> (void); + const RoutingTypeRange *operator-> (void) const; +- ++ + operator const RoutingTypeRange &() const; + operator RoutingTypeRange &(); + operator RoutingTypeRange &() const; +- +- // in, inout, out, _retn ++ ++ // in, inout, out, _retn + const RoutingTypeRange &in (void) const; + RoutingTypeRange &inout (void); + RoutingTypeRange &out (void); +@@ -1401,7 +1456,7 @@ + + class RoutingPolicy; + typedef RoutingPolicy *RoutingPolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -1415,14 +1470,14 @@ + RoutingPolicy_var (RoutingPolicy_ptr); + RoutingPolicy_var (const RoutingPolicy_var &); // copy constructor + ~RoutingPolicy_var (void); // destructor +- ++ + RoutingPolicy_var &operator= (RoutingPolicy_ptr); + RoutingPolicy_var &operator= (const RoutingPolicy_var &); + RoutingPolicy_ptr operator-> (void) const; +- ++ + operator const RoutingPolicy_ptr &() const; + operator RoutingPolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + RoutingPolicy_ptr in (void) const; + RoutingPolicy_ptr &inout (void); + RoutingPolicy_ptr &out (void); +@@ -1452,7 +1507,7 @@ + operator RoutingPolicy_ptr &(); + RoutingPolicy_ptr &ptr (void); + RoutingPolicy_ptr operator-> (void); +- ++ + private: + RoutingPolicy_ptr &ptr_; + }; +@@ -1464,7 +1519,7 @@ + #if !defined (_MESSAGING_ROUTINGPOLICY_CH_) + #define _MESSAGING_ROUTINGPOLICY_CH_ + +-class TAO_Export RoutingPolicy: public virtual CORBA::Policy ++ class TAO_Export RoutingPolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -1476,12 +1531,12 @@ + static RoutingPolicy_ptr _duplicate (RoutingPolicy_ptr obj); + static RoutingPolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RoutingPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static RoutingPolicy_ptr _nil (void) +@@ -1490,7 +1545,7 @@ + } + + virtual Messaging::RoutingTypeRange routing_range ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -1498,7 +1553,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -1512,6 +1567,10 @@ + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_ROUTING_POLICY == 1 */ ++ ++#if (TAO_HAS_MAX_HOPS_POLICY == 1) ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong MAX_HOPS_POLICY_TYPE; + + +@@ -1520,7 +1579,7 @@ + + class MaxHopsPolicy; + typedef MaxHopsPolicy *MaxHopsPolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -1534,14 +1593,14 @@ + MaxHopsPolicy_var (MaxHopsPolicy_ptr); + MaxHopsPolicy_var (const MaxHopsPolicy_var &); // copy constructor + ~MaxHopsPolicy_var (void); // destructor +- ++ + MaxHopsPolicy_var &operator= (MaxHopsPolicy_ptr); + MaxHopsPolicy_var &operator= (const MaxHopsPolicy_var &); + MaxHopsPolicy_ptr operator-> (void) const; +- ++ + operator const MaxHopsPolicy_ptr &() const; + operator MaxHopsPolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + MaxHopsPolicy_ptr in (void) const; + MaxHopsPolicy_ptr &inout (void); + MaxHopsPolicy_ptr &out (void); +@@ -1571,7 +1630,7 @@ + operator MaxHopsPolicy_ptr &(); + MaxHopsPolicy_ptr &ptr (void); + MaxHopsPolicy_ptr operator-> (void); +- ++ + private: + MaxHopsPolicy_ptr &ptr_; + }; +@@ -1583,7 +1642,7 @@ + #if !defined (_MESSAGING_MAXHOPSPOLICY_CH_) + #define _MESSAGING_MAXHOPSPOLICY_CH_ + +-class TAO_Export MaxHopsPolicy: public virtual CORBA::Policy ++ class TAO_Export MaxHopsPolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -1595,12 +1654,12 @@ + static MaxHopsPolicy_ptr _duplicate (MaxHopsPolicy_ptr obj); + static MaxHopsPolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static MaxHopsPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static MaxHopsPolicy_ptr _nil (void) +@@ -1609,7 +1668,7 @@ + } + + virtual CORBA::UShort max_hops ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -1617,7 +1676,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -1631,6 +1690,10 @@ + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_MAX_HOPS_POLICY == 1 */ ++ ++#if (TAO_HAS_QUEUE_ORDER_POLICY == 1) ++ + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong QUEUE_ORDER_POLICY_TYPE; + + +@@ -1639,7 +1702,7 @@ + + class QueueOrderPolicy; + typedef QueueOrderPolicy *QueueOrderPolicy_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -1653,14 +1716,14 @@ + QueueOrderPolicy_var (QueueOrderPolicy_ptr); + QueueOrderPolicy_var (const QueueOrderPolicy_var &); // copy constructor + ~QueueOrderPolicy_var (void); // destructor +- ++ + QueueOrderPolicy_var &operator= (QueueOrderPolicy_ptr); + QueueOrderPolicy_var &operator= (const QueueOrderPolicy_var &); + QueueOrderPolicy_ptr operator-> (void) const; +- ++ + operator const QueueOrderPolicy_ptr &() const; + operator QueueOrderPolicy_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + QueueOrderPolicy_ptr in (void) const; + QueueOrderPolicy_ptr &inout (void); + QueueOrderPolicy_ptr &out (void); +@@ -1690,7 +1753,7 @@ + operator QueueOrderPolicy_ptr &(); + QueueOrderPolicy_ptr &ptr (void); + QueueOrderPolicy_ptr operator-> (void); +- ++ + private: + QueueOrderPolicy_ptr &ptr_; + }; +@@ -1702,7 +1765,7 @@ + #if !defined (_MESSAGING_QUEUEORDERPOLICY_CH_) + #define _MESSAGING_QUEUEORDERPOLICY_CH_ + +-class TAO_Export QueueOrderPolicy: public virtual CORBA::Policy ++ class TAO_Export QueueOrderPolicy: public virtual CORBA::Policy + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -1714,12 +1777,12 @@ + static QueueOrderPolicy_ptr _duplicate (QueueOrderPolicy_ptr obj); + static QueueOrderPolicy_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static QueueOrderPolicy_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static QueueOrderPolicy_ptr _nil (void) +@@ -1728,7 +1791,7 @@ + } + + virtual Messaging::Ordering allowed_orders ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -1736,7 +1799,7 @@ + )) = 0; + + virtual void *_tao_QueryInterface (ptr_arith_t type); +- ++ + virtual const char* _interface_repository_id (void) const; + + protected: +@@ -1750,9 +1813,11 @@ + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_QUEUE_ORDER_POLICY == 1 */ ++ + struct PolicyValue; + class PolicyValue_var; +- ++ + struct TAO_Export PolicyValue + { + +@@ -1769,25 +1834,25 @@ + + class _tao_seq_Octet; + class _tao_seq_Octet_var; +- ++ + // ************************************************************* + // _tao_seq_Octet + // ************************************************************* +- +- class TAO_Export _tao_seq_Octet : public ++ ++ class TAO_Export _tao_seq_Octet : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence<CORBA::Octet> + #else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence<CORBA::Octet> +-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ ++#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + _tao_seq_Octet (void); // default ctor + _tao_seq_Octet (CORBA::ULong max); // uses max size + _tao_seq_Octet ( +- CORBA::ULong max, +- CORBA::ULong length, +- CORBA::Octet *buffer, ++ CORBA::ULong max, ++ CORBA::ULong length, ++ CORBA::Octet *buffer, + CORBA::Boolean release=0 + ); + _tao_seq_Octet (const _tao_seq_Octet &); // copy ctor +@@ -1808,7 +1873,7 @@ + #endif /* TAO_NO_COPY_OCTET_SEQUENCE */ + + }; +- ++ + #endif /* end #if !defined */ + + +@@ -1827,19 +1892,19 @@ + _tao_seq_Octet_var (const _tao_seq_Octet_var &); // copy constructor + _tao_seq_Octet_var (const _tao_seq_Octet &); // fixed-size base types only + ~_tao_seq_Octet_var (void); // destructor +- ++ + _tao_seq_Octet_var &operator= (_tao_seq_Octet *); + _tao_seq_Octet_var &operator= (const _tao_seq_Octet_var &); + _tao_seq_Octet_var &operator= (const _tao_seq_Octet &); // fixed-size base types only + _tao_seq_Octet *operator-> (void); + const _tao_seq_Octet *operator-> (void) const; +- ++ + operator const _tao_seq_Octet &() const; + operator _tao_seq_Octet &(); + operator _tao_seq_Octet &() const; +- ++ + CORBA::Octet &operator[] (CORBA::ULong index); +- // in, inout, out, _retn ++ // in, inout, out, _retn + const _tao_seq_Octet &in (void) const; + _tao_seq_Octet &inout (void); + _tao_seq_Octet *&out (void); +@@ -1869,7 +1934,7 @@ + _tao_seq_Octet *&ptr (void); + _tao_seq_Octet *operator-> (void); + CORBA::Octet &operator[] (CORBA::ULong index); +- ++ + private: + _tao_seq_Octet *&ptr_; + // assignment from T_var not allowed +@@ -1893,18 +1958,18 @@ + PolicyValue_var (PolicyValue *); + PolicyValue_var (const PolicyValue_var &); // copy constructor + ~PolicyValue_var (void); // destructor +- ++ + PolicyValue_var &operator= (PolicyValue *); + PolicyValue_var &operator= (const PolicyValue_var &); + PolicyValue *operator-> (void); + const PolicyValue *operator-> (void) const; +- ++ + operator const PolicyValue &() const; + operator PolicyValue &(); + operator PolicyValue &() const; + operator PolicyValue *&(); // variable-size types only +- +- // in, inout, out, _retn ++ ++ // in, inout, out, _retn + const PolicyValue &in (void) const; + PolicyValue &inout (void); + PolicyValue *&out (void); +@@ -1926,7 +1991,7 @@ + operator PolicyValue *&(); + PolicyValue *&ptr (void); + PolicyValue *operator-> (void); +- ++ + private: + PolicyValue *&ptr_; + // assignment from T_var not allowed +@@ -1937,7 +2002,7 @@ + + + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) +- ++ + #if !defined (__TAO_UNBOUNDED_SEQUENCE_MESSAGING_POLICYVALUESEQ_CH_) + #define __TAO_UNBOUNDED_SEQUENCE_MESSAGING_POLICYVALUESEQ_CH_ + +@@ -1945,9 +2010,9 @@ + { + public: + // = Initialization and termination methods. +- ++ + _TAO_Unbounded_Sequence_Messaging_PolicyValueSeq (void); // Default constructor. +- _TAO_Unbounded_Sequence_Messaging_PolicyValueSeq (CORBA::ULong maximum); ++ _TAO_Unbounded_Sequence_Messaging_PolicyValueSeq (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_Messaging_PolicyValueSeq (CORBA::ULong maximum, + CORBA::ULong length, + PolicyValue *data, +@@ -1964,7 +2029,7 @@ + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) +- ++ + PolicyValue *get_buffer (CORBA::Boolean orphan = 0); + const PolicyValue *get_buffer (void) const; + void replace (CORBA::ULong max, +@@ -1976,32 +2041,32 @@ + #endif /* end #if !defined */ + + +-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +- ++#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ ++ + #if !defined (_MESSAGING_POLICYVALUESEQ_CH_) + #define _MESSAGING_POLICYVALUESEQ_CH_ + + class PolicyValueSeq; + class PolicyValueSeq_var; +- ++ + // ************************************************************* + // PolicyValueSeq + // ************************************************************* +- +- class TAO_Export PolicyValueSeq : public ++ ++ class TAO_Export PolicyValueSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_Messaging_PolicyValueSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence<PolicyValue> +-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ ++#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + PolicyValueSeq (void); // default ctor + PolicyValueSeq (CORBA::ULong max); // uses max size + PolicyValueSeq ( +- CORBA::ULong max, +- CORBA::ULong length, +- PolicyValue *buffer, ++ CORBA::ULong max, ++ CORBA::ULong length, ++ PolicyValue *buffer, + CORBA::Boolean release=0 + ); + PolicyValueSeq (const PolicyValueSeq &); // copy ctor +@@ -2013,7 +2078,7 @@ + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; +- ++ + #endif /* end #if !defined */ + + +@@ -2031,19 +2096,19 @@ + PolicyValueSeq_var (PolicyValueSeq *); + PolicyValueSeq_var (const PolicyValueSeq_var &); // copy constructor + ~PolicyValueSeq_var (void); // destructor +- ++ + PolicyValueSeq_var &operator= (PolicyValueSeq *); + PolicyValueSeq_var &operator= (const PolicyValueSeq_var &); + PolicyValueSeq *operator-> (void); + const PolicyValueSeq *operator-> (void) const; +- ++ + operator const PolicyValueSeq &() const; + operator PolicyValueSeq &(); + operator PolicyValueSeq &() const; + operator PolicyValueSeq *&(); // variable-size base types only +- ++ + PolicyValue &operator[] (CORBA::ULong index); +- // in, inout, out, _retn ++ // in, inout, out, _retn + const PolicyValueSeq &in (void) const; + PolicyValueSeq &inout (void); + PolicyValueSeq *&out (void); +@@ -2073,7 +2138,7 @@ + PolicyValueSeq *&ptr (void); + PolicyValueSeq *operator-> (void); + PolicyValue &operator[] (CORBA::ULong index); +- ++ + private: + PolicyValueSeq *&ptr_; + // assignment from T_var not allowed +@@ -2089,10 +2154,12 @@ + + TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong INVOCATION_POLICIES; + +-// valuetype class ++#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1) ++ ++ // valuetype class + class ExceptionHolder; + typedef ExceptionHolder *ExceptionHolder_ptr; +- ++ + #if !defined (_MESSAGING_EXCEPTIONHOLDER___VAR_CH_) + #define _MESSAGING_EXCEPTIONHOLDER___VAR_CH_ + +@@ -2104,14 +2171,14 @@ + ExceptionHolder_var (const ExceptionHolder*); // (TAO extension) + ExceptionHolder_var (const ExceptionHolder_var &); // copy constructor + ~ExceptionHolder_var (void); // destructor +- ++ + ExceptionHolder_var &operator= (ExceptionHolder*); + ExceptionHolder_var &operator= (const ExceptionHolder_var &); + ExceptionHolder* operator-> (void) const; +- ++ + operator const ExceptionHolder* () const; + operator ExceptionHolder* (); +- // in, inout, out, _retn ++ // in, inout, out, _retn + ExceptionHolder* in (void) const; + ExceptionHolder* &inout (void); + ExceptionHolder* &out (void); +@@ -2141,7 +2208,7 @@ + operator ExceptionHolder* &(); + ExceptionHolder* &ptr (void); + ExceptionHolder* operator-> (void); +- ++ + private: + ExceptionHolder* &ptr_; + }; +@@ -2160,7 +2227,7 @@ + virtual const char* tao_repository_id (); + + // create () goes here +- ++ + }; + + #endif /* end #if !defined */ +@@ -2197,25 +2264,25 @@ + + class _tao_seq_Octet; + class _tao_seq_Octet_var; +- ++ + // ************************************************************* + // _tao_seq_Octet + // ************************************************************* +- +- class TAO_Export _tao_seq_Octet : public ++ ++ class TAO_Export _tao_seq_Octet : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_Sequence<CORBA::Octet> + #else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence<CORBA::Octet> +-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ ++#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + _tao_seq_Octet (void); // default ctor + _tao_seq_Octet (CORBA::ULong max); // uses max size + _tao_seq_Octet ( +- CORBA::ULong max, +- CORBA::ULong length, +- CORBA::Octet *buffer, ++ CORBA::ULong max, ++ CORBA::ULong length, ++ CORBA::Octet *buffer, + CORBA::Boolean release=0 + ); + _tao_seq_Octet (const _tao_seq_Octet &); // copy ctor +@@ -2236,7 +2303,7 @@ + #endif /* TAO_NO_COPY_OCTET_SEQUENCE */ + + }; +- ++ + #endif /* end #if !defined */ + + +@@ -2255,19 +2322,19 @@ + _tao_seq_Octet_var (const _tao_seq_Octet_var &); // copy constructor + _tao_seq_Octet_var (const _tao_seq_Octet &); // fixed-size base types only + ~_tao_seq_Octet_var (void); // destructor +- ++ + _tao_seq_Octet_var &operator= (_tao_seq_Octet *); + _tao_seq_Octet_var &operator= (const _tao_seq_Octet_var &); + _tao_seq_Octet_var &operator= (const _tao_seq_Octet &); // fixed-size base types only + _tao_seq_Octet *operator-> (void); + const _tao_seq_Octet *operator-> (void) const; +- ++ + operator const _tao_seq_Octet &() const; + operator _tao_seq_Octet &(); + operator _tao_seq_Octet &() const; +- ++ + CORBA::Octet &operator[] (CORBA::ULong index); +- // in, inout, out, _retn ++ // in, inout, out, _retn + const _tao_seq_Octet &in (void) const; + _tao_seq_Octet &inout (void); + _tao_seq_Octet *&out (void); +@@ -2297,7 +2364,7 @@ + _tao_seq_Octet *&ptr (void); + _tao_seq_Octet *operator-> (void); + CORBA::Octet &operator[] (CORBA::ULong index); +- ++ + private: + _tao_seq_Octet *&ptr_; + // assignment from T_var not allowed +@@ -2324,26 +2391,25 @@ + virtual void *_tao_obv_narrow (ptr_arith_t); + virtual CORBA::Boolean _tao_marshal_v (TAO_OutputCDR &); + virtual CORBA::Boolean _tao_unmarshal_v (TAO_InputCDR &); +- ++ + private: + ExceptionHolder (const ExceptionHolder &); + void operator= (const ExceptionHolder &); +- ++ + protected: + virtual CORBA::Boolean _tao_marshal__Messaging_ExceptionHolder (TAO_OutputCDR &) = 0; + virtual CORBA::Boolean _tao_unmarshal__Messaging_ExceptionHolder (TAO_InputCDR &) = 0; +- ++ + }; + + #endif /* end #if !defined */ + +- + #if !defined (_MESSAGING_REPLYHANDLER___PTR_CH_) + #define _MESSAGING_REPLYHANDLER___PTR_CH_ + + class ReplyHandler; + typedef ReplyHandler *ReplyHandler_ptr; +- ++ + #endif /* end #if !defined */ + + +@@ -2357,14 +2423,14 @@ + ReplyHandler_var (ReplyHandler_ptr); + ReplyHandler_var (const ReplyHandler_var &); // copy constructor + ~ReplyHandler_var (void); // destructor +- ++ + ReplyHandler_var &operator= (ReplyHandler_ptr); + ReplyHandler_var &operator= (const ReplyHandler_var &); + ReplyHandler_ptr operator-> (void) const; +- ++ + operator const ReplyHandler_ptr &() const; + operator ReplyHandler_ptr &(); +- // in, inout, out, _retn ++ // in, inout, out, _retn + ReplyHandler_ptr in (void) const; + ReplyHandler_ptr &inout (void); + ReplyHandler_ptr &out (void); +@@ -2394,7 +2460,7 @@ + operator ReplyHandler_ptr &(); + ReplyHandler_ptr &ptr (void); + ReplyHandler_ptr operator-> (void); +- ++ + private: + ReplyHandler_ptr &ptr_; + }; +@@ -2406,7 +2472,7 @@ + #if !defined (_MESSAGING_REPLYHANDLER_CH_) + #define _MESSAGING_REPLYHANDLER_CH_ + +-class TAO_Export ReplyHandler : public virtual CORBA_Object ++ class TAO_Export ReplyHandler : public virtual CORBA_Object + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +@@ -2418,12 +2484,12 @@ + static ReplyHandler_ptr _duplicate (ReplyHandler_ptr obj); + static ReplyHandler_ptr _narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ReplyHandler_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + static ReplyHandler_ptr _nil (void) +@@ -2434,18 +2500,18 @@ + static void _tao_any_destructor (void*); + + 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; + + protected: + ReplyHandler (void); +- ReplyHandler (TAO_Stub *objref, +- TAO_ServantBase *_tao_servant = 0, ++ ReplyHandler (TAO_Stub *objref, ++ TAO_ServantBase *_tao_servant = 0, + CORBA::Boolean _tao_collocated = 0 + ); + virtual ~ReplyHandler (void); +@@ -2454,17 +2520,18 @@ + void operator= (const ReplyHandler &); + }; + ++#if (TAO_HAS_SMART_PROXIES == 1) + class TAO_Export TAO_Messaging_ReplyHandler_Default_Proxy_Factory + { + public: +- ++ + TAO_Messaging_ReplyHandler_Default_Proxy_Factory (int register_proxy_factory = 1); +- ++ + virtual ~TAO_Messaging_ReplyHandler_Default_Proxy_Factory (void); +- ++ + virtual ReplyHandler_ptr create_proxy ( + ReplyHandler_ptr proxy, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + }; +@@ -2472,26 +2539,26 @@ + class TAO_Export TAO_Messaging_ReplyHandler_Proxy_Factory_Adapter + { + public: +- ++ + friend class ACE_Singleton<TAO_Messaging_ReplyHandler_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>; +- ++ + int register_proxy_factory ( + TAO_Messaging_ReplyHandler_Default_Proxy_Factory *df, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- ++ + int unregister_proxy_factory ( +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- ++ + ReplyHandler_ptr create_proxy ( + ReplyHandler_ptr proxy, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- ++ + protected: + TAO_Messaging_ReplyHandler_Proxy_Factory_Adapter (void); + ~TAO_Messaging_ReplyHandler_Proxy_Factory_Adapter (void); +@@ -2501,11 +2568,11 @@ + TAO_Messaging_ReplyHandler_Default_Proxy_Factory *proxy_factory_; + int delete_proxy_factory_; + ACE_SYNCH_RECURSIVE_MUTEX lock_; +- ++ + }; + + typedef ACE_Singleton<TAO_Messaging_ReplyHandler_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_Messaging_ReplyHandler_PROXY_FACTORY_ADAPTER; +- ++ + class TAO_Export TAO_Messaging_ReplyHandler_Smart_Proxy_Base + : public virtual ReplyHandler, + public virtual TAO_Smart_Proxy_Base +@@ -2519,15 +2586,20 @@ + ::Messaging::ReplyHandler_var proxy_; + }; + ++#endif /* TAO_HAS_SMART_PROXIES */ + + #endif /* end #if !defined */ + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ReplyHandler; + ++#endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */ ++ ++#if (TAO_HAS_AMI_POLLER == 1) ++ + // valuetype class + class Poller; + typedef Poller *Poller_ptr; +- ++ + #if !defined (_MESSAGING_POLLER___VAR_CH_) + #define _MESSAGING_POLLER___VAR_CH_ + +@@ -2539,14 +2611,14 @@ + Poller_var (const Poller*); // (TAO extension) + Poller_var (const Poller_var &); // copy constructor + ~Poller_var (void); // destructor +- ++ + Poller_var &operator= (Poller*); + Poller_var &operator= (const Poller_var &); + Poller* operator-> (void) const; +- ++ + operator const Poller* () const; + operator Poller* (); +- // in, inout, out, _retn ++ // in, inout, out, _retn + Poller* in (void) const; + Poller* &inout (void); + Poller* &out (void); +@@ -2576,7 +2648,7 @@ + operator Poller* &(); + Poller* &ptr (void); + Poller* operator-> (void); +- ++ + private: + Poller* &ptr_; + }; +@@ -2595,7 +2667,7 @@ + virtual const char* tao_repository_id (); + + // create () goes here +- ++ + }; + + #endif /* end #if !defined */ +@@ -2620,16 +2692,16 @@ + virtual const char* _tao_obv_repository_id () const; + static const char* _tao_obv_static_repository_id (); + public: +- virtual CORBA::Object_ptr operation_target ( CORBA::Environment &ACE_TRY_ENV = ++ virtual CORBA::Object_ptr operation_target ( CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment ()) = 0; +- virtual char * operation_name ( CORBA::Environment &ACE_TRY_ENV = ++ virtual char * operation_name ( CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment ()) = 0; +- virtual Messaging::ReplyHandler_ptr associated_handler ( CORBA::Environment &ACE_TRY_ENV = ++ virtual Messaging::ReplyHandler_ptr associated_handler ( CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment ()) = 0; + virtual void associated_handler (Messaging::ReplyHandler_ptr, +- CORBA::Environment &ACE_TRY_ENV = ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment ()) = 0; +- virtual CORBA::Boolean is_from_poller ( CORBA::Environment &ACE_TRY_ENV = ++ virtual CORBA::Boolean is_from_poller ( CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment ()) = 0; + virtual void target (CORBA::Object_ptr) = 0; // set + virtual CORBA::Object_ptr target (void) const = 0; // get method +@@ -2648,23 +2720,26 @@ + virtual void *_tao_obv_narrow (ptr_arith_t); + virtual CORBA::Boolean _tao_marshal_v (TAO_OutputCDR &); + virtual CORBA::Boolean _tao_unmarshal_v (TAO_InputCDR &); +- ++ + private: + Poller (const Poller &); + void operator= (const Poller &); +- ++ + protected: + virtual CORBA::Boolean _tao_marshal__Messaging_Poller (TAO_OutputCDR &) = 0; + virtual CORBA::Boolean _tao_unmarshal__Messaging_Poller (TAO_InputCDR &) = 0; +- ++ + }; + + #endif /* end #if !defined */ + ++#endif /* TAO_HAS_AMI_POLLER == 1 */ + + } + TAO_NAMESPACE_CLOSE // module Messaging + ++#if (TAO_HAS_AMI_CALLBACK == 1) || (TAO_HAS_AMI_POLLER == 1) ++ + TAO_NAMESPACE OBV_Messaging + { + +@@ -2739,14 +2814,58 @@ + } + TAO_NAMESPACE_CLOSE + ++#endif /* TAO_HAS_AMI_CALLBACK == 1 || TAO_HAS_AMI_POLLER == 1 */ ++ ++// Typedef for the Reply Handler Skeleton. ++// This is handcrafted not generated by the IDL compiler. ++ ++class TAO_InputCDR; ++ ++enum TAO_AMI_Reply_Status ++{ ++ TAO_AMI_REPLY_OK, ++ // Reply is normal. ++ ++ TAO_AMI_REPLY_NOT_OK, ++ // Reply is not normal and no exceptions ++ ++ TAO_AMI_REPLY_USER_EXCEPTION, ++ // An user exception was raised. ++ ++ TAO_AMI_REPLY_SYSTEM_EXCEPTION ++ // An system exception was raised. ++}; ++ ++ ++#if (TAO_HAS_AMI_CALLBACK == 1) ++ ++typedef void (*TAO_Reply_Handler_Skeleton)( ++ TAO_InputCDR &, ++ Messaging::ReplyHandler *, ++ CORBA::ULong reply_status, ++ CORBA::Environment & ++ ); ++ ++#endif /* TAO_HAS_AMI_CALLBACK == 1 */ ++ ++#if (TAO_HAS_PRIORITY_POLICIES == 1) ++ + TAO_Export void operator<<= (CORBA::Any &, const Messaging::PriorityRange &); // copying version + TAO_Export void operator<<= (CORBA::Any &, Messaging::PriorityRange*); // noncopying version + TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::PriorityRange *&); // deprecated + TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const Messaging::PriorityRange *&); ++ ++#endif /* TAO_HAS_PRIORITY_POLICIES == 1 */ ++ ++#if (TAO_HAS_ROUTING_POLICY == 1) ++ + TAO_Export void operator<<= (CORBA::Any &, const Messaging::RoutingTypeRange &); // copying version + TAO_Export void operator<<= (CORBA::Any &, Messaging::RoutingTypeRange*); // noncopying version + TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::RoutingTypeRange *&); // deprecated + TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const Messaging::RoutingTypeRange *&); ++ ++#endif /* TAO_HAS_ROUTING_POLICY == 1 */ ++ + TAO_Export void operator<<= (CORBA::Any &, const Messaging::PolicyValue &); // copying version + TAO_Export void operator<<= (CORBA::Any &, Messaging::PolicyValue*); // noncopying version + TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::PolicyValue *&); // deprecated +@@ -2755,6 +2874,9 @@ + TAO_Export void operator<<= (CORBA::Any &, Messaging::PolicyValueSeq*); // noncopying version + TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::PolicyValueSeq *&); // deprecated + TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const Messaging::PolicyValueSeq *&); ++ ++#if (TAO_HAS_AMI_CALLBACK == 1) ++ + extern TAO_Export Messaging::ReplyHandler_ptr (*_TAO_collocation_Messaging_ReplyHandler_Stub_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +@@ -2762,15 +2884,26 @@ + TAO_Export void operator<<= (CORBA::Any &, Messaging::ReplyHandler_ptr); + TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, Messaging::ReplyHandler *&); + ++#endif /* TAO_HAS_AMI_CALLBACK */ ++ + #ifndef __ACE_INLINE__ + ++#if (TAO_HAS_PRIORITY_POLICIES == 1) ++ + TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::PriorityRange &); + TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::PriorityRange &); ++ ++#endif /* TAO_HAS_PRIORITY_POLICIES == 1 */ ++ ++#if (TAO_HAS_ROUTING_POLICY == 1) ++ + TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::RoutingTypeRange &); + TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::RoutingTypeRange &); + TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::PolicyValue &); + TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::PolicyValue &); + ++#endif /* TAO_HAS_ROUTING_POLICY == 1 */ ++ + #if !defined _TAO_CDR_OP_Messaging_PolicyValue__tao_seq_Octet_H_ + #define _TAO_CDR_OP_Messaging_PolicyValue__tao_seq_Octet_H_ + +@@ -2800,12 +2933,25 @@ + + #endif /* _TAO_CDR_OP_Messaging_PolicyValueSeq_H_ */ + +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ExceptionHolder *); // +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ExceptionHolder *&); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ExceptionHolder &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ExceptionHolder &); ++ ++#if !defined _TAO_CDR_OP_Messaging_ExceptionHolder__tao_seq_Octet_H_ ++#define _TAO_CDR_OP_Messaging_ExceptionHolder__tao_seq_Octet_H_ ++ ++TAO_Export CORBA::Boolean operator<< ( ++ TAO_OutputCDR &, ++ const Messaging::ExceptionHolder::_tao_seq_Octet & ++ ); ++TAO_Export CORBA::Boolean operator>> ( ++ TAO_InputCDR &, ++ Messaging::ExceptionHolder::_tao_seq_Octet & ++ ); ++ ++#endif /* _TAO_CDR_OP_Messaging_ExceptionHolder__tao_seq_Octet_H_ */ ++ + TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::ReplyHandler_ptr ); + TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::ReplyHandler_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const Messaging::Poller *); // +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, Messaging::Poller *&); + + #endif /* __ACE_INLINE__ */ + +@@ -2817,5 +2963,7 @@ + #if defined(_MSC_VER) && (_MSC_VER >= 1200) + #pragma warning(pop) + #endif /* _MSC_VER */ ++ ++#endif /* TAO_HAS_CORBA_MESSAGING */ + + #endif /* ifndef */ |