diff options
Diffstat (limited to 'TAO/tao/diffs/InterfaceC.h.diff')
| -rw-r--r-- | TAO/tao/diffs/InterfaceC.h.diff | 32149 |
1 files changed, 32149 insertions, 0 deletions
diff --git a/TAO/tao/diffs/InterfaceC.h.diff b/TAO/tao/diffs/InterfaceC.h.diff new file mode 100644 index 00000000000..96eed4623cc --- /dev/null +++ b/TAO/tao/diffs/InterfaceC.h.diff @@ -0,0 +1,32149 @@ +--- InterfaceC.h Fri Dec 01 16:26:23 2000 ++++ ..\..\..\tao\InterfaceC.h Mon Nov 27 19:25:21 2000 +@@ -1,6 +1,6 @@ + // -*- C++ -*- + // +-// $Id$ ++//$Id$ + + // **** Code generated by the The ACE ORB (TAO) IDL Compiler **** + // TAO and the TAO IDL Compiler have been developed by: +@@ -19,11 +19,21 @@ + // Information about TAO is available at: + // http://www.cs.wustl.edu/~schmidt/TAO.html + +-#ifndef _TAO_IDL_INTERFACEC_H_ +-#define _TAO_IDL_INTERFACEC_H_ +- ++#ifndef TAO_IDL_INTERFACEC_H ++#define TAO_IDL_INTERFACEC_H + #include "ace/pre.h" +-#include "tao/corba.h" ++ ++#include "tao/TAO_Singleton.h" ++#include "tao/corbafwd.h" ++#include "tao/ifrfwd.h" ++#include "tao/Any.h" ++#include "tao/Object.h" ++#include "tao/Managed_Types.h" ++#include "tao/Sequence.h" ++#include "tao/Typecode.h" ++#include "tao/Remote_Object_Proxy_Impl.h" ++ ++#if (TAO_HAS_INTERFACE_REPOSITORY == 1) + + #if !defined (ACE_LACKS_PRAGMA_ONCE) + # pragma once +@@ -49,160 +59,122 @@ + #pragma warning(disable:4250) + #endif /* _MSC_VER */ + +-TAO_NAMESPACE IR +-{ +- enum DefinitionKind ++enum IR_DefinitionKind + { +- dk_none, +- dk_all, +- dk_Attribute, +- dk_Constant, +- dk_Exception, +- dk_Interface, +- dk_Module, +- dk_Operation, +- dk_Typedef, +- dk_Alias, +- dk_Struct, +- dk_Union, +- dk_Enum, +- dk_Primitive, +- dk_String, +- dk_Sequence, +- dk_Array, +- dk_Repository, +- dk_Wstring, +- dk_Fixed, +- dk_Value, +- dk_ValueBox, +- dk_ValueMember, +- dk_Native, +- dk_Component, +- dk_Home, +- dk_Factory, +- dk_Finder, +- dk_PrimaryKey, +- dk_Emits, +- dk_Publishes, +- dk_Consumes, +- dk_Provides, +- dk_Uses ++ dk_none, ++ dk_all, ++ dk_Attribute, ++ dk_Constant, ++ dk_Exception, ++ dk_Interface, ++ dk_Module, ++ dk_Operation, ++ dk_Typedef, ++ dk_Alias, ++ dk_Struct, ++ dk_Union, ++ dk_Enum, ++ dk_Primitive, ++ dk_String, ++ dk_Sequence, ++ dk_Array, ++ dk_Repository, ++ dk_Wstring, ++ dk_Fixed, ++ dk_Value, ++ dk_ValueBox, ++ dk_ValueMember, ++ dk_Native, ++ dk_Component, ++ dk_Home, ++ dk_Factory, ++ dk_Finder, ++ dk_PrimaryKey, ++ dk_Emits, ++ dk_Publishes, ++ dk_Consumes, ++ dk_Provides, ++ dk_Uses + }; +- typedef DefinitionKind &DefinitionKind_out; +- TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_DefinitionKind; +- +- +-} +-TAO_NAMESPACE_CLOSE // module IR +- +-TAO_NAMESPACE CORBA +-{ + +-#if !defined (_TAO_CORBA_IROBJECT___PTR_CH_) +-#define _TAO_CORBA_IROBJECT___PTR_CH_ +- +- class IRObject; +- typedef IRObject *IRObject_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_CORBA_IROBJECT___VAR_CH_) +-#define _TAO_CORBA_IROBJECT___VAR_CH_ +- +- class TAO_Export IRObject_var : public TAO_Base_var ++ class TAO_Export CORBA_IRObject_var : public TAO_Base_var + { + public: +- IRObject_var (void); // default constructor +- IRObject_var (IRObject_ptr p) : ptr_ (p) {} +- IRObject_var (const IRObject_var &); // copy constructor +- ~IRObject_var (void); // destructor +- +- IRObject_var &operator= (IRObject_ptr); +- IRObject_var &operator= (const IRObject_var &); +- IRObject_ptr operator-> (void) const; ++ CORBA_IRObject_var (void); // default constructor ++ CORBA_IRObject_var (CORBA_IRObject_ptr p) : ptr_ (p) {} ++ CORBA_IRObject_var (const CORBA_IRObject_var &); // copy constructor ++ ~CORBA_IRObject_var (void); // destructor ++ ++ CORBA_IRObject_var &operator= (CORBA_IRObject_ptr); ++ CORBA_IRObject_var &operator= (const CORBA_IRObject_var &); ++ CORBA_IRObject_ptr operator-> (void) const; + +- operator const IRObject_ptr &() const; +- operator IRObject_ptr &(); ++ operator const CORBA_IRObject_ptr &() const; ++ operator CORBA_IRObject_ptr &(); + // in, inout, out, _retn +- IRObject_ptr in (void) const; +- IRObject_ptr &inout (void); +- IRObject_ptr &out (void); +- IRObject_ptr _retn (void); +- IRObject_ptr ptr (void) const; ++ CORBA_IRObject_ptr in (void) const; ++ CORBA_IRObject_ptr &inout (void); ++ CORBA_IRObject_ptr &out (void); ++ CORBA_IRObject_ptr _retn (void); ++ CORBA_IRObject_ptr ptr (void) const; + + private: +- IRObject_ptr ptr_; ++ CORBA_IRObject_ptr ptr_; + // Unimplemented - prevents widening assignment. +- IRObject_var (const TAO_Base_var &rhs); +- IRObject_var &operator= (const TAO_Base_var &rhs); ++ CORBA_IRObject_var (const TAO_Base_var &rhs); ++ CORBA_IRObject_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_CORBA_IROBJECT___OUT_CH_) +-#define _TAO_CORBA_IROBJECT___OUT_CH_ +- +- class TAO_Export IRObject_out ++ class TAO_Export CORBA_IRObject_out + { + public: +- IRObject_out (IRObject_ptr &); +- IRObject_out (IRObject_var &); +- IRObject_out (const IRObject_out &); +- IRObject_out &operator= (const IRObject_out &); +- IRObject_out &operator= (const IRObject_var &); +- IRObject_out &operator= (IRObject_ptr); +- operator IRObject_ptr &(); +- IRObject_ptr &ptr (void); +- IRObject_ptr operator-> (void); ++ CORBA_IRObject_out (CORBA_IRObject_ptr &); ++ CORBA_IRObject_out (CORBA_IRObject_var &); ++ CORBA_IRObject_out (const CORBA_IRObject_out &); ++ CORBA_IRObject_out &operator= (const CORBA_IRObject_out &); ++ CORBA_IRObject_out &operator= (const CORBA_IRObject_var &); ++ CORBA_IRObject_out &operator= (CORBA_IRObject_ptr); ++ operator CORBA_IRObject_ptr &(); ++ CORBA_IRObject_ptr &ptr (void); ++ CORBA_IRObject_ptr operator-> (void); + + private: +- IRObject_ptr &ptr_; ++ CORBA_IRObject_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_CORBA_IROBJECT_CH_) +-#define _TAO_CORBA_IROBJECT_CH_ +- +-// Forward Classes Declaration + class _TAO_IRObject_Proxy_Impl; + class _TAO_IRObject_Remote_Proxy_Impl; + class _TAO_IRObject_Proxy_Broker; + class _TAO_IRObject_Remote_Proxy_Broker; + +- class TAO_Export IRObject : public virtual CORBA_Object ++ class TAO_Export CORBA_IRObject : public virtual CORBA_Object + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef IRObject_ptr _ptr_type; +- typedef IRObject_var _var_type; ++ typedef CORBA_IRObject_ptr _ptr_type; ++ typedef CORBA_IRObject_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static IRObject_ptr _duplicate (IRObject_ptr obj); +- static IRObject_ptr _narrow ( ++ static CORBA_IRObject_ptr _duplicate (CORBA_IRObject_ptr obj); ++ static CORBA_IRObject_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static IRObject_ptr _unchecked_narrow ( ++ static CORBA_IRObject_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static IRObject_ptr _nil (void) ++ static CORBA_IRObject_ptr _nil (void) + { +- return (IRObject_ptr)0; ++ return (CORBA_IRObject_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::DefinitionKind def_kind ( ++ virtual IR_DefinitionKind def_kind ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -212,7 +184,7 @@ + + virtual void destroy ( + CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () ++ TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException +@@ -231,120 +203,28 @@ + _TAO_IRObject_Proxy_Broker *the_TAO_IRObject_Proxy_Broker_; + + protected: +- IRObject (int collocated = 0); ++ CORBA_IRObject (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++ protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- IRObject ( ++ CORBA_IRObject ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_IRObject_Remote_Proxy_Impl; +- friend class _TAO_IRObject_ThruPOA_Proxy_Impl; +- friend class _TAO_IRObject_Direct_Proxy_Impl; +- +- virtual ~IRObject (void); +- private: +- IRObject (const IRObject &); +- void operator= (const IRObject &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get : public TAO_ClientRequestInfo +- { +- public: +- friend class CORBA::IRObject; +- +- friend class _TAO_IRObject_Remote_Proxy_Impl; +- friend class _TAO_IRObject_ThruPOA_Proxy_Impl; +- friend class _TAO_IRObject_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get (const TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get &); +- void operator= (const TAO_ClientRequestInfo_CORBA_IRObject_def_kind_get &); +- void result (IR::DefinitionKind result); +- // update the result +- IR::DefinitionKind result_; +- }; +- +- class TAO_ClientRequestInfo_CORBA_IRObject_destroy : public TAO_ClientRequestInfo +- { +- public: +- friend class CORBA::IRObject; +- +- friend class _TAO_IRObject_Remote_Proxy_Impl; +- friend class _TAO_IRObject_ThruPOA_Proxy_Impl; +- friend class _TAO_IRObject_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_CORBA_IRObject_destroy ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); ++ ++ friend class _TAO_IRObject_Remote_Proxy_Impl; ++ friend class _TAO_IRObject_ThruPOA_Proxy_Impl; ++ friend class _TAO_IRObject_Direct_Proxy_Impl; + +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~CORBA_IRObject (void); + private: +- TAO_ClientRequestInfo_CORBA_IRObject_destroy (const TAO_ClientRequestInfo_CORBA_IRObject_destroy &); +- void operator= (const TAO_ClientRequestInfo_CORBA_IRObject_destroy &); +- ++ CORBA_IRObject (const CORBA_IRObject &); ++ void operator= (const CORBA_IRObject &); + }; +- +- #endif /* TAO_HAS_INTERCEPTORS */ +- +-}; + + + // The Proxy Implementations are used by each interface to +@@ -361,7 +241,7 @@ + public: + virtual ~_TAO_IRObject_Proxy_Impl (void) { } + +- virtual IR::DefinitionKind def_kind ( ++ virtual IR_DefinitionKind def_kind ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -381,6 +261,7 @@ + _TAO_IRObject_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -399,7 +280,7 @@ + + virtual ~_TAO_IRObject_Remote_Proxy_Impl (void) { } + +- virtual IR::DefinitionKind def_kind ( ++ virtual IR_DefinitionKind def_kind ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -437,8 +318,9 @@ + { + public: + virtual ~_TAO_IRObject_Proxy_Broker (void); ++ + virtual _TAO_IRObject_Proxy_Impl &select_proxy ( +- IRObject *object, ++ CORBA_IRObject *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -463,9 +345,9 @@ + _TAO_IRObject_Remote_Proxy_Broker (void); + + virtual ~_TAO_IRObject_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_IRObject_Proxy_Impl &select_proxy ( +- IRObject *object, ++ CORBA_IRObject *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -479,355 +361,175 @@ + static _TAO_IRObject_Remote_Proxy_Broker *the_TAO_IRObject_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + + +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IRObject; +- +-typedef CORBA::Short Visibility; +-typedef CORBA::Short_out Visibility_out; +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Visibility; +- +-TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short PRIVATE_MEMBER; +- +-TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short PUBLIC_MEMBER; +- +- +-} +-TAO_NAMESPACE_CLOSE // module CORBA +- +-TAO_NAMESPACE IR +-{ +- typedef char * Identifier; +- typedef CORBA::String_var Identifier_var; +- typedef CORBA::String_out Identifier_out; +- TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Identifier; +- +- typedef char * ScopedName; +- typedef CORBA::String_var ScopedName_var; +- typedef CORBA::String_out ScopedName_out; +- TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ScopedName; +- +- typedef char * RepositoryId; +- typedef CORBA::String_var RepositoryId_var; +- typedef CORBA::String_out RepositoryId_out; +- TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RepositoryId; +- +- typedef char * VersionSpec; +- typedef CORBA::String_var VersionSpec_var; +- typedef CORBA::String_out VersionSpec_out; +- TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_VersionSpec; +- +- class Contained; +- +-#if !defined (_TAO_IR_CONTAINED___PTR_CH_) +-#define _TAO_IR_CONTAINED___PTR_CH_ +- +-typedef Contained *Contained_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINED___VAR_CH_) +-#define _TAO_IR_CONTAINED___VAR_CH_ +- +- class TAO_Export Contained_var : public TAO_Base_var +- { +- public: +- Contained_var (void); // default constructor +- Contained_var (Contained_ptr p) : ptr_ (p) {} +- Contained_var (const Contained_var &); // copy constructor +- ~Contained_var (void); // destructor +- +- Contained_var &operator= (Contained_ptr); +- Contained_var &operator= (const Contained_var &); +- Contained_ptr operator-> (void) const; +- +- operator const Contained_ptr &() const; +- operator Contained_ptr &(); +- // in, inout, out, _retn +- Contained_ptr in (void) const; +- Contained_ptr &inout (void); +- Contained_ptr &out (void); +- Contained_ptr _retn (void); +- Contained_ptr ptr (void) const; +- +- private: +- Contained_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- Contained_var (const TAO_Base_var &rhs); +- Contained_var &operator= (const TAO_Base_var &rhs); +- }; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINED___OUT_CH_) +-#define _TAO_IR_CONTAINED___OUT_CH_ +- +- class TAO_Export Contained_out +- { +- public: +- Contained_out (Contained_ptr &); +- Contained_out (Contained_var &); +- Contained_out (const Contained_out &); +- Contained_out &operator= (const Contained_out &); +- Contained_out &operator= (const Contained_var &); +- Contained_out &operator= (Contained_ptr); +- operator Contained_ptr &(); +- Contained_ptr &ptr (void); +- Contained_ptr operator-> (void); +- +- private: +- Contained_ptr &ptr_; +- }; +- +- +-#endif /* end #if !defined */ +- +- class Repository; +- +-#if !defined (_TAO_IR_REPOSITORY___PTR_CH_) +-#define _TAO_IR_REPOSITORY___PTR_CH_ +- +-typedef Repository *Repository_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_REPOSITORY___VAR_CH_) +-#define _TAO_IR_REPOSITORY___VAR_CH_ +- +- class TAO_Export Repository_var : public TAO_Base_var ++ class TAO_Export IR_Contained_var : public TAO_Base_var + { + public: +- Repository_var (void); // default constructor +- Repository_var (Repository_ptr p) : ptr_ (p) {} +- Repository_var (const Repository_var &); // copy constructor +- ~Repository_var (void); // destructor +- +- Repository_var &operator= (Repository_ptr); +- Repository_var &operator= (const Repository_var &); +- Repository_ptr operator-> (void) const; ++ IR_Contained_var (void); // default constructor ++ IR_Contained_var (IR_Contained_ptr p) : ptr_ (p) {} ++ IR_Contained_var (const IR_Contained_var &); // copy constructor ++ ~IR_Contained_var (void); // destructor ++ ++ IR_Contained_var &operator= (IR_Contained_ptr); ++ IR_Contained_var &operator= (const IR_Contained_var &); ++ IR_Contained_ptr operator-> (void) const; + +- operator const Repository_ptr &() const; +- operator Repository_ptr &(); ++ operator const IR_Contained_ptr &() const; ++ operator IR_Contained_ptr &(); + // in, inout, out, _retn +- Repository_ptr in (void) const; +- Repository_ptr &inout (void); +- Repository_ptr &out (void); +- Repository_ptr _retn (void); +- Repository_ptr ptr (void) const; ++ IR_Contained_ptr in (void) const; ++ IR_Contained_ptr &inout (void); ++ IR_Contained_ptr &out (void); ++ IR_Contained_ptr _retn (void); ++ IR_Contained_ptr ptr (void) const; + + private: +- Repository_ptr ptr_; ++ IR_Contained_ptr ptr_; + // Unimplemented - prevents widening assignment. +- Repository_var (const TAO_Base_var &rhs); +- Repository_var &operator= (const TAO_Base_var &rhs); ++ IR_Contained_var (const TAO_Base_var &rhs); ++ IR_Contained_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_REPOSITORY___OUT_CH_) +-#define _TAO_IR_REPOSITORY___OUT_CH_ +- +- class TAO_Export Repository_out ++ class TAO_Export IR_Contained_out + { + public: +- Repository_out (Repository_ptr &); +- Repository_out (Repository_var &); +- Repository_out (const Repository_out &); +- Repository_out &operator= (const Repository_out &); +- Repository_out &operator= (const Repository_var &); +- Repository_out &operator= (Repository_ptr); +- operator Repository_ptr &(); +- Repository_ptr &ptr (void); +- Repository_ptr operator-> (void); ++ IR_Contained_out (IR_Contained_ptr &); ++ IR_Contained_out (IR_Contained_var &); ++ IR_Contained_out (const IR_Contained_out &); ++ IR_Contained_out &operator= (const IR_Contained_out &); ++ IR_Contained_out &operator= (const IR_Contained_var &); ++ IR_Contained_out &operator= (IR_Contained_ptr); ++ operator IR_Contained_ptr &(); ++ IR_Contained_ptr &ptr (void); ++ IR_Contained_ptr operator-> (void); + + private: +- Repository_ptr &ptr_; ++ IR_Contained_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- class Container; +- +-#if !defined (_TAO_IR_CONTAINER___PTR_CH_) +-#define _TAO_IR_CONTAINER___PTR_CH_ +- +-typedef Container *Container_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINER___VAR_CH_) +-#define _TAO_IR_CONTAINER___VAR_CH_ +- +- class TAO_Export Container_var : public TAO_Base_var ++ class TAO_Export IR_Repository_var : public TAO_Base_var + { + public: +- Container_var (void); // default constructor +- Container_var (Container_ptr p) : ptr_ (p) {} +- Container_var (const Container_var &); // copy constructor +- ~Container_var (void); // destructor +- +- Container_var &operator= (Container_ptr); +- Container_var &operator= (const Container_var &); +- Container_ptr operator-> (void) const; ++ IR_Repository_var (void); // default constructor ++ IR_Repository_var (IR_Repository_ptr p) : ptr_ (p) {} ++ IR_Repository_var (const IR_Repository_var &); // copy constructor ++ ~IR_Repository_var (void); // destructor ++ ++ IR_Repository_var &operator= (IR_Repository_ptr); ++ IR_Repository_var &operator= (const IR_Repository_var &); ++ IR_Repository_ptr operator-> (void) const; + +- operator const Container_ptr &() const; +- operator Container_ptr &(); ++ operator const IR_Repository_ptr &() const; ++ operator IR_Repository_ptr &(); + // in, inout, out, _retn +- Container_ptr in (void) const; +- Container_ptr &inout (void); +- Container_ptr &out (void); +- Container_ptr _retn (void); +- Container_ptr ptr (void) const; ++ IR_Repository_ptr in (void) const; ++ IR_Repository_ptr &inout (void); ++ IR_Repository_ptr &out (void); ++ IR_Repository_ptr _retn (void); ++ IR_Repository_ptr ptr (void) const; + + private: +- Container_ptr ptr_; ++ IR_Repository_ptr ptr_; + // Unimplemented - prevents widening assignment. +- Container_var (const TAO_Base_var &rhs); +- Container_var &operator= (const TAO_Base_var &rhs); ++ IR_Repository_var (const TAO_Base_var &rhs); ++ IR_Repository_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINER___OUT_CH_) +-#define _TAO_IR_CONTAINER___OUT_CH_ +- +- class TAO_Export Container_out ++ class TAO_Export IR_Repository_out + { + public: +- Container_out (Container_ptr &); +- Container_out (Container_var &); +- Container_out (const Container_out &); +- Container_out &operator= (const Container_out &); +- Container_out &operator= (const Container_var &); +- Container_out &operator= (Container_ptr); +- operator Container_ptr &(); +- Container_ptr &ptr (void); +- Container_ptr operator-> (void); ++ IR_Repository_out (IR_Repository_ptr &); ++ IR_Repository_out (IR_Repository_var &); ++ IR_Repository_out (const IR_Repository_out &); ++ IR_Repository_out &operator= (const IR_Repository_out &); ++ IR_Repository_out &operator= (const IR_Repository_var &); ++ IR_Repository_out &operator= (IR_Repository_ptr); ++ operator IR_Repository_ptr &(); ++ IR_Repository_ptr &ptr (void); ++ IR_Repository_ptr operator-> (void); + + private: +- Container_ptr &ptr_; ++ IR_Repository_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINED___PTR_CH_) +-#define _TAO_IR_CONTAINED___PTR_CH_ +- +- class Contained; +- typedef Contained *Contained_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINED___VAR_CH_) +-#define _TAO_IR_CONTAINED___VAR_CH_ +- +- class TAO_Export Contained_var : public TAO_Base_var ++ class TAO_Export IR_Container_var : public TAO_Base_var + { + public: +- Contained_var (void); // default constructor +- Contained_var (Contained_ptr p) : ptr_ (p) {} +- Contained_var (const Contained_var &); // copy constructor +- ~Contained_var (void); // destructor +- +- Contained_var &operator= (Contained_ptr); +- Contained_var &operator= (const Contained_var &); +- Contained_ptr operator-> (void) const; ++ IR_Container_var (void); // default constructor ++ IR_Container_var (IR_Container_ptr p) : ptr_ (p) {} ++ IR_Container_var (const IR_Container_var &); // copy constructor ++ ~IR_Container_var (void); // destructor ++ ++ IR_Container_var &operator= (IR_Container_ptr); ++ IR_Container_var &operator= (const IR_Container_var &); ++ IR_Container_ptr operator-> (void) const; + +- operator const Contained_ptr &() const; +- operator Contained_ptr &(); ++ operator const IR_Container_ptr &() const; ++ operator IR_Container_ptr &(); + // in, inout, out, _retn +- Contained_ptr in (void) const; +- Contained_ptr &inout (void); +- Contained_ptr &out (void); +- Contained_ptr _retn (void); +- Contained_ptr ptr (void) const; ++ IR_Container_ptr in (void) const; ++ IR_Container_ptr &inout (void); ++ IR_Container_ptr &out (void); ++ IR_Container_ptr _retn (void); ++ IR_Container_ptr ptr (void) const; + + private: +- Contained_ptr ptr_; ++ IR_Container_ptr ptr_; + // Unimplemented - prevents widening assignment. +- Contained_var (const TAO_Base_var &rhs); +- Contained_var &operator= (const TAO_Base_var &rhs); ++ IR_Container_var (const TAO_Base_var &rhs); ++ IR_Container_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINED___OUT_CH_) +-#define _TAO_IR_CONTAINED___OUT_CH_ +- +- class TAO_Export Contained_out ++ class TAO_Export IR_Container_out + { + public: +- Contained_out (Contained_ptr &); +- Contained_out (Contained_var &); +- Contained_out (const Contained_out &); +- Contained_out &operator= (const Contained_out &); +- Contained_out &operator= (const Contained_var &); +- Contained_out &operator= (Contained_ptr); +- operator Contained_ptr &(); +- Contained_ptr &ptr (void); +- Contained_ptr operator-> (void); ++ IR_Container_out (IR_Container_ptr &); ++ IR_Container_out (IR_Container_var &); ++ IR_Container_out (const IR_Container_out &); ++ IR_Container_out &operator= (const IR_Container_out &); ++ IR_Container_out &operator= (const IR_Container_var &); ++ IR_Container_out &operator= (IR_Container_ptr); ++ operator IR_Container_ptr &(); ++ IR_Container_ptr &ptr (void); ++ IR_Container_ptr operator-> (void); + + private: +- Contained_ptr &ptr_; ++ IR_Container_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINED_CH_) +-#define _TAO_IR_CONTAINED_CH_ +- + // Forward Classes Declaration + class _TAO_Contained_Proxy_Impl; + class _TAO_Contained_Remote_Proxy_Impl; + class _TAO_Contained_Proxy_Broker; + class _TAO_Contained_Remote_Proxy_Broker; + +- class TAO_Export Contained: public virtual CORBA::IRObject ++ class TAO_Export IR_Contained: public virtual CORBA_IRObject + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef Contained_ptr _ptr_type; +- typedef Contained_var _var_type; ++ typedef IR_Contained_ptr _ptr_type; ++ typedef IR_Contained_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static Contained_ptr _duplicate (Contained_ptr obj); +- static Contained_ptr _narrow ( ++ static IR_Contained_ptr _duplicate (IR_Contained_ptr obj); ++ static IR_Contained_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static Contained_ptr _unchecked_narrow ( ++ static IR_Contained_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static Contained_ptr _nil (void) ++ static IR_Contained_ptr _nil (void) + { +- return (Contained_ptr)0; ++ return (IR_Contained_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -883,7 +585,7 @@ + CORBA::SystemException + )); + +- virtual IR::Container_ptr defined_in ( ++ virtual IR_Container_ptr defined_in ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -899,7 +601,7 @@ + CORBA::SystemException + )); + +- virtual IR::Repository_ptr containing_repository ( ++ virtual IR_Repository_ptr containing_repository ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -919,7 +621,7 @@ + + static void _tao_any_destructor (void*); + +- ACE_NESTED_CLASS (IR, DefinitionKind) kind; ++ IR_DefinitionKind kind; + CORBA::Any value; + }; + +@@ -972,8 +674,8 @@ + + static CORBA::TypeCode_ptr _tc_Description; + +- virtual IR::Contained::Description * describe ( +- CORBA::Environment &ACE_TRY_ENV = ++ virtual IR_Contained::Description * describe ( ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -981,7 +683,7 @@ + )); + + virtual void move ( +- IR::Container_ptr new_container, ++ IR_Container_ptr new_container, + const char * new_name, + const char * new_version, + CORBA::Environment &ACE_TRY_ENV = +@@ -1004,554 +706,70 @@ + _TAO_Contained_Proxy_Broker *the_TAO_Contained_Proxy_Broker_; + + protected: +- Contained (int collocated = 0); ++ IR_Contained (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++ protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- Contained ( ++ IR_Contained ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_Contained_Remote_Proxy_Impl; +- friend class _TAO_Contained_ThruPOA_Proxy_Impl; +- friend class _TAO_Contained_Direct_Proxy_Impl; +- +- virtual ~Contained (void); +- private: +- Contained (const Contained &); +- void operator= (const Contained &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_Contained_id_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::Contained; +- +- friend class _TAO_Contained_Remote_Proxy_Impl; +- friend class _TAO_Contained_ThruPOA_Proxy_Impl; +- friend class _TAO_Contained_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_Contained_id_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_Contained_id_get (const TAO_ClientRequestInfo_IR_Contained_id_get &); +- void operator= (const TAO_ClientRequestInfo_IR_Contained_id_get &); +- void result (char * result); +- // update the result +- char * result_; +- }; +- +- class TAO_ClientRequestInfo_IR_Contained_id_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::Contained; +- +- friend class _TAO_Contained_Remote_Proxy_Impl; +- friend class _TAO_Contained_ThruPOA_Proxy_Impl; +- friend class _TAO_Contained_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_Contained_id_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_Contained_id_set (const TAO_ClientRequestInfo_IR_Contained_id_set &); +- void operator= (const TAO_ClientRequestInfo_IR_Contained_id_set &); +- const char * id_; +- +- }; +- +- class TAO_ClientRequestInfo_IR_Contained_name_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::Contained; +- ++ + friend class _TAO_Contained_Remote_Proxy_Impl; + friend class _TAO_Contained_ThruPOA_Proxy_Impl; + friend class _TAO_Contained_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_Contained_name_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Contained_name_get (const TAO_ClientRequestInfo_IR_Contained_name_get &); +- void operator= (const TAO_ClientRequestInfo_IR_Contained_name_get &); +- void result (char * result); +- // update the result +- char * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Contained_name_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Contained; +- +- friend class _TAO_Contained_Remote_Proxy_Impl; +- friend class _TAO_Contained_ThruPOA_Proxy_Impl; +- friend class _TAO_Contained_Direct_Proxy_Impl; ++ ++ virtual ~IR_Contained (void); ++ private: ++ IR_Contained (const IR_Contained &); ++ void operator= (const IR_Contained &); + +-TAO_ClientRequestInfo_IR_Contained_name_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * name, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); ++ }; + +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); + +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++// The Proxy Implementations are used by each interface to ++// perform a call. Each different implementation encapsulate ++// an invocation logics. + +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); + +-private: +- TAO_ClientRequestInfo_IR_Contained_name_set (const TAO_ClientRequestInfo_IR_Contained_name_set &); +- void operator= (const TAO_ClientRequestInfo_IR_Contained_name_set &); +- const char * name_; +- +-}; ++/////////////////////////////////////////////////////////////////////// ++// Base Impl. Declaration ++// + +-class TAO_ClientRequestInfo_IR_Contained_version_get : public TAO_ClientRequestInfo ++class TAO_Export _TAO_Contained_Proxy_Impl : ++ public virtual _TAO_IRObject_Proxy_Impl + { + public: +- friend class IR::Contained; ++ virtual ~_TAO_Contained_Proxy_Impl (void) { } + +- friend class _TAO_Contained_Remote_Proxy_Impl; +- friend class _TAO_Contained_ThruPOA_Proxy_Impl; +- friend class _TAO_Contained_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Contained_version_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual char * id ( ++ CORBA_Object *_collocated_tao_target_, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual void id ( ++ CORBA_Object *_collocated_tao_target_, ++ const char * id, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-private: +- TAO_ClientRequestInfo_IR_Contained_version_get (const TAO_ClientRequestInfo_IR_Contained_version_get &); +- void operator= (const TAO_ClientRequestInfo_IR_Contained_version_get &); +- void result (char * result); +- // update the result +- char * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Contained_version_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Contained; +- +- friend class _TAO_Contained_Remote_Proxy_Impl; +- friend class _TAO_Contained_ThruPOA_Proxy_Impl; +- friend class _TAO_Contained_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Contained_version_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * version, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Contained_version_set (const TAO_ClientRequestInfo_IR_Contained_version_set &); +- void operator= (const TAO_ClientRequestInfo_IR_Contained_version_set &); +- const char * version_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_Contained_defined_in_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Contained; +- +- friend class _TAO_Contained_Remote_Proxy_Impl; +- friend class _TAO_Contained_ThruPOA_Proxy_Impl; +- friend class _TAO_Contained_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Contained_defined_in_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Contained_defined_in_get (const TAO_ClientRequestInfo_IR_Contained_defined_in_get &); +- void operator= (const TAO_ClientRequestInfo_IR_Contained_defined_in_get &); +- void result (IR::Container_ptr result); +- // update the result +- IR::Container_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Contained_absolute_name_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Contained; +- +- friend class _TAO_Contained_Remote_Proxy_Impl; +- friend class _TAO_Contained_ThruPOA_Proxy_Impl; +- friend class _TAO_Contained_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Contained_absolute_name_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Contained_absolute_name_get (const TAO_ClientRequestInfo_IR_Contained_absolute_name_get &); +- void operator= (const TAO_ClientRequestInfo_IR_Contained_absolute_name_get &); +- void result (char * result); +- // update the result +- char * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Contained_containing_repository_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Contained; +- +- friend class _TAO_Contained_Remote_Proxy_Impl; +- friend class _TAO_Contained_ThruPOA_Proxy_Impl; +- friend class _TAO_Contained_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Contained_containing_repository_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Contained_containing_repository_get (const TAO_ClientRequestInfo_IR_Contained_containing_repository_get &); +- void operator= (const TAO_ClientRequestInfo_IR_Contained_containing_repository_get &); +- void result (IR::Repository_ptr result); +- // update the result +- IR::Repository_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Contained_describe : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Contained; +- +- friend class _TAO_Contained_Remote_Proxy_Impl; +- friend class _TAO_Contained_ThruPOA_Proxy_Impl; +- friend class _TAO_Contained_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Contained_describe ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Contained_describe (const TAO_ClientRequestInfo_IR_Contained_describe &); +- void operator= (const TAO_ClientRequestInfo_IR_Contained_describe &); +- void result (ACE_NESTED_CLASS (IR::Contained,Description) * result); +- // update the result +- ACE_NESTED_CLASS (IR::Contained,Description) * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Contained_move : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Contained; +- +- friend class _TAO_Contained_Remote_Proxy_Impl; +- friend class _TAO_Contained_ThruPOA_Proxy_Impl; +- friend class _TAO_Contained_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Contained_move ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::Container_ptr new_container, +- const char * new_name, +- const char * new_version, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Contained_move (const TAO_ClientRequestInfo_IR_Contained_move &); +- void operator= (const TAO_ClientRequestInfo_IR_Contained_move &); +- IR::Container_ptr new_container_; +- const char * new_name_; +- const char * new_version_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- +-}; +- +- +-// The Proxy Implementations are used by each interface to +-// perform a call. Each different implementation encapsulate +-// an invocation logics. +- +- +-/////////////////////////////////////////////////////////////////////// +-// Base Impl. Declaration +-// +- +-class TAO_Export _TAO_Contained_Proxy_Impl : +- public virtual CORBA::_TAO_IRObject_Proxy_Impl +-{ +-public: +- virtual ~_TAO_Contained_Proxy_Impl (void) { } +- +- virtual char * id ( +- CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual void id ( +- CORBA_Object *_collocated_tao_target_, +- const char * id, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual char * name ( +- CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; ++ virtual char * name ( ++ CORBA_Object *_collocated_tao_target_, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + + virtual void name ( + CORBA_Object *_collocated_tao_target_, +@@ -1579,7 +797,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::Container_ptr defined_in ( ++ virtual IR_Container_ptr defined_in ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -1595,7 +813,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::Repository_ptr containing_repository ( ++ virtual IR_Repository_ptr containing_repository ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -1603,7 +821,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::Contained::Description * describe ( ++ virtual IR_Contained::Description * describe ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -1613,7 +831,7 @@ + + virtual void move ( + CORBA_Object *_collocated_tao_target_, +- IR::Container_ptr new_container, ++ IR_Container_ptr new_container, + const char * new_name, + const char * new_version, + CORBA::Environment &ACE_TRY_ENV +@@ -1624,8 +842,8 @@ + + protected: + _TAO_Contained_Proxy_Impl (void); +- + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -1638,7 +856,7 @@ + class TAO_Export _TAO_Contained_Remote_Proxy_Impl : + public virtual _TAO_Contained_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual CORBA::_TAO_IRObject_Remote_Proxy_Impl ++ public virtual _TAO_IRObject_Remote_Proxy_Impl + + { + public: +@@ -1646,7 +864,7 @@ + + virtual ~_TAO_Contained_Remote_Proxy_Impl (void) { } + +- virtual char * id ( ++ virtual char * id ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -1697,7 +915,7 @@ + CORBA::SystemException + )); + +- virtual IR::Container_ptr defined_in ( ++ virtual IR_Container_ptr defined_in ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -1713,7 +931,7 @@ + CORBA::SystemException + )); + +- virtual IR::Repository_ptr containing_repository ( ++ virtual IR_Repository_ptr containing_repository ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -1721,7 +939,7 @@ + CORBA::SystemException + )); + +- virtual IR::Contained::Description * describe ( ++ virtual IR_Contained::Description * describe ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -1731,7 +949,7 @@ + + virtual void move ( + CORBA_Object *_collocated_tao_target_, +- IR::Container_ptr new_container, ++ IR_Container_ptr new_container, + const char * new_name, + const char * new_version, + CORBA::Environment &ACE_TRY_ENV +@@ -1739,7 +957,6 @@ + ACE_THROW_SPEC (( + CORBA::SystemException + )); +- + }; + + // +@@ -1762,8 +979,9 @@ + { + public: + virtual ~_TAO_Contained_Proxy_Broker (void); ++ + virtual _TAO_Contained_Proxy_Impl &select_proxy ( +- Contained *object, ++ IR_Contained *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -1788,9 +1006,9 @@ + _TAO_Contained_Remote_Proxy_Broker (void); + + virtual ~_TAO_Contained_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_Contained_Proxy_Impl &select_proxy ( +- Contained *object, ++ IR_Contained *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -1804,702 +1022,462 @@ + static _TAO_Contained_Remote_Proxy_Broker *the_TAO_Contained_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Contained; +- +-class ModuleDef; +- +-#if !defined (_TAO_IR_MODULEDEF___PTR_CH_) +-#define _TAO_IR_MODULEDEF___PTR_CH_ +- +-typedef ModuleDef *ModuleDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_MODULEDEF___VAR_CH_) +-#define _TAO_IR_MODULEDEF___VAR_CH_ +- +-class TAO_Export ModuleDef_var : public TAO_Base_var ++class TAO_Export IR_ModuleDef_var : public TAO_Base_var + { + public: +- ModuleDef_var (void); // default constructor +- ModuleDef_var (ModuleDef_ptr p) : ptr_ (p) {} +- ModuleDef_var (const ModuleDef_var &); // copy constructor +- ~ModuleDef_var (void); // destructor ++ IR_ModuleDef_var (void); // default constructor ++ IR_ModuleDef_var (IR_ModuleDef_ptr p) : ptr_ (p) {} ++ IR_ModuleDef_var (const IR_ModuleDef_var &); // copy constructor ++ ~IR_ModuleDef_var (void); // destructor + +- ModuleDef_var &operator= (ModuleDef_ptr); +- ModuleDef_var &operator= (const ModuleDef_var &); +- ModuleDef_ptr operator-> (void) const; ++ IR_ModuleDef_var &operator= (IR_ModuleDef_ptr); ++ IR_ModuleDef_var &operator= (const IR_ModuleDef_var &); ++ IR_ModuleDef_ptr operator-> (void) const; + +- operator const ModuleDef_ptr &() const; +- operator ModuleDef_ptr &(); ++ operator const IR_ModuleDef_ptr &() const; ++ operator IR_ModuleDef_ptr &(); + // in, inout, out, _retn +- ModuleDef_ptr in (void) const; +- ModuleDef_ptr &inout (void); +- ModuleDef_ptr &out (void); +- ModuleDef_ptr _retn (void); +- ModuleDef_ptr ptr (void) const; ++ IR_ModuleDef_ptr in (void) const; ++ IR_ModuleDef_ptr &inout (void); ++ IR_ModuleDef_ptr &out (void); ++ IR_ModuleDef_ptr _retn (void); ++ IR_ModuleDef_ptr ptr (void) const; + + private: +- ModuleDef_ptr ptr_; ++ IR_ModuleDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- ModuleDef_var (const TAO_Base_var &rhs); +- ModuleDef_var &operator= (const TAO_Base_var &rhs); ++ IR_ModuleDef_var (const TAO_Base_var &rhs); ++ IR_ModuleDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_MODULEDEF___OUT_CH_) +-#define _TAO_IR_MODULEDEF___OUT_CH_ +- +-class TAO_Export ModuleDef_out ++class TAO_Export IR_ModuleDef_out + { + public: +- ModuleDef_out (ModuleDef_ptr &); +- ModuleDef_out (ModuleDef_var &); +- ModuleDef_out (const ModuleDef_out &); +- ModuleDef_out &operator= (const ModuleDef_out &); +- ModuleDef_out &operator= (const ModuleDef_var &); +- ModuleDef_out &operator= (ModuleDef_ptr); +- operator ModuleDef_ptr &(); +- ModuleDef_ptr &ptr (void); +- ModuleDef_ptr operator-> (void); ++ IR_ModuleDef_out (IR_ModuleDef_ptr &); ++ IR_ModuleDef_out (IR_ModuleDef_var &); ++ IR_ModuleDef_out (const IR_ModuleDef_out &); ++ IR_ModuleDef_out &operator= (const IR_ModuleDef_out &); ++ IR_ModuleDef_out &operator= (const IR_ModuleDef_var &); ++ IR_ModuleDef_out &operator= (IR_ModuleDef_ptr); ++ operator IR_ModuleDef_ptr &(); ++ IR_ModuleDef_ptr &ptr (void); ++ IR_ModuleDef_ptr operator-> (void); + + private: +- ModuleDef_ptr &ptr_; ++ IR_ModuleDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class ConstantDef; +- +-#if !defined (_TAO_IR_CONSTANTDEF___PTR_CH_) +-#define _TAO_IR_CONSTANTDEF___PTR_CH_ +- +-typedef ConstantDef *ConstantDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONSTANTDEF___VAR_CH_) +-#define _TAO_IR_CONSTANTDEF___VAR_CH_ +- +-class TAO_Export ConstantDef_var : public TAO_Base_var ++class TAO_Export IR_ConstantDef_var : public TAO_Base_var + { + public: +- ConstantDef_var (void); // default constructor +- ConstantDef_var (ConstantDef_ptr p) : ptr_ (p) {} +- ConstantDef_var (const ConstantDef_var &); // copy constructor +- ~ConstantDef_var (void); // destructor ++ IR_ConstantDef_var (void); // default constructor ++ IR_ConstantDef_var (IR_ConstantDef_ptr p) : ptr_ (p) {} ++ IR_ConstantDef_var (const IR_ConstantDef_var &); // copy constructor ++ ~IR_ConstantDef_var (void); // destructor + +- ConstantDef_var &operator= (ConstantDef_ptr); +- ConstantDef_var &operator= (const ConstantDef_var &); +- ConstantDef_ptr operator-> (void) const; ++ IR_ConstantDef_var &operator= (IR_ConstantDef_ptr); ++ IR_ConstantDef_var &operator= (const IR_ConstantDef_var &); ++ IR_ConstantDef_ptr operator-> (void) const; + +- operator const ConstantDef_ptr &() const; +- operator ConstantDef_ptr &(); ++ operator const IR_ConstantDef_ptr &() const; ++ operator IR_ConstantDef_ptr &(); + // in, inout, out, _retn +- ConstantDef_ptr in (void) const; +- ConstantDef_ptr &inout (void); +- ConstantDef_ptr &out (void); +- ConstantDef_ptr _retn (void); +- ConstantDef_ptr ptr (void) const; ++ IR_ConstantDef_ptr in (void) const; ++ IR_ConstantDef_ptr &inout (void); ++ IR_ConstantDef_ptr &out (void); ++ IR_ConstantDef_ptr _retn (void); ++ IR_ConstantDef_ptr ptr (void) const; + + private: +- ConstantDef_ptr ptr_; ++ IR_ConstantDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- ConstantDef_var (const TAO_Base_var &rhs); +- ConstantDef_var &operator= (const TAO_Base_var &rhs); ++ IR_ConstantDef_var (const TAO_Base_var &rhs); ++ IR_ConstantDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONSTANTDEF___OUT_CH_) +-#define _TAO_IR_CONSTANTDEF___OUT_CH_ +- +-class TAO_Export ConstantDef_out ++class TAO_Export IR_ConstantDef_out + { + public: +- ConstantDef_out (ConstantDef_ptr &); +- ConstantDef_out (ConstantDef_var &); +- ConstantDef_out (const ConstantDef_out &); +- ConstantDef_out &operator= (const ConstantDef_out &); +- ConstantDef_out &operator= (const ConstantDef_var &); +- ConstantDef_out &operator= (ConstantDef_ptr); +- operator ConstantDef_ptr &(); +- ConstantDef_ptr &ptr (void); +- ConstantDef_ptr operator-> (void); ++ IR_ConstantDef_out (IR_ConstantDef_ptr &); ++ IR_ConstantDef_out (IR_ConstantDef_var &); ++ IR_ConstantDef_out (const IR_ConstantDef_out &); ++ IR_ConstantDef_out &operator= (const IR_ConstantDef_out &); ++ IR_ConstantDef_out &operator= (const IR_ConstantDef_var &); ++ IR_ConstantDef_out &operator= (IR_ConstantDef_ptr); ++ operator IR_ConstantDef_ptr &(); ++ IR_ConstantDef_ptr &ptr (void); ++ IR_ConstantDef_ptr operator-> (void); + + private: +- ConstantDef_ptr &ptr_; ++ IR_ConstantDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class IDLType; +- +-#if !defined (_TAO_IR_IDLTYPE___PTR_CH_) +-#define _TAO_IR_IDLTYPE___PTR_CH_ +- +-typedef IDLType *IDLType_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_IDLTYPE___VAR_CH_) +-#define _TAO_IR_IDLTYPE___VAR_CH_ +- +-class TAO_Export IDLType_var : public TAO_Base_var ++class TAO_Export IR_IDLType_var : public TAO_Base_var + { + public: +- IDLType_var (void); // default constructor +- IDLType_var (IDLType_ptr p) : ptr_ (p) {} +- IDLType_var (const IDLType_var &); // copy constructor +- ~IDLType_var (void); // destructor ++ IR_IDLType_var (void); // default constructor ++ IR_IDLType_var (IR_IDLType_ptr p) : ptr_ (p) {} ++ IR_IDLType_var (const IR_IDLType_var &); // copy constructor ++ ~IR_IDLType_var (void); // destructor + +- IDLType_var &operator= (IDLType_ptr); +- IDLType_var &operator= (const IDLType_var &); +- IDLType_ptr operator-> (void) const; ++ IR_IDLType_var &operator= (IR_IDLType_ptr); ++ IR_IDLType_var &operator= (const IR_IDLType_var &); ++ IR_IDLType_ptr operator-> (void) const; + +- operator const IDLType_ptr &() const; +- operator IDLType_ptr &(); ++ operator const IR_IDLType_ptr &() const; ++ operator IR_IDLType_ptr &(); + // in, inout, out, _retn +- IDLType_ptr in (void) const; +- IDLType_ptr &inout (void); +- IDLType_ptr &out (void); +- IDLType_ptr _retn (void); +- IDLType_ptr ptr (void) const; ++ IR_IDLType_ptr in (void) const; ++ IR_IDLType_ptr &inout (void); ++ IR_IDLType_ptr &out (void); ++ IR_IDLType_ptr _retn (void); ++ IR_IDLType_ptr ptr (void) const; + + private: +- IDLType_ptr ptr_; ++ IR_IDLType_ptr ptr_; + // Unimplemented - prevents widening assignment. +- IDLType_var (const TAO_Base_var &rhs); +- IDLType_var &operator= (const TAO_Base_var &rhs); ++ IR_IDLType_var (const TAO_Base_var &rhs); ++ IR_IDLType_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_IDLTYPE___OUT_CH_) +-#define _TAO_IR_IDLTYPE___OUT_CH_ +- +-class TAO_Export IDLType_out ++class TAO_Export IR_IDLType_out + { + public: +- IDLType_out (IDLType_ptr &); +- IDLType_out (IDLType_var &); +- IDLType_out (const IDLType_out &); +- IDLType_out &operator= (const IDLType_out &); +- IDLType_out &operator= (const IDLType_var &); +- IDLType_out &operator= (IDLType_ptr); +- operator IDLType_ptr &(); +- IDLType_ptr &ptr (void); +- IDLType_ptr operator-> (void); ++ IR_IDLType_out (IR_IDLType_ptr &); ++ IR_IDLType_out (IR_IDLType_var &); ++ IR_IDLType_out (const IR_IDLType_out &); ++ IR_IDLType_out &operator= (const IR_IDLType_out &); ++ IR_IDLType_out &operator= (const IR_IDLType_var &); ++ IR_IDLType_out &operator= (IR_IDLType_ptr); ++ operator IR_IDLType_ptr &(); ++ IR_IDLType_ptr &ptr (void); ++ IR_IDLType_ptr operator-> (void); + + private: +- IDLType_ptr &ptr_; ++ IR_IDLType_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class StructDef; +- +-#if !defined (_TAO_IR_STRUCTDEF___PTR_CH_) +-#define _TAO_IR_STRUCTDEF___PTR_CH_ +- +-typedef StructDef *StructDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_STRUCTDEF___VAR_CH_) +-#define _TAO_IR_STRUCTDEF___VAR_CH_ +- +-class TAO_Export StructDef_var : public TAO_Base_var ++class TAO_Export IR_StructDef_var : public TAO_Base_var + { + public: +- StructDef_var (void); // default constructor +- StructDef_var (StructDef_ptr p) : ptr_ (p) {} +- StructDef_var (const StructDef_var &); // copy constructor +- ~StructDef_var (void); // destructor ++ IR_StructDef_var (void); // default constructor ++ IR_StructDef_var (IR_StructDef_ptr p) : ptr_ (p) {} ++ IR_StructDef_var (const IR_StructDef_var &); // copy constructor ++ ~IR_StructDef_var (void); // destructor + +- StructDef_var &operator= (StructDef_ptr); +- StructDef_var &operator= (const StructDef_var &); +- StructDef_ptr operator-> (void) const; ++ IR_StructDef_var &operator= (IR_StructDef_ptr); ++ IR_StructDef_var &operator= (const IR_StructDef_var &); ++ IR_StructDef_ptr operator-> (void) const; + +- operator const StructDef_ptr &() const; +- operator StructDef_ptr &(); ++ operator const IR_StructDef_ptr &() const; ++ operator IR_StructDef_ptr &(); + // in, inout, out, _retn +- StructDef_ptr in (void) const; +- StructDef_ptr &inout (void); +- StructDef_ptr &out (void); +- StructDef_ptr _retn (void); +- StructDef_ptr ptr (void) const; ++ IR_StructDef_ptr in (void) const; ++ IR_StructDef_ptr &inout (void); ++ IR_StructDef_ptr &out (void); ++ IR_StructDef_ptr _retn (void); ++ IR_StructDef_ptr ptr (void) const; + + private: +- StructDef_ptr ptr_; ++ IR_StructDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- StructDef_var (const TAO_Base_var &rhs); +- StructDef_var &operator= (const TAO_Base_var &rhs); ++ IR_StructDef_var (const TAO_Base_var &rhs); ++ IR_StructDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_STRUCTDEF___OUT_CH_) +-#define _TAO_IR_STRUCTDEF___OUT_CH_ +- +-class TAO_Export StructDef_out ++class TAO_Export IR_StructDef_out + { + public: +- StructDef_out (StructDef_ptr &); +- StructDef_out (StructDef_var &); +- StructDef_out (const StructDef_out &); +- StructDef_out &operator= (const StructDef_out &); +- StructDef_out &operator= (const StructDef_var &); +- StructDef_out &operator= (StructDef_ptr); +- operator StructDef_ptr &(); +- StructDef_ptr &ptr (void); +- StructDef_ptr operator-> (void); ++ IR_StructDef_out (IR_StructDef_ptr &); ++ IR_StructDef_out (IR_StructDef_var &); ++ IR_StructDef_out (const IR_StructDef_out &); ++ IR_StructDef_out &operator= (const IR_StructDef_out &); ++ IR_StructDef_out &operator= (const IR_StructDef_var &); ++ IR_StructDef_out &operator= (IR_StructDef_ptr); ++ operator IR_StructDef_ptr &(); ++ IR_StructDef_ptr &ptr (void); ++ IR_StructDef_ptr operator-> (void); + + private: +- StructDef_ptr &ptr_; ++ IR_StructDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class UnionDef; +- +-#if !defined (_TAO_IR_UNIONDEF___PTR_CH_) +-#define _TAO_IR_UNIONDEF___PTR_CH_ +- +-typedef UnionDef *UnionDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_UNIONDEF___VAR_CH_) +-#define _TAO_IR_UNIONDEF___VAR_CH_ +- +-class TAO_Export UnionDef_var : public TAO_Base_var ++class TAO_Export IR_UnionDef_var : public TAO_Base_var + { + public: +- UnionDef_var (void); // default constructor +- UnionDef_var (UnionDef_ptr p) : ptr_ (p) {} +- UnionDef_var (const UnionDef_var &); // copy constructor +- ~UnionDef_var (void); // destructor ++ IR_UnionDef_var (void); // default constructor ++ IR_UnionDef_var (IR_UnionDef_ptr p) : ptr_ (p) {} ++ IR_UnionDef_var (const IR_UnionDef_var &); // copy constructor ++ ~IR_UnionDef_var (void); // destructor + +- UnionDef_var &operator= (UnionDef_ptr); +- UnionDef_var &operator= (const UnionDef_var &); +- UnionDef_ptr operator-> (void) const; ++ IR_UnionDef_var &operator= (IR_UnionDef_ptr); ++ IR_UnionDef_var &operator= (const IR_UnionDef_var &); ++ IR_UnionDef_ptr operator-> (void) const; + +- operator const UnionDef_ptr &() const; +- operator UnionDef_ptr &(); ++ operator const IR_UnionDef_ptr &() const; ++ operator IR_UnionDef_ptr &(); + // in, inout, out, _retn +- UnionDef_ptr in (void) const; +- UnionDef_ptr &inout (void); +- UnionDef_ptr &out (void); +- UnionDef_ptr _retn (void); +- UnionDef_ptr ptr (void) const; ++ IR_UnionDef_ptr in (void) const; ++ IR_UnionDef_ptr &inout (void); ++ IR_UnionDef_ptr &out (void); ++ IR_UnionDef_ptr _retn (void); ++ IR_UnionDef_ptr ptr (void) const; + + private: +- UnionDef_ptr ptr_; ++ IR_UnionDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- UnionDef_var (const TAO_Base_var &rhs); +- UnionDef_var &operator= (const TAO_Base_var &rhs); ++ IR_UnionDef_var (const TAO_Base_var &rhs); ++ IR_UnionDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_UNIONDEF___OUT_CH_) +-#define _TAO_IR_UNIONDEF___OUT_CH_ +- +-class TAO_Export UnionDef_out ++class TAO_Export IR_UnionDef_out + { + public: +- UnionDef_out (UnionDef_ptr &); +- UnionDef_out (UnionDef_var &); +- UnionDef_out (const UnionDef_out &); +- UnionDef_out &operator= (const UnionDef_out &); +- UnionDef_out &operator= (const UnionDef_var &); +- UnionDef_out &operator= (UnionDef_ptr); +- operator UnionDef_ptr &(); +- UnionDef_ptr &ptr (void); +- UnionDef_ptr operator-> (void); ++ IR_UnionDef_out (IR_UnionDef_ptr &); ++ IR_UnionDef_out (IR_UnionDef_var &); ++ IR_UnionDef_out (const IR_UnionDef_out &); ++ IR_UnionDef_out &operator= (const IR_UnionDef_out &); ++ IR_UnionDef_out &operator= (const IR_UnionDef_var &); ++ IR_UnionDef_out &operator= (IR_UnionDef_ptr); ++ operator IR_UnionDef_ptr &(); ++ IR_UnionDef_ptr &ptr (void); ++ IR_UnionDef_ptr operator-> (void); + + private: +- UnionDef_ptr &ptr_; ++ IR_UnionDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class EnumDef; +- +-#if !defined (_TAO_IR_ENUMDEF___PTR_CH_) +-#define _TAO_IR_ENUMDEF___PTR_CH_ +- +-typedef EnumDef *EnumDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ENUMDEF___VAR_CH_) +-#define _TAO_IR_ENUMDEF___VAR_CH_ +- +-class TAO_Export EnumDef_var : public TAO_Base_var ++class TAO_Export IR_EnumDef_var : public TAO_Base_var + { + public: +- EnumDef_var (void); // default constructor +- EnumDef_var (EnumDef_ptr p) : ptr_ (p) {} +- EnumDef_var (const EnumDef_var &); // copy constructor +- ~EnumDef_var (void); // destructor ++ IR_EnumDef_var (void); // default constructor ++ IR_EnumDef_var (IR_EnumDef_ptr p) : ptr_ (p) {} ++ IR_EnumDef_var (const IR_EnumDef_var &); // copy constructor ++ ~IR_EnumDef_var (void); // destructor + +- EnumDef_var &operator= (EnumDef_ptr); +- EnumDef_var &operator= (const EnumDef_var &); +- EnumDef_ptr operator-> (void) const; ++ IR_EnumDef_var &operator= (IR_EnumDef_ptr); ++ IR_EnumDef_var &operator= (const IR_EnumDef_var &); ++ IR_EnumDef_ptr operator-> (void) const; + +- operator const EnumDef_ptr &() const; +- operator EnumDef_ptr &(); ++ operator const IR_EnumDef_ptr &() const; ++ operator IR_EnumDef_ptr &(); + // in, inout, out, _retn +- EnumDef_ptr in (void) const; +- EnumDef_ptr &inout (void); +- EnumDef_ptr &out (void); +- EnumDef_ptr _retn (void); +- EnumDef_ptr ptr (void) const; ++ IR_EnumDef_ptr in (void) const; ++ IR_EnumDef_ptr &inout (void); ++ IR_EnumDef_ptr &out (void); ++ IR_EnumDef_ptr _retn (void); ++ IR_EnumDef_ptr ptr (void) const; + + private: +- EnumDef_ptr ptr_; ++ IR_EnumDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- EnumDef_var (const TAO_Base_var &rhs); +- EnumDef_var &operator= (const TAO_Base_var &rhs); ++ IR_EnumDef_var (const TAO_Base_var &rhs); ++ IR_EnumDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ENUMDEF___OUT_CH_) +-#define _TAO_IR_ENUMDEF___OUT_CH_ +- +-class TAO_Export EnumDef_out ++class TAO_Export IR_EnumDef_out + { + public: +- EnumDef_out (EnumDef_ptr &); +- EnumDef_out (EnumDef_var &); +- EnumDef_out (const EnumDef_out &); +- EnumDef_out &operator= (const EnumDef_out &); +- EnumDef_out &operator= (const EnumDef_var &); +- EnumDef_out &operator= (EnumDef_ptr); +- operator EnumDef_ptr &(); +- EnumDef_ptr &ptr (void); +- EnumDef_ptr operator-> (void); ++ IR_EnumDef_out (IR_EnumDef_ptr &); ++ IR_EnumDef_out (IR_EnumDef_var &); ++ IR_EnumDef_out (const IR_EnumDef_out &); ++ IR_EnumDef_out &operator= (const IR_EnumDef_out &); ++ IR_EnumDef_out &operator= (const IR_EnumDef_var &); ++ IR_EnumDef_out &operator= (IR_EnumDef_ptr); ++ operator IR_EnumDef_ptr &(); ++ IR_EnumDef_ptr &ptr (void); ++ IR_EnumDef_ptr operator-> (void); + + private: +- EnumDef_ptr &ptr_; ++ IR_EnumDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class AliasDef; +- +-#if !defined (_TAO_IR_ALIASDEF___PTR_CH_) +-#define _TAO_IR_ALIASDEF___PTR_CH_ +- +-typedef AliasDef *AliasDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ALIASDEF___VAR_CH_) +-#define _TAO_IR_ALIASDEF___VAR_CH_ +- +-class TAO_Export AliasDef_var : public TAO_Base_var ++class TAO_Export IR_AliasDef_var : public TAO_Base_var + { + public: +- AliasDef_var (void); // default constructor +- AliasDef_var (AliasDef_ptr p) : ptr_ (p) {} +- AliasDef_var (const AliasDef_var &); // copy constructor +- ~AliasDef_var (void); // destructor ++ IR_AliasDef_var (void); // default constructor ++ IR_AliasDef_var (IR_AliasDef_ptr p) : ptr_ (p) {} ++ IR_AliasDef_var (const IR_AliasDef_var &); // copy constructor ++ ~IR_AliasDef_var (void); // destructor + +- AliasDef_var &operator= (AliasDef_ptr); +- AliasDef_var &operator= (const AliasDef_var &); +- AliasDef_ptr operator-> (void) const; ++ IR_AliasDef_var &operator= (IR_AliasDef_ptr); ++ IR_AliasDef_var &operator= (const IR_AliasDef_var &); ++ IR_AliasDef_ptr operator-> (void) const; + +- operator const AliasDef_ptr &() const; +- operator AliasDef_ptr &(); ++ operator const IR_AliasDef_ptr &() const; ++ operator IR_AliasDef_ptr &(); + // in, inout, out, _retn +- AliasDef_ptr in (void) const; +- AliasDef_ptr &inout (void); +- AliasDef_ptr &out (void); +- AliasDef_ptr _retn (void); +- AliasDef_ptr ptr (void) const; ++ IR_AliasDef_ptr in (void) const; ++ IR_AliasDef_ptr &inout (void); ++ IR_AliasDef_ptr &out (void); ++ IR_AliasDef_ptr _retn (void); ++ IR_AliasDef_ptr ptr (void) const; + + private: +- AliasDef_ptr ptr_; ++ IR_AliasDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- AliasDef_var (const TAO_Base_var &rhs); +- AliasDef_var &operator= (const TAO_Base_var &rhs); ++ IR_AliasDef_var (const TAO_Base_var &rhs); ++ IR_AliasDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ALIASDEF___OUT_CH_) +-#define _TAO_IR_ALIASDEF___OUT_CH_ +- +-class TAO_Export AliasDef_out ++class TAO_Export IR_AliasDef_out + { + public: +- AliasDef_out (AliasDef_ptr &); +- AliasDef_out (AliasDef_var &); +- AliasDef_out (const AliasDef_out &); +- AliasDef_out &operator= (const AliasDef_out &); +- AliasDef_out &operator= (const AliasDef_var &); +- AliasDef_out &operator= (AliasDef_ptr); +- operator AliasDef_ptr &(); +- AliasDef_ptr &ptr (void); +- AliasDef_ptr operator-> (void); ++ IR_AliasDef_out (IR_AliasDef_ptr &); ++ IR_AliasDef_out (IR_AliasDef_var &); ++ IR_AliasDef_out (const IR_AliasDef_out &); ++ IR_AliasDef_out &operator= (const IR_AliasDef_out &); ++ IR_AliasDef_out &operator= (const IR_AliasDef_var &); ++ IR_AliasDef_out &operator= (IR_AliasDef_ptr); ++ operator IR_AliasDef_ptr &(); ++ IR_AliasDef_ptr &ptr (void); ++ IR_AliasDef_ptr operator-> (void); + + private: +- AliasDef_ptr &ptr_; ++ IR_AliasDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class InterfaceDef; +- +-#if !defined (_TAO_IR_INTERFACEDEF___PTR_CH_) +-#define _TAO_IR_INTERFACEDEF___PTR_CH_ +- +-typedef InterfaceDef *InterfaceDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_INTERFACEDEF___VAR_CH_) +-#define _TAO_IR_INTERFACEDEF___VAR_CH_ +- +-class TAO_Export InterfaceDef_var : public TAO_Base_var ++class TAO_Export IR_InterfaceDef_var : public TAO_Base_var + { + public: +- InterfaceDef_var (void); // default constructor +- InterfaceDef_var (InterfaceDef_ptr p) : ptr_ (p) {} +- InterfaceDef_var (const InterfaceDef_var &); // copy constructor +- ~InterfaceDef_var (void); // destructor ++ IR_InterfaceDef_var (void); // default constructor ++ IR_InterfaceDef_var (IR_InterfaceDef_ptr p) : ptr_ (p) {} ++ IR_InterfaceDef_var (const IR_InterfaceDef_var &); // copy constructor ++ ~IR_InterfaceDef_var (void); // destructor + +- InterfaceDef_var &operator= (InterfaceDef_ptr); +- InterfaceDef_var &operator= (const InterfaceDef_var &); +- InterfaceDef_ptr operator-> (void) const; ++ IR_InterfaceDef_var &operator= (IR_InterfaceDef_ptr); ++ IR_InterfaceDef_var &operator= (const IR_InterfaceDef_var &); ++ IR_InterfaceDef_ptr operator-> (void) const; + +- operator const InterfaceDef_ptr &() const; +- operator InterfaceDef_ptr &(); ++ operator const IR_InterfaceDef_ptr &() const; ++ operator IR_InterfaceDef_ptr &(); + // in, inout, out, _retn +- InterfaceDef_ptr in (void) const; +- InterfaceDef_ptr &inout (void); +- InterfaceDef_ptr &out (void); +- InterfaceDef_ptr _retn (void); +- InterfaceDef_ptr ptr (void) const; ++ IR_InterfaceDef_ptr in (void) const; ++ IR_InterfaceDef_ptr &inout (void); ++ IR_InterfaceDef_ptr &out (void); ++ IR_InterfaceDef_ptr _retn (void); ++ IR_InterfaceDef_ptr ptr (void) const; + + private: +- InterfaceDef_ptr ptr_; ++ IR_InterfaceDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- InterfaceDef_var (const TAO_Base_var &rhs); +- InterfaceDef_var &operator= (const TAO_Base_var &rhs); ++ IR_InterfaceDef_var (const TAO_Base_var &rhs); ++ IR_InterfaceDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_INTERFACEDEF___OUT_CH_) +-#define _TAO_IR_INTERFACEDEF___OUT_CH_ +- +-class TAO_Export InterfaceDef_out ++class TAO_Export IR_InterfaceDef_out + { + public: +- InterfaceDef_out (InterfaceDef_ptr &); +- InterfaceDef_out (InterfaceDef_var &); +- InterfaceDef_out (const InterfaceDef_out &); +- InterfaceDef_out &operator= (const InterfaceDef_out &); +- InterfaceDef_out &operator= (const InterfaceDef_var &); +- InterfaceDef_out &operator= (InterfaceDef_ptr); +- operator InterfaceDef_ptr &(); +- InterfaceDef_ptr &ptr (void); +- InterfaceDef_ptr operator-> (void); ++ IR_InterfaceDef_out (IR_InterfaceDef_ptr &); ++ IR_InterfaceDef_out (IR_InterfaceDef_var &); ++ IR_InterfaceDef_out (const IR_InterfaceDef_out &); ++ IR_InterfaceDef_out &operator= (const IR_InterfaceDef_out &); ++ IR_InterfaceDef_out &operator= (const IR_InterfaceDef_var &); ++ IR_InterfaceDef_out &operator= (IR_InterfaceDef_ptr); ++ operator IR_InterfaceDef_ptr &(); ++ IR_InterfaceDef_ptr &ptr (void); ++ IR_InterfaceDef_ptr operator-> (void); + + private: +- InterfaceDef_ptr &ptr_; ++ IR_InterfaceDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class ExceptionDef; +- +-#if !defined (_TAO_IR_EXCEPTIONDEF___PTR_CH_) +-#define _TAO_IR_EXCEPTIONDEF___PTR_CH_ +- +-typedef ExceptionDef *ExceptionDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EXCEPTIONDEF___VAR_CH_) +-#define _TAO_IR_EXCEPTIONDEF___VAR_CH_ +- +-class TAO_Export ExceptionDef_var : public TAO_Base_var ++class TAO_Export IR_ExceptionDef_var : public TAO_Base_var + { + public: +- ExceptionDef_var (void); // default constructor +- ExceptionDef_var (ExceptionDef_ptr p) : ptr_ (p) {} +- ExceptionDef_var (const ExceptionDef_var &); // copy constructor +- ~ExceptionDef_var (void); // destructor ++ IR_ExceptionDef_var (void); // default constructor ++ IR_ExceptionDef_var (IR_ExceptionDef_ptr p) : ptr_ (p) {} ++ IR_ExceptionDef_var (const IR_ExceptionDef_var &); // copy constructor ++ ~IR_ExceptionDef_var (void); // destructor + +- ExceptionDef_var &operator= (ExceptionDef_ptr); +- ExceptionDef_var &operator= (const ExceptionDef_var &); +- ExceptionDef_ptr operator-> (void) const; ++ IR_ExceptionDef_var &operator= (IR_ExceptionDef_ptr); ++ IR_ExceptionDef_var &operator= (const IR_ExceptionDef_var &); ++ IR_ExceptionDef_ptr operator-> (void) const; + +- operator const ExceptionDef_ptr &() const; +- operator ExceptionDef_ptr &(); ++ operator const IR_ExceptionDef_ptr &() const; ++ operator IR_ExceptionDef_ptr &(); + // in, inout, out, _retn +- ExceptionDef_ptr in (void) const; +- ExceptionDef_ptr &inout (void); +- ExceptionDef_ptr &out (void); +- ExceptionDef_ptr _retn (void); +- ExceptionDef_ptr ptr (void) const; ++ IR_ExceptionDef_ptr in (void) const; ++ IR_ExceptionDef_ptr &inout (void); ++ IR_ExceptionDef_ptr &out (void); ++ IR_ExceptionDef_ptr _retn (void); ++ IR_ExceptionDef_ptr ptr (void) const; + + private: +- ExceptionDef_ptr ptr_; ++ IR_ExceptionDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- ExceptionDef_var (const TAO_Base_var &rhs); +- ExceptionDef_var &operator= (const TAO_Base_var &rhs); ++ IR_ExceptionDef_var (const TAO_Base_var &rhs); ++ IR_ExceptionDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EXCEPTIONDEF___OUT_CH_) +-#define _TAO_IR_EXCEPTIONDEF___OUT_CH_ +- +-class TAO_Export ExceptionDef_out ++class TAO_Export IR_ExceptionDef_out + { + public: +- ExceptionDef_out (ExceptionDef_ptr &); +- ExceptionDef_out (ExceptionDef_var &); +- ExceptionDef_out (const ExceptionDef_out &); +- ExceptionDef_out &operator= (const ExceptionDef_out &); +- ExceptionDef_out &operator= (const ExceptionDef_var &); +- ExceptionDef_out &operator= (ExceptionDef_ptr); +- operator ExceptionDef_ptr &(); +- ExceptionDef_ptr &ptr (void); +- ExceptionDef_ptr operator-> (void); ++ IR_ExceptionDef_out (IR_ExceptionDef_ptr &); ++ IR_ExceptionDef_out (IR_ExceptionDef_var &); ++ IR_ExceptionDef_out (const IR_ExceptionDef_out &); ++ IR_ExceptionDef_out &operator= (const IR_ExceptionDef_out &); ++ IR_ExceptionDef_out &operator= (const IR_ExceptionDef_var &); ++ IR_ExceptionDef_out &operator= (IR_ExceptionDef_ptr); ++ operator IR_ExceptionDef_ptr &(); ++ IR_ExceptionDef_ptr &ptr (void); ++ IR_ExceptionDef_ptr operator-> (void); + + private: +- ExceptionDef_ptr &ptr_; ++ IR_ExceptionDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class NativeDef; +- +-#if !defined (_TAO_IR_NATIVEDEF___PTR_CH_) +-#define _TAO_IR_NATIVEDEF___PTR_CH_ +- +-typedef NativeDef *NativeDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_NATIVEDEF___VAR_CH_) +-#define _TAO_IR_NATIVEDEF___VAR_CH_ +- +-class TAO_Export NativeDef_var : public TAO_Base_var ++class TAO_Export IR_NativeDef_var : public TAO_Base_var + { + public: +- NativeDef_var (void); // default constructor +- NativeDef_var (NativeDef_ptr p) : ptr_ (p) {} +- NativeDef_var (const NativeDef_var &); // copy constructor +- ~NativeDef_var (void); // destructor ++ IR_NativeDef_var (void); // default constructor ++ IR_NativeDef_var (IR_NativeDef_ptr p) : ptr_ (p) {} ++ IR_NativeDef_var (const IR_NativeDef_var &); // copy constructor ++ ~IR_NativeDef_var (void); // destructor + +- NativeDef_var &operator= (NativeDef_ptr); +- NativeDef_var &operator= (const NativeDef_var &); +- NativeDef_ptr operator-> (void) const; ++ IR_NativeDef_var &operator= (IR_NativeDef_ptr); ++ IR_NativeDef_var &operator= (const IR_NativeDef_var &); ++ IR_NativeDef_ptr operator-> (void) const; + +- operator const NativeDef_ptr &() const; +- operator NativeDef_ptr &(); ++ operator const IR_NativeDef_ptr &() const; ++ operator IR_NativeDef_ptr &(); + // in, inout, out, _retn +- NativeDef_ptr in (void) const; +- NativeDef_ptr &inout (void); +- NativeDef_ptr &out (void); +- NativeDef_ptr _retn (void); +- NativeDef_ptr ptr (void) const; ++ IR_NativeDef_ptr in (void) const; ++ IR_NativeDef_ptr &inout (void); ++ IR_NativeDef_ptr &out (void); ++ IR_NativeDef_ptr _retn (void); ++ IR_NativeDef_ptr ptr (void) const; + + private: +- NativeDef_ptr ptr_; ++ IR_NativeDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- NativeDef_var (const TAO_Base_var &rhs); +- NativeDef_var &operator= (const TAO_Base_var &rhs); ++ IR_NativeDef_var (const TAO_Base_var &rhs); ++ IR_NativeDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_NATIVEDEF___OUT_CH_) +-#define _TAO_IR_NATIVEDEF___OUT_CH_ +- +-class TAO_Export NativeDef_out ++class TAO_Export IR_NativeDef_out + { + public: +- NativeDef_out (NativeDef_ptr &); +- NativeDef_out (NativeDef_var &); +- NativeDef_out (const NativeDef_out &); +- NativeDef_out &operator= (const NativeDef_out &); +- NativeDef_out &operator= (const NativeDef_var &); +- NativeDef_out &operator= (NativeDef_ptr); +- operator NativeDef_ptr &(); +- NativeDef_ptr &ptr (void); +- NativeDef_ptr operator-> (void); ++ IR_NativeDef_out (IR_NativeDef_ptr &); ++ IR_NativeDef_out (IR_NativeDef_var &); ++ IR_NativeDef_out (const IR_NativeDef_out &); ++ IR_NativeDef_out &operator= (const IR_NativeDef_out &); ++ IR_NativeDef_out &operator= (const IR_NativeDef_var &); ++ IR_NativeDef_out &operator= (IR_NativeDef_ptr); ++ operator IR_NativeDef_ptr &(); ++ IR_NativeDef_ptr &ptr (void); ++ IR_NativeDef_ptr operator-> (void); + + private: +- NativeDef_ptr &ptr_; ++ IR_NativeDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_INTERFACEDEFSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_INTERFACEDEFSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -2509,19 +1487,19 @@ + _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (CORBA::ULong maximum, + CORBA::ULong length, +- InterfaceDef* *value, ++ IR_InterfaceDef* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (void); + _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq &rhs); +- TAO_Object_Manager<IR::InterfaceDef,IR::InterfaceDef_var> operator[] (CORBA::ULong index) const; +- static InterfaceDef **allocbuf (CORBA::ULong nelems); +- static void freebuf (InterfaceDef **buffer); ++ TAO_Object_Manager<IR_InterfaceDef,IR_InterfaceDef_var> operator[] (CORBA::ULong index) const; ++ static IR_InterfaceDef **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_InterfaceDef **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- InterfaceDef* *get_buffer (CORBA::Boolean orphan = 0); +- const InterfaceDef* *get_buffer (void) const; ++ IR_InterfaceDef* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_InterfaceDef* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -2533,193 +1511,139 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_INTERFACEDEFSEQ_CH_) +-#define _TAO_IR_INTERFACEDEFSEQ_CH_ +- +-class InterfaceDefSeq; +-class InterfaceDefSeq_var; +- + // ************************************************************* +-// InterfaceDefSeq ++// IR_InterfaceDefSeq + // ************************************************************* + +-class TAO_Export InterfaceDefSeq : public ++class TAO_Export IR_InterfaceDefSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<InterfaceDef,InterfaceDef_var> ++ TAO_Unbounded_Object_Sequence<IR_InterfaceDef,IR_InterfaceDef_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- InterfaceDefSeq (void); // default ctor +- InterfaceDefSeq (CORBA::ULong max); // uses max size +- InterfaceDefSeq ( ++ IR_InterfaceDefSeq (void); // default ctor ++ IR_InterfaceDefSeq (CORBA::ULong max); // uses max size ++ IR_InterfaceDefSeq ( + CORBA::ULong max, + CORBA::ULong length, +- InterfaceDef_ptr *buffer, ++ IR_InterfaceDef_ptr *buffer, + CORBA::Boolean release = 0 + ); +- InterfaceDefSeq (const InterfaceDefSeq &); // copy ctor +- ~InterfaceDefSeq (void); ++ IR_InterfaceDefSeq (const IR_InterfaceDefSeq &); // copy ctor ++ ~IR_InterfaceDefSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef InterfaceDefSeq_var _var_type; ++ typedef IR_InterfaceDefSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ ++// ************************************************************* ++// class IR_InterfaceDefSeq_var ++// ************************************************************* + +- +-#if !defined (_TAO_IR_INTERFACEDEFSEQ___VAR_CH_) +-#define _TAO_IR_INTERFACEDEFSEQ___VAR_CH_ +- +-// ************************************************************* +-// class IR::InterfaceDefSeq_var +-// ************************************************************* +- +-class TAO_Export InterfaceDefSeq_var ++class TAO_Export IR_InterfaceDefSeq_var + { + public: +- InterfaceDefSeq_var (void); // default constructor +- InterfaceDefSeq_var (InterfaceDefSeq *); +- InterfaceDefSeq_var (const InterfaceDefSeq_var &); // copy constructor +- ~InterfaceDefSeq_var (void); // destructor ++ IR_InterfaceDefSeq_var (void); // default constructor ++ IR_InterfaceDefSeq_var (IR_InterfaceDefSeq *); ++ IR_InterfaceDefSeq_var (const IR_InterfaceDefSeq_var &); // copy constructor ++ ~IR_InterfaceDefSeq_var (void); // destructor + +- InterfaceDefSeq_var &operator= (InterfaceDefSeq *); +- InterfaceDefSeq_var &operator= (const InterfaceDefSeq_var &); +- InterfaceDefSeq *operator-> (void); +- const InterfaceDefSeq *operator-> (void) const; ++ IR_InterfaceDefSeq_var &operator= (IR_InterfaceDefSeq *); ++ IR_InterfaceDefSeq_var &operator= (const IR_InterfaceDefSeq_var &); ++ IR_InterfaceDefSeq *operator-> (void); ++ const IR_InterfaceDefSeq *operator-> (void) const; + +- operator const InterfaceDefSeq &() const; +- operator InterfaceDefSeq &(); +- operator InterfaceDefSeq &() const; +- operator InterfaceDefSeq *&(); // variable-size base types only ++ operator const IR_InterfaceDefSeq &() const; ++ operator IR_InterfaceDefSeq &(); ++ operator IR_InterfaceDefSeq &() const; ++ operator IR_InterfaceDefSeq *&(); // variable-size base types only + +- TAO_Object_Manager<InterfaceDef, InterfaceDef_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_InterfaceDef, IR_InterfaceDef_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const InterfaceDefSeq &in (void) const; +- InterfaceDefSeq &inout (void); +- InterfaceDefSeq *&out (void); +- InterfaceDefSeq *_retn (void); +- InterfaceDefSeq *ptr (void) const; ++ const IR_InterfaceDefSeq &in (void) const; ++ IR_InterfaceDefSeq &inout (void); ++ IR_InterfaceDefSeq *&out (void); ++ IR_InterfaceDefSeq *_retn (void); ++ IR_InterfaceDefSeq *ptr (void) const; + + private: +- InterfaceDefSeq *ptr_; ++ IR_InterfaceDefSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_INTERFACEDEFSEQ___OUT_CH_) +-#define _TAO_IR_INTERFACEDEFSEQ___OUT_CH_ +- +-class TAO_Export InterfaceDefSeq_out ++class TAO_Export IR_InterfaceDefSeq_out + { + public: +- InterfaceDefSeq_out (InterfaceDefSeq *&); +- InterfaceDefSeq_out (InterfaceDefSeq_var &); +- InterfaceDefSeq_out (const InterfaceDefSeq_out &); +- InterfaceDefSeq_out &operator= (const InterfaceDefSeq_out &); +- InterfaceDefSeq_out &operator= (InterfaceDefSeq *); +- operator InterfaceDefSeq *&(); +- InterfaceDefSeq *&ptr (void); +- InterfaceDefSeq *operator-> (void); +- TAO_Object_Manager<InterfaceDef, InterfaceDef_var> operator[] (CORBA::ULong index); ++ IR_InterfaceDefSeq_out (IR_InterfaceDefSeq *&); ++ IR_InterfaceDefSeq_out (IR_InterfaceDefSeq_var &); ++ IR_InterfaceDefSeq_out (const IR_InterfaceDefSeq_out &); ++ IR_InterfaceDefSeq_out &operator= (const IR_InterfaceDefSeq_out &); ++ IR_InterfaceDefSeq_out &operator= (IR_InterfaceDefSeq *); ++ operator IR_InterfaceDefSeq *&(); ++ IR_InterfaceDefSeq *&ptr (void); ++ IR_InterfaceDefSeq *operator-> (void); ++ TAO_Object_Manager<IR_InterfaceDef, IR_InterfaceDef_var> operator[] (CORBA::ULong index); + + private: +- InterfaceDefSeq *&ptr_; ++ IR_InterfaceDefSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const InterfaceDefSeq_var &); ++ void operator= (const IR_InterfaceDefSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDefSeq; +- +-class ValueDef; +- +-#if !defined (_TAO_IR_VALUEDEF___PTR_CH_) +-#define _TAO_IR_VALUEDEF___PTR_CH_ +- +-typedef ValueDef *ValueDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEDEF___VAR_CH_) +-#define _TAO_IR_VALUEDEF___VAR_CH_ +- +-class TAO_Export ValueDef_var : public TAO_Base_var ++class TAO_Export IR_ValueDef_var : public TAO_Base_var + { + public: +- ValueDef_var (void); // default constructor +- ValueDef_var (ValueDef_ptr p) : ptr_ (p) {} +- ValueDef_var (const ValueDef_var &); // copy constructor +- ~ValueDef_var (void); // destructor ++ IR_ValueDef_var (void); // default constructor ++ IR_ValueDef_var (IR_ValueDef_ptr p) : ptr_ (p) {} ++ IR_ValueDef_var (const IR_ValueDef_var &); // copy constructor ++ ~IR_ValueDef_var (void); // destructor + +- ValueDef_var &operator= (ValueDef_ptr); +- ValueDef_var &operator= (const ValueDef_var &); +- ValueDef_ptr operator-> (void) const; ++ IR_ValueDef_var &operator= (IR_ValueDef_ptr); ++ IR_ValueDef_var &operator= (const IR_ValueDef_var &); ++ IR_ValueDef_ptr operator-> (void) const; + +- operator const ValueDef_ptr &() const; +- operator ValueDef_ptr &(); ++ operator const IR_ValueDef_ptr &() const; ++ operator IR_ValueDef_ptr &(); + // in, inout, out, _retn +- ValueDef_ptr in (void) const; +- ValueDef_ptr &inout (void); +- ValueDef_ptr &out (void); +- ValueDef_ptr _retn (void); +- ValueDef_ptr ptr (void) const; ++ IR_ValueDef_ptr in (void) const; ++ IR_ValueDef_ptr &inout (void); ++ IR_ValueDef_ptr &out (void); ++ IR_ValueDef_ptr _retn (void); ++ IR_ValueDef_ptr ptr (void) const; + + private: +- ValueDef_ptr ptr_; ++ IR_ValueDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- ValueDef_var (const TAO_Base_var &rhs); +- ValueDef_var &operator= (const TAO_Base_var &rhs); ++ IR_ValueDef_var (const TAO_Base_var &rhs); ++ IR_ValueDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEDEF___OUT_CH_) +-#define _TAO_IR_VALUEDEF___OUT_CH_ +- +-class TAO_Export ValueDef_out ++class TAO_Export IR_ValueDef_out + { + public: +- ValueDef_out (ValueDef_ptr &); +- ValueDef_out (ValueDef_var &); +- ValueDef_out (const ValueDef_out &); +- ValueDef_out &operator= (const ValueDef_out &); +- ValueDef_out &operator= (const ValueDef_var &); +- ValueDef_out &operator= (ValueDef_ptr); +- operator ValueDef_ptr &(); +- ValueDef_ptr &ptr (void); +- ValueDef_ptr operator-> (void); ++ IR_ValueDef_out (IR_ValueDef_ptr &); ++ IR_ValueDef_out (IR_ValueDef_var &); ++ IR_ValueDef_out (const IR_ValueDef_out &); ++ IR_ValueDef_out &operator= (const IR_ValueDef_out &); ++ IR_ValueDef_out &operator= (const IR_ValueDef_var &); ++ IR_ValueDef_out &operator= (IR_ValueDef_ptr); ++ operator IR_ValueDef_ptr &(); ++ IR_ValueDef_ptr &ptr (void); ++ IR_ValueDef_ptr operator-> (void); + + private: +- ValueDef_ptr &ptr_; ++ IR_ValueDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_VALUEDEFSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_VALUEDEFSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -2729,19 +1653,19 @@ + _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (CORBA::ULong maximum, + CORBA::ULong length, +- ValueDef* *value, ++ IR_ValueDef* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (void); + _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq &rhs); +- TAO_Object_Manager<IR::ValueDef,IR::ValueDef_var> operator[] (CORBA::ULong index) const; +- static ValueDef **allocbuf (CORBA::ULong nelems); +- static void freebuf (ValueDef **buffer); ++ TAO_Object_Manager<IR_ValueDef,IR_ValueDef_var> operator[] (CORBA::ULong index) const; ++ static IR_ValueDef **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_ValueDef **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- ValueDef* *get_buffer (CORBA::Boolean orphan = 0); +- const ValueDef* *get_buffer (void) const; ++ IR_ValueDef* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_ValueDef* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -2753,261 +1677,184 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_VALUEDEFSEQ_CH_) +-#define _TAO_IR_VALUEDEFSEQ_CH_ +- +-class ValueDefSeq; +-class ValueDefSeq_var; +- + // ************************************************************* +-// ValueDefSeq ++// IR_ValueDefSeq + // ************************************************************* + +-class TAO_Export ValueDefSeq : public ++class TAO_Export IR_ValueDefSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<ValueDef,ValueDef_var> ++ TAO_Unbounded_Object_Sequence<IR_ValueDef,IR_ValueDef_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- ValueDefSeq (void); // default ctor +- ValueDefSeq (CORBA::ULong max); // uses max size +- ValueDefSeq ( ++ IR_ValueDefSeq (void); // default ctor ++ IR_ValueDefSeq (CORBA::ULong max); // uses max size ++ IR_ValueDefSeq ( + CORBA::ULong max, + CORBA::ULong length, +- ValueDef_ptr *buffer, ++ IR_ValueDef_ptr *buffer, + CORBA::Boolean release = 0 + ); +- ValueDefSeq (const ValueDefSeq &); // copy ctor +- ~ValueDefSeq (void); ++ IR_ValueDefSeq (const IR_ValueDefSeq &); // copy ctor ++ ~IR_ValueDefSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ValueDefSeq_var _var_type; ++ typedef IR_ValueDefSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEDEFSEQ___VAR_CH_) +-#define _TAO_IR_VALUEDEFSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::ValueDefSeq_var ++// class IR_ValueDefSeq_var + // ************************************************************* + +-class TAO_Export ValueDefSeq_var ++class TAO_Export IR_ValueDefSeq_var + { + public: +- ValueDefSeq_var (void); // default constructor +- ValueDefSeq_var (ValueDefSeq *); +- ValueDefSeq_var (const ValueDefSeq_var &); // copy constructor +- ~ValueDefSeq_var (void); // destructor ++ IR_ValueDefSeq_var (void); // default constructor ++ IR_ValueDefSeq_var (IR_ValueDefSeq *); ++ IR_ValueDefSeq_var (const IR_ValueDefSeq_var &); // copy constructor ++ ~IR_ValueDefSeq_var (void); // destructor + +- ValueDefSeq_var &operator= (ValueDefSeq *); +- ValueDefSeq_var &operator= (const ValueDefSeq_var &); +- ValueDefSeq *operator-> (void); +- const ValueDefSeq *operator-> (void) const; ++ IR_ValueDefSeq_var &operator= (IR_ValueDefSeq *); ++ IR_ValueDefSeq_var &operator= (const IR_ValueDefSeq_var &); ++ IR_ValueDefSeq *operator-> (void); ++ const IR_ValueDefSeq *operator-> (void) const; + +- operator const ValueDefSeq &() const; +- operator ValueDefSeq &(); +- operator ValueDefSeq &() const; +- operator ValueDefSeq *&(); // variable-size base types only ++ operator const IR_ValueDefSeq &() const; ++ operator IR_ValueDefSeq &(); ++ operator IR_ValueDefSeq &() const; ++ operator IR_ValueDefSeq *&(); // variable-size base types only + +- TAO_Object_Manager<ValueDef, ValueDef_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_ValueDef, IR_ValueDef_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const ValueDefSeq &in (void) const; +- ValueDefSeq &inout (void); +- ValueDefSeq *&out (void); +- ValueDefSeq *_retn (void); +- ValueDefSeq *ptr (void) const; ++ const IR_ValueDefSeq &in (void) const; ++ IR_ValueDefSeq &inout (void); ++ IR_ValueDefSeq *&out (void); ++ IR_ValueDefSeq *_retn (void); ++ IR_ValueDefSeq *ptr (void) const; + + private: +- ValueDefSeq *ptr_; ++ IR_ValueDefSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEDEFSEQ___OUT_CH_) +-#define _TAO_IR_VALUEDEFSEQ___OUT_CH_ +- +-class TAO_Export ValueDefSeq_out ++class TAO_Export IR_ValueDefSeq_out + { + public: +- ValueDefSeq_out (ValueDefSeq *&); +- ValueDefSeq_out (ValueDefSeq_var &); +- ValueDefSeq_out (const ValueDefSeq_out &); +- ValueDefSeq_out &operator= (const ValueDefSeq_out &); +- ValueDefSeq_out &operator= (ValueDefSeq *); +- operator ValueDefSeq *&(); +- ValueDefSeq *&ptr (void); +- ValueDefSeq *operator-> (void); +- TAO_Object_Manager<ValueDef, ValueDef_var> operator[] (CORBA::ULong index); ++ IR_ValueDefSeq_out (IR_ValueDefSeq *&); ++ IR_ValueDefSeq_out (IR_ValueDefSeq_var &); ++ IR_ValueDefSeq_out (const IR_ValueDefSeq_out &); ++ IR_ValueDefSeq_out &operator= (const IR_ValueDefSeq_out &); ++ IR_ValueDefSeq_out &operator= (IR_ValueDefSeq *); ++ operator IR_ValueDefSeq *&(); ++ IR_ValueDefSeq *&ptr (void); ++ IR_ValueDefSeq *operator-> (void); ++ TAO_Object_Manager<IR_ValueDef, IR_ValueDef_var> operator[] (CORBA::ULong index); + + private: +- ValueDefSeq *&ptr_; ++ IR_ValueDefSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const ValueDefSeq_var &); ++ void operator= (const IR_ValueDefSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDefSeq; +- +-class ValueBoxDef; +- +-#if !defined (_TAO_IR_VALUEBOXDEF___PTR_CH_) +-#define _TAO_IR_VALUEBOXDEF___PTR_CH_ +- +-typedef ValueBoxDef *ValueBoxDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEBOXDEF___VAR_CH_) +-#define _TAO_IR_VALUEBOXDEF___VAR_CH_ +- +-class TAO_Export ValueBoxDef_var : public TAO_Base_var ++class TAO_Export IR_ValueBoxDef_var : public TAO_Base_var + { + public: +- ValueBoxDef_var (void); // default constructor +- ValueBoxDef_var (ValueBoxDef_ptr p) : ptr_ (p) {} +- ValueBoxDef_var (const ValueBoxDef_var &); // copy constructor +- ~ValueBoxDef_var (void); // destructor ++ IR_ValueBoxDef_var (void); // default constructor ++ IR_ValueBoxDef_var (IR_ValueBoxDef_ptr p) : ptr_ (p) {} ++ IR_ValueBoxDef_var (const IR_ValueBoxDef_var &); // copy constructor ++ ~IR_ValueBoxDef_var (void); // destructor + +- ValueBoxDef_var &operator= (ValueBoxDef_ptr); +- ValueBoxDef_var &operator= (const ValueBoxDef_var &); +- ValueBoxDef_ptr operator-> (void) const; ++ IR_ValueBoxDef_var &operator= (IR_ValueBoxDef_ptr); ++ IR_ValueBoxDef_var &operator= (const IR_ValueBoxDef_var &); ++ IR_ValueBoxDef_ptr operator-> (void) const; + +- operator const ValueBoxDef_ptr &() const; +- operator ValueBoxDef_ptr &(); ++ operator const IR_ValueBoxDef_ptr &() const; ++ operator IR_ValueBoxDef_ptr &(); + // in, inout, out, _retn +- ValueBoxDef_ptr in (void) const; +- ValueBoxDef_ptr &inout (void); +- ValueBoxDef_ptr &out (void); +- ValueBoxDef_ptr _retn (void); +- ValueBoxDef_ptr ptr (void) const; ++ IR_ValueBoxDef_ptr in (void) const; ++ IR_ValueBoxDef_ptr &inout (void); ++ IR_ValueBoxDef_ptr &out (void); ++ IR_ValueBoxDef_ptr _retn (void); ++ IR_ValueBoxDef_ptr ptr (void) const; + + private: +- ValueBoxDef_ptr ptr_; ++ IR_ValueBoxDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- ValueBoxDef_var (const TAO_Base_var &rhs); +- ValueBoxDef_var &operator= (const TAO_Base_var &rhs); ++ IR_ValueBoxDef_var (const TAO_Base_var &rhs); ++ IR_ValueBoxDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEBOXDEF___OUT_CH_) +-#define _TAO_IR_VALUEBOXDEF___OUT_CH_ +- +-class TAO_Export ValueBoxDef_out ++class TAO_Export IR_ValueBoxDef_out + { + public: +- ValueBoxDef_out (ValueBoxDef_ptr &); +- ValueBoxDef_out (ValueBoxDef_var &); +- ValueBoxDef_out (const ValueBoxDef_out &); +- ValueBoxDef_out &operator= (const ValueBoxDef_out &); +- ValueBoxDef_out &operator= (const ValueBoxDef_var &); +- ValueBoxDef_out &operator= (ValueBoxDef_ptr); +- operator ValueBoxDef_ptr &(); +- ValueBoxDef_ptr &ptr (void); +- ValueBoxDef_ptr operator-> (void); ++ IR_ValueBoxDef_out (IR_ValueBoxDef_ptr &); ++ IR_ValueBoxDef_out (IR_ValueBoxDef_var &); ++ IR_ValueBoxDef_out (const IR_ValueBoxDef_out &); ++ IR_ValueBoxDef_out &operator= (const IR_ValueBoxDef_out &); ++ IR_ValueBoxDef_out &operator= (const IR_ValueBoxDef_var &); ++ IR_ValueBoxDef_out &operator= (IR_ValueBoxDef_ptr); ++ operator IR_ValueBoxDef_ptr &(); ++ IR_ValueBoxDef_ptr &ptr (void); ++ IR_ValueBoxDef_ptr operator-> (void); + + private: +- ValueBoxDef_ptr &ptr_; ++ IR_ValueBoxDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class ComponentDef; +- +-#if !defined (_TAO_IR_COMPONENTDEF___PTR_CH_) +-#define _TAO_IR_COMPONENTDEF___PTR_CH_ +- +-typedef ComponentDef *ComponentDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_COMPONENTDEF___VAR_CH_) +-#define _TAO_IR_COMPONENTDEF___VAR_CH_ +- +-class TAO_Export ComponentDef_var : public TAO_Base_var ++class TAO_Export IR_ComponentDef_var : public TAO_Base_var + { + public: +- ComponentDef_var (void); // default constructor +- ComponentDef_var (ComponentDef_ptr p) : ptr_ (p) {} +- ComponentDef_var (const ComponentDef_var &); // copy constructor +- ~ComponentDef_var (void); // destructor ++ IR_ComponentDef_var (void); // default constructor ++ IR_ComponentDef_var (IR_ComponentDef_ptr p) : ptr_ (p) {} ++ IR_ComponentDef_var (const IR_ComponentDef_var &); // copy constructor ++ ~IR_ComponentDef_var (void); // destructor + +- ComponentDef_var &operator= (ComponentDef_ptr); +- ComponentDef_var &operator= (const ComponentDef_var &); +- ComponentDef_ptr operator-> (void) const; ++ IR_ComponentDef_var &operator= (IR_ComponentDef_ptr); ++ IR_ComponentDef_var &operator= (const IR_ComponentDef_var &); ++ IR_ComponentDef_ptr operator-> (void) const; + +- operator const ComponentDef_ptr &() const; +- operator ComponentDef_ptr &(); ++ operator const IR_ComponentDef_ptr &() const; ++ operator IR_ComponentDef_ptr &(); + // in, inout, out, _retn +- ComponentDef_ptr in (void) const; +- ComponentDef_ptr &inout (void); +- ComponentDef_ptr &out (void); +- ComponentDef_ptr _retn (void); +- ComponentDef_ptr ptr (void) const; ++ IR_ComponentDef_ptr in (void) const; ++ IR_ComponentDef_ptr &inout (void); ++ IR_ComponentDef_ptr &out (void); ++ IR_ComponentDef_ptr _retn (void); ++ IR_ComponentDef_ptr ptr (void) const; + + private: +- ComponentDef_ptr ptr_; ++ IR_ComponentDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- ComponentDef_var (const TAO_Base_var &rhs); +- ComponentDef_var &operator= (const TAO_Base_var &rhs); ++ IR_ComponentDef_var (const TAO_Base_var &rhs); ++ IR_ComponentDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_COMPONENTDEF___OUT_CH_) +-#define _TAO_IR_COMPONENTDEF___OUT_CH_ +- +-class TAO_Export ComponentDef_out ++class TAO_Export IR_ComponentDef_out + { + public: +- ComponentDef_out (ComponentDef_ptr &); +- ComponentDef_out (ComponentDef_var &); +- ComponentDef_out (const ComponentDef_out &); +- ComponentDef_out &operator= (const ComponentDef_out &); +- ComponentDef_out &operator= (const ComponentDef_var &); +- ComponentDef_out &operator= (ComponentDef_ptr); +- operator ComponentDef_ptr &(); +- ComponentDef_ptr &ptr (void); +- ComponentDef_ptr operator-> (void); ++ IR_ComponentDef_out (IR_ComponentDef_ptr &); ++ IR_ComponentDef_out (IR_ComponentDef_var &); ++ IR_ComponentDef_out (const IR_ComponentDef_out &); ++ IR_ComponentDef_out &operator= (const IR_ComponentDef_out &); ++ IR_ComponentDef_out &operator= (const IR_ComponentDef_var &); ++ IR_ComponentDef_out &operator= (IR_ComponentDef_ptr); ++ operator IR_ComponentDef_ptr &(); ++ IR_ComponentDef_ptr &ptr (void); ++ IR_ComponentDef_ptr operator-> (void); + + private: +- ComponentDef_ptr &ptr_; ++ IR_ComponentDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -3017,19 +1864,19 @@ + _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum, + CORBA::ULong length, +- ComponentDef* *value, ++ IR_ComponentDef* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (void); + _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &rhs); +- TAO_Object_Manager<IR::ComponentDef,IR::ComponentDef_var> operator[] (CORBA::ULong index) const; +- static ComponentDef **allocbuf (CORBA::ULong nelems); +- static void freebuf (ComponentDef **buffer); ++ TAO_Object_Manager<IR_ComponentDef,IR_ComponentDef_var> operator[] (CORBA::ULong index) const; ++ static IR_ComponentDef **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_ComponentDef **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- ComponentDef* *get_buffer (CORBA::Boolean orphan = 0); +- const ComponentDef* *get_buffer (void) const; ++ IR_ComponentDef* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_ComponentDef* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -3041,193 +1888,139 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_COMPONENTDEFSEQ_CH_) +-#define _TAO_IR_COMPONENTDEFSEQ_CH_ +- +-class ComponentDefSeq; +-class ComponentDefSeq_var; +- + // ************************************************************* +-// ComponentDefSeq ++// IR_ComponentDefSeq + // ************************************************************* + +-class TAO_Export ComponentDefSeq : public ++class TAO_Export IR_ComponentDefSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<ComponentDef,ComponentDef_var> ++ TAO_Unbounded_Object_Sequence<IR_ComponentDef,IR_ComponentDef_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- ComponentDefSeq (void); // default ctor +- ComponentDefSeq (CORBA::ULong max); // uses max size +- ComponentDefSeq ( ++ IR_ComponentDefSeq (void); // default ctor ++ IR_ComponentDefSeq (CORBA::ULong max); // uses max size ++ IR_ComponentDefSeq ( + CORBA::ULong max, + CORBA::ULong length, +- ComponentDef_ptr *buffer, ++ IR_ComponentDef_ptr *buffer, + CORBA::Boolean release = 0 + ); +- ComponentDefSeq (const ComponentDefSeq &); // copy ctor +- ~ComponentDefSeq (void); ++ IR_ComponentDefSeq (const IR_ComponentDefSeq &); // copy ctor ++ ~IR_ComponentDefSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ComponentDefSeq_var _var_type; ++ typedef IR_ComponentDefSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_COMPONENTDEFSEQ___VAR_CH_) +-#define _TAO_IR_COMPONENTDEFSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::ComponentDefSeq_var ++// class IR_ComponentDefSeq_var + // ************************************************************* + +-class TAO_Export ComponentDefSeq_var ++class TAO_Export IR_ComponentDefSeq_var + { + public: +- ComponentDefSeq_var (void); // default constructor +- ComponentDefSeq_var (ComponentDefSeq *); +- ComponentDefSeq_var (const ComponentDefSeq_var &); // copy constructor +- ~ComponentDefSeq_var (void); // destructor ++ IR_ComponentDefSeq_var (void); // default constructor ++ IR_ComponentDefSeq_var (IR_ComponentDefSeq *); ++ IR_ComponentDefSeq_var (const IR_ComponentDefSeq_var &); // copy constructor ++ ~IR_ComponentDefSeq_var (void); // destructor + +- ComponentDefSeq_var &operator= (ComponentDefSeq *); +- ComponentDefSeq_var &operator= (const ComponentDefSeq_var &); +- ComponentDefSeq *operator-> (void); +- const ComponentDefSeq *operator-> (void) const; ++ IR_ComponentDefSeq_var &operator= (IR_ComponentDefSeq *); ++ IR_ComponentDefSeq_var &operator= (const IR_ComponentDefSeq_var &); ++ IR_ComponentDefSeq *operator-> (void); ++ const IR_ComponentDefSeq *operator-> (void) const; + +- operator const ComponentDefSeq &() const; +- operator ComponentDefSeq &(); +- operator ComponentDefSeq &() const; +- operator ComponentDefSeq *&(); // variable-size base types only ++ operator const IR_ComponentDefSeq &() const; ++ operator IR_ComponentDefSeq &(); ++ operator IR_ComponentDefSeq &() const; ++ operator IR_ComponentDefSeq *&(); // variable-size base types only + +- TAO_Object_Manager<ComponentDef, ComponentDef_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_ComponentDef, IR_ComponentDef_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const ComponentDefSeq &in (void) const; +- ComponentDefSeq &inout (void); +- ComponentDefSeq *&out (void); +- ComponentDefSeq *_retn (void); +- ComponentDefSeq *ptr (void) const; ++ const IR_ComponentDefSeq &in (void) const; ++ IR_ComponentDefSeq &inout (void); ++ IR_ComponentDefSeq *&out (void); ++ IR_ComponentDefSeq *_retn (void); ++ IR_ComponentDefSeq *ptr (void) const; + + private: +- ComponentDefSeq *ptr_; ++ IR_ComponentDefSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_COMPONENTDEFSEQ___OUT_CH_) +-#define _TAO_IR_COMPONENTDEFSEQ___OUT_CH_ +- +-class TAO_Export ComponentDefSeq_out ++class TAO_Export IR_ComponentDefSeq_out + { + public: +- ComponentDefSeq_out (ComponentDefSeq *&); +- ComponentDefSeq_out (ComponentDefSeq_var &); +- ComponentDefSeq_out (const ComponentDefSeq_out &); +- ComponentDefSeq_out &operator= (const ComponentDefSeq_out &); +- ComponentDefSeq_out &operator= (ComponentDefSeq *); +- operator ComponentDefSeq *&(); +- ComponentDefSeq *&ptr (void); +- ComponentDefSeq *operator-> (void); +- TAO_Object_Manager<ComponentDef, ComponentDef_var> operator[] (CORBA::ULong index); ++ IR_ComponentDefSeq_out (IR_ComponentDefSeq *&); ++ IR_ComponentDefSeq_out (IR_ComponentDefSeq_var &); ++ IR_ComponentDefSeq_out (const IR_ComponentDefSeq_out &); ++ IR_ComponentDefSeq_out &operator= (const IR_ComponentDefSeq_out &); ++ IR_ComponentDefSeq_out &operator= (IR_ComponentDefSeq *); ++ operator IR_ComponentDefSeq *&(); ++ IR_ComponentDefSeq *&ptr (void); ++ IR_ComponentDefSeq *operator-> (void); ++ TAO_Object_Manager<IR_ComponentDef, IR_ComponentDef_var> operator[] (CORBA::ULong index); + + private: +- ComponentDefSeq *&ptr_; ++ IR_ComponentDefSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const ComponentDefSeq_var &); ++ void operator= (const IR_ComponentDefSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentDefSeq; +- +-class ProvidesDef; +- +-#if !defined (_TAO_IR_PROVIDESDEF___PTR_CH_) +-#define _TAO_IR_PROVIDESDEF___PTR_CH_ +- +-typedef ProvidesDef *ProvidesDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PROVIDESDEF___VAR_CH_) +-#define _TAO_IR_PROVIDESDEF___VAR_CH_ +- +-class TAO_Export ProvidesDef_var : public TAO_Base_var ++class TAO_Export IR_ProvidesDef_var : public TAO_Base_var + { + public: +- ProvidesDef_var (void); // default constructor +- ProvidesDef_var (ProvidesDef_ptr p) : ptr_ (p) {} +- ProvidesDef_var (const ProvidesDef_var &); // copy constructor +- ~ProvidesDef_var (void); // destructor ++ IR_ProvidesDef_var (void); // default constructor ++ IR_ProvidesDef_var (IR_ProvidesDef_ptr p) : ptr_ (p) {} ++ IR_ProvidesDef_var (const IR_ProvidesDef_var &); // copy constructor ++ ~IR_ProvidesDef_var (void); // destructor + +- ProvidesDef_var &operator= (ProvidesDef_ptr); +- ProvidesDef_var &operator= (const ProvidesDef_var &); +- ProvidesDef_ptr operator-> (void) const; ++ IR_ProvidesDef_var &operator= (IR_ProvidesDef_ptr); ++ IR_ProvidesDef_var &operator= (const IR_ProvidesDef_var &); ++ IR_ProvidesDef_ptr operator-> (void) const; + +- operator const ProvidesDef_ptr &() const; +- operator ProvidesDef_ptr &(); ++ operator const IR_ProvidesDef_ptr &() const; ++ operator IR_ProvidesDef_ptr &(); + // in, inout, out, _retn +- ProvidesDef_ptr in (void) const; +- ProvidesDef_ptr &inout (void); +- ProvidesDef_ptr &out (void); +- ProvidesDef_ptr _retn (void); +- ProvidesDef_ptr ptr (void) const; ++ IR_ProvidesDef_ptr in (void) const; ++ IR_ProvidesDef_ptr &inout (void); ++ IR_ProvidesDef_ptr &out (void); ++ IR_ProvidesDef_ptr _retn (void); ++ IR_ProvidesDef_ptr ptr (void) const; + + private: +- ProvidesDef_ptr ptr_; ++ IR_ProvidesDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- ProvidesDef_var (const TAO_Base_var &rhs); +- ProvidesDef_var &operator= (const TAO_Base_var &rhs); ++ IR_ProvidesDef_var (const TAO_Base_var &rhs); ++ IR_ProvidesDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PROVIDESDEF___OUT_CH_) +-#define _TAO_IR_PROVIDESDEF___OUT_CH_ +- +-class TAO_Export ProvidesDef_out ++class TAO_Export IR_ProvidesDef_out + { + public: +- ProvidesDef_out (ProvidesDef_ptr &); +- ProvidesDef_out (ProvidesDef_var &); +- ProvidesDef_out (const ProvidesDef_out &); +- ProvidesDef_out &operator= (const ProvidesDef_out &); +- ProvidesDef_out &operator= (const ProvidesDef_var &); +- ProvidesDef_out &operator= (ProvidesDef_ptr); +- operator ProvidesDef_ptr &(); +- ProvidesDef_ptr &ptr (void); +- ProvidesDef_ptr operator-> (void); ++ IR_ProvidesDef_out (IR_ProvidesDef_ptr &); ++ IR_ProvidesDef_out (IR_ProvidesDef_var &); ++ IR_ProvidesDef_out (const IR_ProvidesDef_out &); ++ IR_ProvidesDef_out &operator= (const IR_ProvidesDef_out &); ++ IR_ProvidesDef_out &operator= (const IR_ProvidesDef_var &); ++ IR_ProvidesDef_out &operator= (IR_ProvidesDef_ptr); ++ operator IR_ProvidesDef_ptr &(); ++ IR_ProvidesDef_ptr &ptr (void); ++ IR_ProvidesDef_ptr operator-> (void); + + private: +- ProvidesDef_ptr &ptr_; ++ IR_ProvidesDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -3237,19 +2030,19 @@ + _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum, + CORBA::ULong length, +- ProvidesDef* *value, ++ IR_ProvidesDef* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (void); + _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &rhs); +- TAO_Object_Manager<IR::ProvidesDef,IR::ProvidesDef_var> operator[] (CORBA::ULong index) const; +- static ProvidesDef **allocbuf (CORBA::ULong nelems); +- static void freebuf (ProvidesDef **buffer); ++ TAO_Object_Manager<IR_ProvidesDef,IR_ProvidesDef_var> operator[] (CORBA::ULong index) const; ++ static IR_ProvidesDef **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_ProvidesDef **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- ProvidesDef* *get_buffer (CORBA::Boolean orphan = 0); +- const ProvidesDef* *get_buffer (void) const; ++ IR_ProvidesDef* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_ProvidesDef* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -3261,193 +2054,139 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_PROVIDESDEFSEQ_CH_) +-#define _TAO_IR_PROVIDESDEFSEQ_CH_ +- +-class ProvidesDefSeq; +-class ProvidesDefSeq_var; +- + // ************************************************************* +-// ProvidesDefSeq ++// IR_ProvidesDefSeq + // ************************************************************* + +-class TAO_Export ProvidesDefSeq : public ++class TAO_Export IR_ProvidesDefSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<ProvidesDef,ProvidesDef_var> ++ TAO_Unbounded_Object_Sequence<IR_ProvidesDef,IR_ProvidesDef_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- ProvidesDefSeq (void); // default ctor +- ProvidesDefSeq (CORBA::ULong max); // uses max size +- ProvidesDefSeq ( ++ IR_ProvidesDefSeq (void); // default ctor ++ IR_ProvidesDefSeq (CORBA::ULong max); // uses max size ++ IR_ProvidesDefSeq ( + CORBA::ULong max, + CORBA::ULong length, +- ProvidesDef_ptr *buffer, ++ IR_ProvidesDef_ptr *buffer, + CORBA::Boolean release = 0 + ); +- ProvidesDefSeq (const ProvidesDefSeq &); // copy ctor +- ~ProvidesDefSeq (void); ++ IR_ProvidesDefSeq (const IR_ProvidesDefSeq &); // copy ctor ++ ~IR_ProvidesDefSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ProvidesDefSeq_var _var_type; ++ typedef IR_ProvidesDefSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PROVIDESDEFSEQ___VAR_CH_) +-#define _TAO_IR_PROVIDESDEFSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::ProvidesDefSeq_var ++// class IR_ProvidesDefSeq_var + // ************************************************************* + +-class TAO_Export ProvidesDefSeq_var ++class TAO_Export IR_ProvidesDefSeq_var + { + public: +- ProvidesDefSeq_var (void); // default constructor +- ProvidesDefSeq_var (ProvidesDefSeq *); +- ProvidesDefSeq_var (const ProvidesDefSeq_var &); // copy constructor +- ~ProvidesDefSeq_var (void); // destructor ++ IR_ProvidesDefSeq_var (void); // default constructor ++ IR_ProvidesDefSeq_var (IR_ProvidesDefSeq *); ++ IR_ProvidesDefSeq_var (const IR_ProvidesDefSeq_var &); // copy constructor ++ ~IR_ProvidesDefSeq_var (void); // destructor + +- ProvidesDefSeq_var &operator= (ProvidesDefSeq *); +- ProvidesDefSeq_var &operator= (const ProvidesDefSeq_var &); +- ProvidesDefSeq *operator-> (void); +- const ProvidesDefSeq *operator-> (void) const; ++ IR_ProvidesDefSeq_var &operator= (IR_ProvidesDefSeq *); ++ IR_ProvidesDefSeq_var &operator= (const IR_ProvidesDefSeq_var &); ++ IR_ProvidesDefSeq *operator-> (void); ++ const IR_ProvidesDefSeq *operator-> (void) const; + +- operator const ProvidesDefSeq &() const; +- operator ProvidesDefSeq &(); +- operator ProvidesDefSeq &() const; +- operator ProvidesDefSeq *&(); // variable-size base types only ++ operator const IR_ProvidesDefSeq &() const; ++ operator IR_ProvidesDefSeq &(); ++ operator IR_ProvidesDefSeq &() const; ++ operator IR_ProvidesDefSeq *&(); // variable-size base types only + +- TAO_Object_Manager<ProvidesDef, ProvidesDef_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_ProvidesDef, IR_ProvidesDef_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const ProvidesDefSeq &in (void) const; +- ProvidesDefSeq &inout (void); +- ProvidesDefSeq *&out (void); +- ProvidesDefSeq *_retn (void); +- ProvidesDefSeq *ptr (void) const; ++ const IR_ProvidesDefSeq &in (void) const; ++ IR_ProvidesDefSeq &inout (void); ++ IR_ProvidesDefSeq *&out (void); ++ IR_ProvidesDefSeq *_retn (void); ++ IR_ProvidesDefSeq *ptr (void) const; + + private: +- ProvidesDefSeq *ptr_; ++ IR_ProvidesDefSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PROVIDESDEFSEQ___OUT_CH_) +-#define _TAO_IR_PROVIDESDEFSEQ___OUT_CH_ +- +-class TAO_Export ProvidesDefSeq_out ++class TAO_Export IR_ProvidesDefSeq_out + { + public: +- ProvidesDefSeq_out (ProvidesDefSeq *&); +- ProvidesDefSeq_out (ProvidesDefSeq_var &); +- ProvidesDefSeq_out (const ProvidesDefSeq_out &); +- ProvidesDefSeq_out &operator= (const ProvidesDefSeq_out &); +- ProvidesDefSeq_out &operator= (ProvidesDefSeq *); +- operator ProvidesDefSeq *&(); +- ProvidesDefSeq *&ptr (void); +- ProvidesDefSeq *operator-> (void); +- TAO_Object_Manager<ProvidesDef, ProvidesDef_var> operator[] (CORBA::ULong index); ++ IR_ProvidesDefSeq_out (IR_ProvidesDefSeq *&); ++ IR_ProvidesDefSeq_out (IR_ProvidesDefSeq_var &); ++ IR_ProvidesDefSeq_out (const IR_ProvidesDefSeq_out &); ++ IR_ProvidesDefSeq_out &operator= (const IR_ProvidesDefSeq_out &); ++ IR_ProvidesDefSeq_out &operator= (IR_ProvidesDefSeq *); ++ operator IR_ProvidesDefSeq *&(); ++ IR_ProvidesDefSeq *&ptr (void); ++ IR_ProvidesDefSeq *operator-> (void); ++ TAO_Object_Manager<IR_ProvidesDef, IR_ProvidesDef_var> operator[] (CORBA::ULong index); + + private: +- ProvidesDefSeq *&ptr_; ++ IR_ProvidesDefSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const ProvidesDefSeq_var &); ++ void operator= (const IR_ProvidesDefSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDefSeq; +- +-class UsesDef; +- +-#if !defined (_TAO_IR_USESDEF___PTR_CH_) +-#define _TAO_IR_USESDEF___PTR_CH_ +- +-typedef UsesDef *UsesDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_USESDEF___VAR_CH_) +-#define _TAO_IR_USESDEF___VAR_CH_ +- +-class TAO_Export UsesDef_var : public TAO_Base_var ++class TAO_Export IR_UsesDef_var : public TAO_Base_var + { + public: +- UsesDef_var (void); // default constructor +- UsesDef_var (UsesDef_ptr p) : ptr_ (p) {} +- UsesDef_var (const UsesDef_var &); // copy constructor +- ~UsesDef_var (void); // destructor ++ IR_UsesDef_var (void); // default constructor ++ IR_UsesDef_var (IR_UsesDef_ptr p) : ptr_ (p) {} ++ IR_UsesDef_var (const IR_UsesDef_var &); // copy constructor ++ ~IR_UsesDef_var (void); // destructor + +- UsesDef_var &operator= (UsesDef_ptr); +- UsesDef_var &operator= (const UsesDef_var &); +- UsesDef_ptr operator-> (void) const; ++ IR_UsesDef_var &operator= (IR_UsesDef_ptr); ++ IR_UsesDef_var &operator= (const IR_UsesDef_var &); ++ IR_UsesDef_ptr operator-> (void) const; + +- operator const UsesDef_ptr &() const; +- operator UsesDef_ptr &(); ++ operator const IR_UsesDef_ptr &() const; ++ operator IR_UsesDef_ptr &(); + // in, inout, out, _retn +- UsesDef_ptr in (void) const; +- UsesDef_ptr &inout (void); +- UsesDef_ptr &out (void); +- UsesDef_ptr _retn (void); +- UsesDef_ptr ptr (void) const; ++ IR_UsesDef_ptr in (void) const; ++ IR_UsesDef_ptr &inout (void); ++ IR_UsesDef_ptr &out (void); ++ IR_UsesDef_ptr _retn (void); ++ IR_UsesDef_ptr ptr (void) const; + + private: +- UsesDef_ptr ptr_; ++ IR_UsesDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- UsesDef_var (const TAO_Base_var &rhs); +- UsesDef_var &operator= (const TAO_Base_var &rhs); ++ IR_UsesDef_var (const TAO_Base_var &rhs); ++ IR_UsesDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_USESDEF___OUT_CH_) +-#define _TAO_IR_USESDEF___OUT_CH_ +- +-class TAO_Export UsesDef_out ++class TAO_Export IR_UsesDef_out + { + public: +- UsesDef_out (UsesDef_ptr &); +- UsesDef_out (UsesDef_var &); +- UsesDef_out (const UsesDef_out &); +- UsesDef_out &operator= (const UsesDef_out &); +- UsesDef_out &operator= (const UsesDef_var &); +- UsesDef_out &operator= (UsesDef_ptr); +- operator UsesDef_ptr &(); +- UsesDef_ptr &ptr (void); +- UsesDef_ptr operator-> (void); ++ IR_UsesDef_out (IR_UsesDef_ptr &); ++ IR_UsesDef_out (IR_UsesDef_var &); ++ IR_UsesDef_out (const IR_UsesDef_out &); ++ IR_UsesDef_out &operator= (const IR_UsesDef_out &); ++ IR_UsesDef_out &operator= (const IR_UsesDef_var &); ++ IR_UsesDef_out &operator= (IR_UsesDef_ptr); ++ operator IR_UsesDef_ptr &(); ++ IR_UsesDef_ptr &ptr (void); ++ IR_UsesDef_ptr operator-> (void); + + private: +- UsesDef_ptr &ptr_; ++ IR_UsesDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -3457,19 +2196,19 @@ + _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum, + CORBA::ULong length, +- UsesDef* *value, ++ IR_UsesDef* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (void); + _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &rhs); +- TAO_Object_Manager<IR::UsesDef,IR::UsesDef_var> operator[] (CORBA::ULong index) const; +- static UsesDef **allocbuf (CORBA::ULong nelems); +- static void freebuf (UsesDef **buffer); ++ TAO_Object_Manager<IR_UsesDef,IR_UsesDef_var> operator[] (CORBA::ULong index) const; ++ static IR_UsesDef **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_UsesDef **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- UsesDef* *get_buffer (CORBA::Boolean orphan = 0); +- const UsesDef* *get_buffer (void) const; ++ IR_UsesDef* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_UsesDef* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -3481,193 +2220,140 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_USESDEFSEQ_CH_) +-#define _TAO_IR_USESDEFSEQ_CH_ +- +-class UsesDefSeq; +-class UsesDefSeq_var; +- + // ************************************************************* +-// UsesDefSeq ++// IR_UsesDefSeq + // ************************************************************* + +-class TAO_Export UsesDefSeq : public ++class TAO_Export IR_UsesDefSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<UsesDef,UsesDef_var> ++ TAO_Unbounded_Object_Sequence<IR_UsesDef,IR_UsesDef_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- UsesDefSeq (void); // default ctor +- UsesDefSeq (CORBA::ULong max); // uses max size +- UsesDefSeq ( ++ IR_UsesDefSeq (void); // default ctor ++ IR_UsesDefSeq (CORBA::ULong max); // uses max size ++ IR_UsesDefSeq ( + CORBA::ULong max, + CORBA::ULong length, +- UsesDef_ptr *buffer, ++ IR_UsesDef_ptr *buffer, + CORBA::Boolean release = 0 + ); +- UsesDefSeq (const UsesDefSeq &); // copy ctor +- ~UsesDefSeq (void); ++ IR_UsesDefSeq (const IR_UsesDefSeq &); // copy ctor ++ ~IR_UsesDefSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef UsesDefSeq_var _var_type; ++ typedef IR_UsesDefSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_USESDEFSEQ___VAR_CH_) +-#define _TAO_IR_USESDEFSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::UsesDefSeq_var ++// class IR_UsesDefSeq_var + // ************************************************************* + +-class TAO_Export UsesDefSeq_var ++class TAO_Export IR_UsesDefSeq_var + { + public: +- UsesDefSeq_var (void); // default constructor +- UsesDefSeq_var (UsesDefSeq *); +- UsesDefSeq_var (const UsesDefSeq_var &); // copy constructor +- ~UsesDefSeq_var (void); // destructor ++ IR_UsesDefSeq_var (void); // default constructor ++ IR_UsesDefSeq_var (IR_UsesDefSeq *); ++ IR_UsesDefSeq_var (const IR_UsesDefSeq_var &); // copy constructor ++ ~IR_UsesDefSeq_var (void); // destructor + +- UsesDefSeq_var &operator= (UsesDefSeq *); +- UsesDefSeq_var &operator= (const UsesDefSeq_var &); +- UsesDefSeq *operator-> (void); +- const UsesDefSeq *operator-> (void) const; ++ IR_UsesDefSeq_var &operator= (IR_UsesDefSeq *); ++ IR_UsesDefSeq_var &operator= (const IR_UsesDefSeq_var &); ++ IR_UsesDefSeq *operator-> (void); ++ const IR_UsesDefSeq *operator-> (void) const; + +- operator const UsesDefSeq &() const; +- operator UsesDefSeq &(); +- operator UsesDefSeq &() const; +- operator UsesDefSeq *&(); // variable-size base types only ++ operator const IR_UsesDefSeq &() const; ++ operator IR_UsesDefSeq &(); ++ operator IR_UsesDefSeq &() const; ++ operator IR_UsesDefSeq *&(); // variable-size base types only + +- TAO_Object_Manager<UsesDef, UsesDef_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_UsesDef, IR_UsesDef_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const UsesDefSeq &in (void) const; +- UsesDefSeq &inout (void); +- UsesDefSeq *&out (void); +- UsesDefSeq *_retn (void); +- UsesDefSeq *ptr (void) const; ++ const IR_UsesDefSeq &in (void) const; ++ IR_UsesDefSeq &inout (void); ++ IR_UsesDefSeq *&out (void); ++ IR_UsesDefSeq *_retn (void); ++ IR_UsesDefSeq *ptr (void) const; + + private: +- UsesDefSeq *ptr_; ++ IR_UsesDefSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_USESDEFSEQ___OUT_CH_) +-#define _TAO_IR_USESDEFSEQ___OUT_CH_ +- +-class TAO_Export UsesDefSeq_out ++class TAO_Export IR_UsesDefSeq_out + { + public: +- UsesDefSeq_out (UsesDefSeq *&); +- UsesDefSeq_out (UsesDefSeq_var &); +- UsesDefSeq_out (const UsesDefSeq_out &); +- UsesDefSeq_out &operator= (const UsesDefSeq_out &); +- UsesDefSeq_out &operator= (UsesDefSeq *); +- operator UsesDefSeq *&(); +- UsesDefSeq *&ptr (void); +- UsesDefSeq *operator-> (void); +- TAO_Object_Manager<UsesDef, UsesDef_var> operator[] (CORBA::ULong index); ++ IR_UsesDefSeq_out (IR_UsesDefSeq *&); ++ IR_UsesDefSeq_out (IR_UsesDefSeq_var &); ++ IR_UsesDefSeq_out (const IR_UsesDefSeq_out &); ++ IR_UsesDefSeq_out &operator= (const IR_UsesDefSeq_out &); ++ IR_UsesDefSeq_out &operator= (IR_UsesDefSeq *); ++ operator IR_UsesDefSeq *&(); ++ IR_UsesDefSeq *&ptr (void); ++ IR_UsesDefSeq *operator-> (void); ++ TAO_Object_Manager<IR_UsesDef, IR_UsesDef_var> operator[] (CORBA::ULong index); + + private: +- UsesDefSeq *&ptr_; ++ IR_UsesDefSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const UsesDefSeq_var &); ++ void operator= (const IR_UsesDefSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDefSeq; +- +-class HomeDef; +- +-#if !defined (_TAO_IR_HOMEDEF___PTR_CH_) +-#define _TAO_IR_HOMEDEF___PTR_CH_ +- +-typedef HomeDef *HomeDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_HOMEDEF___VAR_CH_) +-#define _TAO_IR_HOMEDEF___VAR_CH_ +- +-class TAO_Export HomeDef_var : public TAO_Base_var ++class TAO_Export IR_HomeDef_var : public TAO_Base_var + { + public: +- HomeDef_var (void); // default constructor +- HomeDef_var (HomeDef_ptr p) : ptr_ (p) {} +- HomeDef_var (const HomeDef_var &); // copy constructor +- ~HomeDef_var (void); // destructor ++ IR_HomeDef_var (void); // default constructor ++ IR_HomeDef_var (IR_HomeDef_ptr p) : ptr_ (p) {} ++ IR_HomeDef_var (const IR_HomeDef_var &); // copy constructor ++ ~IR_HomeDef_var (void); // destructor + +- HomeDef_var &operator= (HomeDef_ptr); +- HomeDef_var &operator= (const HomeDef_var &); +- HomeDef_ptr operator-> (void) const; ++ IR_HomeDef_var &operator= (IR_HomeDef_ptr); ++ IR_HomeDef_var &operator= (const IR_HomeDef_var &); ++ IR_HomeDef_ptr operator-> (void) const; + +- operator const HomeDef_ptr &() const; +- operator HomeDef_ptr &(); ++ operator const IR_HomeDef_ptr &() const; ++ operator IR_HomeDef_ptr &(); + // in, inout, out, _retn +- HomeDef_ptr in (void) const; +- HomeDef_ptr &inout (void); +- HomeDef_ptr &out (void); +- HomeDef_ptr _retn (void); +- HomeDef_ptr ptr (void) const; ++ IR_HomeDef_ptr in (void) const; ++ IR_HomeDef_ptr &inout (void); ++ IR_HomeDef_ptr &out (void); ++ IR_HomeDef_ptr _retn (void); ++ IR_HomeDef_ptr ptr (void) const; + + private: +- HomeDef_ptr ptr_; ++ IR_HomeDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- HomeDef_var (const TAO_Base_var &rhs); +- HomeDef_var &operator= (const TAO_Base_var &rhs); ++ IR_HomeDef_var (const TAO_Base_var &rhs); ++ IR_HomeDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_HOMEDEF___OUT_CH_) +-#define _TAO_IR_HOMEDEF___OUT_CH_ +- +-class TAO_Export HomeDef_out ++class TAO_Export IR_HomeDef_out + { + public: +- HomeDef_out (HomeDef_ptr &); +- HomeDef_out (HomeDef_var &); +- HomeDef_out (const HomeDef_out &); +- HomeDef_out &operator= (const HomeDef_out &); +- HomeDef_out &operator= (const HomeDef_var &); +- HomeDef_out &operator= (HomeDef_ptr); +- operator HomeDef_ptr &(); +- HomeDef_ptr &ptr (void); +- HomeDef_ptr operator-> (void); ++ IR_HomeDef_out (IR_HomeDef_ptr &); ++ IR_HomeDef_out (IR_HomeDef_var &); ++ IR_HomeDef_out (const IR_HomeDef_out &); ++ IR_HomeDef_out &operator= (const IR_HomeDef_out &); ++ IR_HomeDef_out &operator= (const IR_HomeDef_var &); ++ IR_HomeDef_out &operator= (IR_HomeDef_ptr); ++ operator IR_HomeDef_ptr &(); ++ IR_HomeDef_ptr &ptr (void); ++ IR_HomeDef_ptr operator-> (void); + + private: +- HomeDef_ptr &ptr_; ++ IR_HomeDef_ptr &ptr_; + }; + + +-#endif /* end #if !defined */ +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -3677,19 +2363,19 @@ + _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum, + CORBA::ULong length, +- HomeDef* *value, ++ IR_HomeDef* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq(const _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (void); + _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &rhs); +- TAO_Object_Manager<IR::HomeDef,IR::HomeDef_var> operator[] (CORBA::ULong index) const; +- static HomeDef **allocbuf (CORBA::ULong nelems); +- static void freebuf (HomeDef **buffer); ++ TAO_Object_Manager<IR_HomeDef,IR_HomeDef_var> operator[] (CORBA::ULong index) const; ++ static IR_HomeDef **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_HomeDef **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- HomeDef* *get_buffer (CORBA::Boolean orphan = 0); +- const HomeDef* *get_buffer (void) const; ++ IR_HomeDef* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_HomeDef* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -3701,261 +2387,184 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_HOMEDEFSEQ_CH_) +-#define _TAO_IR_HOMEDEFSEQ_CH_ +- +-class HomeDefSeq; +-class HomeDefSeq_var; +- + // ************************************************************* +-// HomeDefSeq ++// IR_HomeDefSeq + // ************************************************************* + +-class TAO_Export HomeDefSeq : public ++class TAO_Export IR_HomeDefSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<HomeDef,HomeDef_var> ++ TAO_Unbounded_Object_Sequence<IR_HomeDef,IR_HomeDef_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- HomeDefSeq (void); // default ctor +- HomeDefSeq (CORBA::ULong max); // uses max size +- HomeDefSeq ( ++ IR_HomeDefSeq (void); // default ctor ++ IR_HomeDefSeq (CORBA::ULong max); // uses max size ++ IR_HomeDefSeq ( + CORBA::ULong max, + CORBA::ULong length, +- HomeDef_ptr *buffer, ++ IR_HomeDef_ptr *buffer, + CORBA::Boolean release = 0 + ); +- HomeDefSeq (const HomeDefSeq &); // copy ctor +- ~HomeDefSeq (void); ++ IR_HomeDefSeq (const IR_HomeDefSeq &); // copy ctor ++ ~IR_HomeDefSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef HomeDefSeq_var _var_type; ++ typedef IR_HomeDefSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_HOMEDEFSEQ___VAR_CH_) +-#define _TAO_IR_HOMEDEFSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::HomeDefSeq_var ++// class IR_HomeDefSeq_var + // ************************************************************* + +-class TAO_Export HomeDefSeq_var ++class TAO_Export IR_HomeDefSeq_var + { + public: +- HomeDefSeq_var (void); // default constructor +- HomeDefSeq_var (HomeDefSeq *); +- HomeDefSeq_var (const HomeDefSeq_var &); // copy constructor +- ~HomeDefSeq_var (void); // destructor ++ IR_HomeDefSeq_var (void); // default constructor ++ IR_HomeDefSeq_var (IR_HomeDefSeq *); ++ IR_HomeDefSeq_var (const IR_HomeDefSeq_var &); // copy constructor ++ ~IR_HomeDefSeq_var (void); // destructor + +- HomeDefSeq_var &operator= (HomeDefSeq *); +- HomeDefSeq_var &operator= (const HomeDefSeq_var &); +- HomeDefSeq *operator-> (void); +- const HomeDefSeq *operator-> (void) const; ++ IR_HomeDefSeq_var &operator= (IR_HomeDefSeq *); ++ IR_HomeDefSeq_var &operator= (const IR_HomeDefSeq_var &); ++ IR_HomeDefSeq *operator-> (void); ++ const IR_HomeDefSeq *operator-> (void) const; + +- operator const HomeDefSeq &() const; +- operator HomeDefSeq &(); +- operator HomeDefSeq &() const; +- operator HomeDefSeq *&(); // variable-size base types only ++ operator const IR_HomeDefSeq &() const; ++ operator IR_HomeDefSeq &(); ++ operator IR_HomeDefSeq &() const; ++ operator IR_HomeDefSeq *&(); // variable-size base types only + +- TAO_Object_Manager<HomeDef, HomeDef_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_HomeDef, IR_HomeDef_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const HomeDefSeq &in (void) const; +- HomeDefSeq &inout (void); +- HomeDefSeq *&out (void); +- HomeDefSeq *_retn (void); +- HomeDefSeq *ptr (void) const; ++ const IR_HomeDefSeq &in (void) const; ++ IR_HomeDefSeq &inout (void); ++ IR_HomeDefSeq *&out (void); ++ IR_HomeDefSeq *_retn (void); ++ IR_HomeDefSeq *ptr (void) const; + + private: +- HomeDefSeq *ptr_; ++ IR_HomeDefSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_HOMEDEFSEQ___OUT_CH_) +-#define _TAO_IR_HOMEDEFSEQ___OUT_CH_ +- +-class TAO_Export HomeDefSeq_out ++class TAO_Export IR_HomeDefSeq_out + { + public: +- HomeDefSeq_out (HomeDefSeq *&); +- HomeDefSeq_out (HomeDefSeq_var &); +- HomeDefSeq_out (const HomeDefSeq_out &); +- HomeDefSeq_out &operator= (const HomeDefSeq_out &); +- HomeDefSeq_out &operator= (HomeDefSeq *); +- operator HomeDefSeq *&(); +- HomeDefSeq *&ptr (void); +- HomeDefSeq *operator-> (void); +- TAO_Object_Manager<HomeDef, HomeDef_var> operator[] (CORBA::ULong index); ++ IR_HomeDefSeq_out (IR_HomeDefSeq *&); ++ IR_HomeDefSeq_out (IR_HomeDefSeq_var &); ++ IR_HomeDefSeq_out (const IR_HomeDefSeq_out &); ++ IR_HomeDefSeq_out &operator= (const IR_HomeDefSeq_out &); ++ IR_HomeDefSeq_out &operator= (IR_HomeDefSeq *); ++ operator IR_HomeDefSeq *&(); ++ IR_HomeDefSeq *&ptr (void); ++ IR_HomeDefSeq *operator-> (void); ++ TAO_Object_Manager<IR_HomeDef, IR_HomeDef_var> operator[] (CORBA::ULong index); + + private: +- HomeDefSeq *&ptr_; ++ IR_HomeDefSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const HomeDefSeq_var &); ++ void operator= (const IR_HomeDefSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HomeDefSeq; +- +-class EventDef; +- +-#if !defined (_TAO_IR_EVENTDEF___PTR_CH_) +-#define _TAO_IR_EVENTDEF___PTR_CH_ +- +-typedef EventDef *EventDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EVENTDEF___VAR_CH_) +-#define _TAO_IR_EVENTDEF___VAR_CH_ +- +-class TAO_Export EventDef_var : public TAO_Base_var ++class TAO_Export IR_EventDef_var : public TAO_Base_var + { + public: +- EventDef_var (void); // default constructor +- EventDef_var (EventDef_ptr p) : ptr_ (p) {} +- EventDef_var (const EventDef_var &); // copy constructor +- ~EventDef_var (void); // destructor ++ IR_EventDef_var (void); // default constructor ++ IR_EventDef_var (IR_EventDef_ptr p) : ptr_ (p) {} ++ IR_EventDef_var (const IR_EventDef_var &); // copy constructor ++ ~IR_EventDef_var (void); // destructor + +- EventDef_var &operator= (EventDef_ptr); +- EventDef_var &operator= (const EventDef_var &); +- EventDef_ptr operator-> (void) const; ++ IR_EventDef_var &operator= (IR_EventDef_ptr); ++ IR_EventDef_var &operator= (const IR_EventDef_var &); ++ IR_EventDef_ptr operator-> (void) const; + +- operator const EventDef_ptr &() const; +- operator EventDef_ptr &(); ++ operator const IR_EventDef_ptr &() const; ++ operator IR_EventDef_ptr &(); + // in, inout, out, _retn +- EventDef_ptr in (void) const; +- EventDef_ptr &inout (void); +- EventDef_ptr &out (void); +- EventDef_ptr _retn (void); +- EventDef_ptr ptr (void) const; ++ IR_EventDef_ptr in (void) const; ++ IR_EventDef_ptr &inout (void); ++ IR_EventDef_ptr &out (void); ++ IR_EventDef_ptr _retn (void); ++ IR_EventDef_ptr ptr (void) const; + + private: +- EventDef_ptr ptr_; ++ IR_EventDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- EventDef_var (const TAO_Base_var &rhs); +- EventDef_var &operator= (const TAO_Base_var &rhs); ++ IR_EventDef_var (const TAO_Base_var &rhs); ++ IR_EventDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EVENTDEF___OUT_CH_) +-#define _TAO_IR_EVENTDEF___OUT_CH_ +- +-class TAO_Export EventDef_out ++class TAO_Export IR_EventDef_out + { + public: +- EventDef_out (EventDef_ptr &); +- EventDef_out (EventDef_var &); +- EventDef_out (const EventDef_out &); +- EventDef_out &operator= (const EventDef_out &); +- EventDef_out &operator= (const EventDef_var &); +- EventDef_out &operator= (EventDef_ptr); +- operator EventDef_ptr &(); +- EventDef_ptr &ptr (void); +- EventDef_ptr operator-> (void); ++ IR_EventDef_out (IR_EventDef_ptr &); ++ IR_EventDef_out (IR_EventDef_var &); ++ IR_EventDef_out (const IR_EventDef_out &); ++ IR_EventDef_out &operator= (const IR_EventDef_out &); ++ IR_EventDef_out &operator= (const IR_EventDef_var &); ++ IR_EventDef_out &operator= (IR_EventDef_ptr); ++ operator IR_EventDef_ptr &(); ++ IR_EventDef_ptr &ptr (void); ++ IR_EventDef_ptr operator-> (void); + + private: +- EventDef_ptr &ptr_; ++ IR_EventDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class EmitsDef; +- +-#if !defined (_TAO_IR_EMITSDEF___PTR_CH_) +-#define _TAO_IR_EMITSDEF___PTR_CH_ +- +-typedef EmitsDef *EmitsDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EMITSDEF___VAR_CH_) +-#define _TAO_IR_EMITSDEF___VAR_CH_ +- +-class TAO_Export EmitsDef_var : public TAO_Base_var ++class TAO_Export IR_EmitsDef_var : public TAO_Base_var + { + public: +- EmitsDef_var (void); // default constructor +- EmitsDef_var (EmitsDef_ptr p) : ptr_ (p) {} +- EmitsDef_var (const EmitsDef_var &); // copy constructor +- ~EmitsDef_var (void); // destructor ++ IR_EmitsDef_var (void); // default constructor ++ IR_EmitsDef_var (IR_EmitsDef_ptr p) : ptr_ (p) {} ++ IR_EmitsDef_var (const IR_EmitsDef_var &); // copy constructor ++ ~IR_EmitsDef_var (void); // destructor + +- EmitsDef_var &operator= (EmitsDef_ptr); +- EmitsDef_var &operator= (const EmitsDef_var &); +- EmitsDef_ptr operator-> (void) const; ++ IR_EmitsDef_var &operator= (IR_EmitsDef_ptr); ++ IR_EmitsDef_var &operator= (const IR_EmitsDef_var &); ++ IR_EmitsDef_ptr operator-> (void) const; + +- operator const EmitsDef_ptr &() const; +- operator EmitsDef_ptr &(); ++ operator const IR_EmitsDef_ptr &() const; ++ operator IR_EmitsDef_ptr &(); + // in, inout, out, _retn +- EmitsDef_ptr in (void) const; +- EmitsDef_ptr &inout (void); +- EmitsDef_ptr &out (void); +- EmitsDef_ptr _retn (void); +- EmitsDef_ptr ptr (void) const; ++ IR_EmitsDef_ptr in (void) const; ++ IR_EmitsDef_ptr &inout (void); ++ IR_EmitsDef_ptr &out (void); ++ IR_EmitsDef_ptr _retn (void); ++ IR_EmitsDef_ptr ptr (void) const; + + private: +- EmitsDef_ptr ptr_; ++ IR_EmitsDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- EmitsDef_var (const TAO_Base_var &rhs); +- EmitsDef_var &operator= (const TAO_Base_var &rhs); ++ IR_EmitsDef_var (const TAO_Base_var &rhs); ++ IR_EmitsDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EMITSDEF___OUT_CH_) +-#define _TAO_IR_EMITSDEF___OUT_CH_ +- +-class TAO_Export EmitsDef_out ++class TAO_Export IR_EmitsDef_out + { + public: +- EmitsDef_out (EmitsDef_ptr &); +- EmitsDef_out (EmitsDef_var &); +- EmitsDef_out (const EmitsDef_out &); +- EmitsDef_out &operator= (const EmitsDef_out &); +- EmitsDef_out &operator= (const EmitsDef_var &); +- EmitsDef_out &operator= (EmitsDef_ptr); +- operator EmitsDef_ptr &(); +- EmitsDef_ptr &ptr (void); +- EmitsDef_ptr operator-> (void); ++ IR_EmitsDef_out (IR_EmitsDef_ptr &); ++ IR_EmitsDef_out (IR_EmitsDef_var &); ++ IR_EmitsDef_out (const IR_EmitsDef_out &); ++ IR_EmitsDef_out &operator= (const IR_EmitsDef_out &); ++ IR_EmitsDef_out &operator= (const IR_EmitsDef_var &); ++ IR_EmitsDef_out &operator= (IR_EmitsDef_ptr); ++ operator IR_EmitsDef_ptr &(); ++ IR_EmitsDef_ptr &ptr (void); ++ IR_EmitsDef_ptr operator-> (void); + + private: +- EmitsDef_ptr &ptr_; ++ IR_EmitsDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -3965,19 +2574,19 @@ + _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum, + CORBA::ULong length, +- EmitsDef* *value, ++ IR_EmitsDef* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq(const _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (void); + _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &rhs); +- TAO_Object_Manager<IR::EmitsDef,IR::EmitsDef_var> operator[] (CORBA::ULong index) const; +- static EmitsDef **allocbuf (CORBA::ULong nelems); +- static void freebuf (EmitsDef **buffer); ++ TAO_Object_Manager<IR_EmitsDef,IR_EmitsDef_var> operator[] (CORBA::ULong index) const; ++ static IR_EmitsDef **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_EmitsDef **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- EmitsDef* *get_buffer (CORBA::Boolean orphan = 0); +- const EmitsDef* *get_buffer (void) const; ++ IR_EmitsDef* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_EmitsDef* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -3989,193 +2598,139 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_EMITSDEFSEQ_CH_) +-#define _TAO_IR_EMITSDEFSEQ_CH_ +- +-class EmitsDefSeq; +-class EmitsDefSeq_var; +- + // ************************************************************* +-// EmitsDefSeq ++// IR_EmitsDefSeq + // ************************************************************* + +-class TAO_Export EmitsDefSeq : public ++class TAO_Export IR_EmitsDefSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<EmitsDef,EmitsDef_var> ++ TAO_Unbounded_Object_Sequence<IR_EmitsDef,IR_EmitsDef_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- EmitsDefSeq (void); // default ctor +- EmitsDefSeq (CORBA::ULong max); // uses max size +- EmitsDefSeq ( ++ IR_EmitsDefSeq (void); // default ctor ++ IR_EmitsDefSeq (CORBA::ULong max); // uses max size ++ IR_EmitsDefSeq ( + CORBA::ULong max, + CORBA::ULong length, +- EmitsDef_ptr *buffer, ++ IR_EmitsDef_ptr *buffer, + CORBA::Boolean release = 0 + ); +- EmitsDefSeq (const EmitsDefSeq &); // copy ctor +- ~EmitsDefSeq (void); ++ IR_EmitsDefSeq (const IR_EmitsDefSeq &); // copy ctor ++ ~IR_EmitsDefSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef EmitsDefSeq_var _var_type; ++ typedef IR_EmitsDefSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EMITSDEFSEQ___VAR_CH_) +-#define _TAO_IR_EMITSDEFSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::EmitsDefSeq_var ++// class IR_EmitsDefSeq_var + // ************************************************************* + +-class TAO_Export EmitsDefSeq_var ++class TAO_Export IR_EmitsDefSeq_var + { + public: +- EmitsDefSeq_var (void); // default constructor +- EmitsDefSeq_var (EmitsDefSeq *); +- EmitsDefSeq_var (const EmitsDefSeq_var &); // copy constructor +- ~EmitsDefSeq_var (void); // destructor ++ IR_EmitsDefSeq_var (void); // default constructor ++ IR_EmitsDefSeq_var (IR_EmitsDefSeq *); ++ IR_EmitsDefSeq_var (const IR_EmitsDefSeq_var &); // copy constructor ++ ~IR_EmitsDefSeq_var (void); // destructor + +- EmitsDefSeq_var &operator= (EmitsDefSeq *); +- EmitsDefSeq_var &operator= (const EmitsDefSeq_var &); +- EmitsDefSeq *operator-> (void); +- const EmitsDefSeq *operator-> (void) const; ++ IR_EmitsDefSeq_var &operator= (IR_EmitsDefSeq *); ++ IR_EmitsDefSeq_var &operator= (const IR_EmitsDefSeq_var &); ++ IR_EmitsDefSeq *operator-> (void); ++ const IR_EmitsDefSeq *operator-> (void) const; + +- operator const EmitsDefSeq &() const; +- operator EmitsDefSeq &(); +- operator EmitsDefSeq &() const; +- operator EmitsDefSeq *&(); // variable-size base types only ++ operator const IR_EmitsDefSeq &() const; ++ operator IR_EmitsDefSeq &(); ++ operator IR_EmitsDefSeq &() const; ++ operator IR_EmitsDefSeq *&(); // variable-size base types only + +- TAO_Object_Manager<EmitsDef, EmitsDef_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_EmitsDef, IR_EmitsDef_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const EmitsDefSeq &in (void) const; +- EmitsDefSeq &inout (void); +- EmitsDefSeq *&out (void); +- EmitsDefSeq *_retn (void); +- EmitsDefSeq *ptr (void) const; ++ const IR_EmitsDefSeq &in (void) const; ++ IR_EmitsDefSeq &inout (void); ++ IR_EmitsDefSeq *&out (void); ++ IR_EmitsDefSeq *_retn (void); ++ IR_EmitsDefSeq *ptr (void) const; + + private: +- EmitsDefSeq *ptr_; ++ IR_EmitsDefSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EMITSDEFSEQ___OUT_CH_) +-#define _TAO_IR_EMITSDEFSEQ___OUT_CH_ +- +-class TAO_Export EmitsDefSeq_out ++class TAO_Export IR_EmitsDefSeq_out + { + public: +- EmitsDefSeq_out (EmitsDefSeq *&); +- EmitsDefSeq_out (EmitsDefSeq_var &); +- EmitsDefSeq_out (const EmitsDefSeq_out &); +- EmitsDefSeq_out &operator= (const EmitsDefSeq_out &); +- EmitsDefSeq_out &operator= (EmitsDefSeq *); +- operator EmitsDefSeq *&(); +- EmitsDefSeq *&ptr (void); +- EmitsDefSeq *operator-> (void); +- TAO_Object_Manager<EmitsDef, EmitsDef_var> operator[] (CORBA::ULong index); ++ IR_EmitsDefSeq_out (IR_EmitsDefSeq *&); ++ IR_EmitsDefSeq_out (IR_EmitsDefSeq_var &); ++ IR_EmitsDefSeq_out (const IR_EmitsDefSeq_out &); ++ IR_EmitsDefSeq_out &operator= (const IR_EmitsDefSeq_out &); ++ IR_EmitsDefSeq_out &operator= (IR_EmitsDefSeq *); ++ operator IR_EmitsDefSeq *&(); ++ IR_EmitsDefSeq *&ptr (void); ++ IR_EmitsDefSeq *operator-> (void); ++ TAO_Object_Manager<IR_EmitsDef, IR_EmitsDef_var> operator[] (CORBA::ULong index); + + private: +- EmitsDefSeq *&ptr_; ++ IR_EmitsDefSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const EmitsDefSeq_var &); ++ void operator= (const IR_EmitsDefSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EmitsDefSeq; +- +-class PublishesDef; +- +-#if !defined (_TAO_IR_PUBLISHESDEF___PTR_CH_) +-#define _TAO_IR_PUBLISHESDEF___PTR_CH_ +- +-typedef PublishesDef *PublishesDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PUBLISHESDEF___VAR_CH_) +-#define _TAO_IR_PUBLISHESDEF___VAR_CH_ +- +-class TAO_Export PublishesDef_var : public TAO_Base_var ++class TAO_Export IR_PublishesDef_var : public TAO_Base_var + { + public: +- PublishesDef_var (void); // default constructor +- PublishesDef_var (PublishesDef_ptr p) : ptr_ (p) {} +- PublishesDef_var (const PublishesDef_var &); // copy constructor +- ~PublishesDef_var (void); // destructor ++ IR_PublishesDef_var (void); // default constructor ++ IR_PublishesDef_var (IR_PublishesDef_ptr p) : ptr_ (p) {} ++ IR_PublishesDef_var (const IR_PublishesDef_var &); // copy constructor ++ ~IR_PublishesDef_var (void); // destructor + +- PublishesDef_var &operator= (PublishesDef_ptr); +- PublishesDef_var &operator= (const PublishesDef_var &); +- PublishesDef_ptr operator-> (void) const; ++ IR_PublishesDef_var &operator= (IR_PublishesDef_ptr); ++ IR_PublishesDef_var &operator= (const IR_PublishesDef_var &); ++ IR_PublishesDef_ptr operator-> (void) const; + +- operator const PublishesDef_ptr &() const; +- operator PublishesDef_ptr &(); ++ operator const IR_PublishesDef_ptr &() const; ++ operator IR_PublishesDef_ptr &(); + // in, inout, out, _retn +- PublishesDef_ptr in (void) const; +- PublishesDef_ptr &inout (void); +- PublishesDef_ptr &out (void); +- PublishesDef_ptr _retn (void); +- PublishesDef_ptr ptr (void) const; ++ IR_PublishesDef_ptr in (void) const; ++ IR_PublishesDef_ptr &inout (void); ++ IR_PublishesDef_ptr &out (void); ++ IR_PublishesDef_ptr _retn (void); ++ IR_PublishesDef_ptr ptr (void) const; + + private: +- PublishesDef_ptr ptr_; ++ IR_PublishesDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- PublishesDef_var (const TAO_Base_var &rhs); +- PublishesDef_var &operator= (const TAO_Base_var &rhs); ++ IR_PublishesDef_var (const TAO_Base_var &rhs); ++ IR_PublishesDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PUBLISHESDEF___OUT_CH_) +-#define _TAO_IR_PUBLISHESDEF___OUT_CH_ +- +-class TAO_Export PublishesDef_out ++class TAO_Export IR_PublishesDef_out + { + public: +- PublishesDef_out (PublishesDef_ptr &); +- PublishesDef_out (PublishesDef_var &); +- PublishesDef_out (const PublishesDef_out &); +- PublishesDef_out &operator= (const PublishesDef_out &); +- PublishesDef_out &operator= (const PublishesDef_var &); +- PublishesDef_out &operator= (PublishesDef_ptr); +- operator PublishesDef_ptr &(); +- PublishesDef_ptr &ptr (void); +- PublishesDef_ptr operator-> (void); ++ IR_PublishesDef_out (IR_PublishesDef_ptr &); ++ IR_PublishesDef_out (IR_PublishesDef_var &); ++ IR_PublishesDef_out (const IR_PublishesDef_out &); ++ IR_PublishesDef_out &operator= (const IR_PublishesDef_out &); ++ IR_PublishesDef_out &operator= (const IR_PublishesDef_var &); ++ IR_PublishesDef_out &operator= (IR_PublishesDef_ptr); ++ operator IR_PublishesDef_ptr &(); ++ IR_PublishesDef_ptr &ptr (void); ++ IR_PublishesDef_ptr operator-> (void); + + private: +- PublishesDef_ptr &ptr_; ++ IR_PublishesDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -4185,19 +2740,19 @@ + _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum, + CORBA::ULong length, +- PublishesDef* *value, ++ IR_PublishesDef* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (void); + _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &rhs); +- TAO_Object_Manager<IR::PublishesDef,IR::PublishesDef_var> operator[] (CORBA::ULong index) const; +- static PublishesDef **allocbuf (CORBA::ULong nelems); +- static void freebuf (PublishesDef **buffer); ++ TAO_Object_Manager<IR_PublishesDef,IR_PublishesDef_var> operator[] (CORBA::ULong index) const; ++ static IR_PublishesDef **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_PublishesDef **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- PublishesDef* *get_buffer (CORBA::Boolean orphan = 0); +- const PublishesDef* *get_buffer (void) const; ++ IR_PublishesDef* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_PublishesDef* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -4209,193 +2764,139 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_PUBLISHESDEFSEQ_CH_) +-#define _TAO_IR_PUBLISHESDEFSEQ_CH_ +- +-class PublishesDefSeq; +-class PublishesDefSeq_var; +- + // ************************************************************* +-// PublishesDefSeq ++// IR_PublishesDefSeq + // ************************************************************* + +-class TAO_Export PublishesDefSeq : public ++class TAO_Export IR_PublishesDefSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<PublishesDef,PublishesDef_var> ++ TAO_Unbounded_Object_Sequence<IR_PublishesDef,IR_PublishesDef_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- PublishesDefSeq (void); // default ctor +- PublishesDefSeq (CORBA::ULong max); // uses max size +- PublishesDefSeq ( ++ IR_PublishesDefSeq (void); // default ctor ++ IR_PublishesDefSeq (CORBA::ULong max); // uses max size ++ IR_PublishesDefSeq ( + CORBA::ULong max, + CORBA::ULong length, +- PublishesDef_ptr *buffer, ++ IR_PublishesDef_ptr *buffer, + CORBA::Boolean release = 0 + ); +- PublishesDefSeq (const PublishesDefSeq &); // copy ctor +- ~PublishesDefSeq (void); ++ IR_PublishesDefSeq (const IR_PublishesDefSeq &); // copy ctor ++ ~IR_PublishesDefSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef PublishesDefSeq_var _var_type; ++ typedef IR_PublishesDefSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PUBLISHESDEFSEQ___VAR_CH_) +-#define _TAO_IR_PUBLISHESDEFSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::PublishesDefSeq_var ++// class IR_PublishesDefSeq_var + // ************************************************************* + +-class TAO_Export PublishesDefSeq_var ++class TAO_Export IR_PublishesDefSeq_var + { + public: +- PublishesDefSeq_var (void); // default constructor +- PublishesDefSeq_var (PublishesDefSeq *); +- PublishesDefSeq_var (const PublishesDefSeq_var &); // copy constructor +- ~PublishesDefSeq_var (void); // destructor ++ IR_PublishesDefSeq_var (void); // default constructor ++ IR_PublishesDefSeq_var (IR_PublishesDefSeq *); ++ IR_PublishesDefSeq_var (const IR_PublishesDefSeq_var &); // copy constructor ++ ~IR_PublishesDefSeq_var (void); // destructor + +- PublishesDefSeq_var &operator= (PublishesDefSeq *); +- PublishesDefSeq_var &operator= (const PublishesDefSeq_var &); +- PublishesDefSeq *operator-> (void); +- const PublishesDefSeq *operator-> (void) const; ++ IR_PublishesDefSeq_var &operator= (IR_PublishesDefSeq *); ++ IR_PublishesDefSeq_var &operator= (const IR_PublishesDefSeq_var &); ++ IR_PublishesDefSeq *operator-> (void); ++ const IR_PublishesDefSeq *operator-> (void) const; + +- operator const PublishesDefSeq &() const; +- operator PublishesDefSeq &(); +- operator PublishesDefSeq &() const; +- operator PublishesDefSeq *&(); // variable-size base types only ++ operator const IR_PublishesDefSeq &() const; ++ operator IR_PublishesDefSeq &(); ++ operator IR_PublishesDefSeq &() const; ++ operator IR_PublishesDefSeq *&(); // variable-size base types only + +- TAO_Object_Manager<PublishesDef, PublishesDef_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_PublishesDef, IR_PublishesDef_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const PublishesDefSeq &in (void) const; +- PublishesDefSeq &inout (void); +- PublishesDefSeq *&out (void); +- PublishesDefSeq *_retn (void); +- PublishesDefSeq *ptr (void) const; ++ const IR_PublishesDefSeq &in (void) const; ++ IR_PublishesDefSeq &inout (void); ++ IR_PublishesDefSeq *&out (void); ++ IR_PublishesDefSeq *_retn (void); ++ IR_PublishesDefSeq *ptr (void) const; + + private: +- PublishesDefSeq *ptr_; ++ IR_PublishesDefSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PUBLISHESDEFSEQ___OUT_CH_) +-#define _TAO_IR_PUBLISHESDEFSEQ___OUT_CH_ +- +-class TAO_Export PublishesDefSeq_out ++class TAO_Export IR_PublishesDefSeq_out + { + public: +- PublishesDefSeq_out (PublishesDefSeq *&); +- PublishesDefSeq_out (PublishesDefSeq_var &); +- PublishesDefSeq_out (const PublishesDefSeq_out &); +- PublishesDefSeq_out &operator= (const PublishesDefSeq_out &); +- PublishesDefSeq_out &operator= (PublishesDefSeq *); +- operator PublishesDefSeq *&(); +- PublishesDefSeq *&ptr (void); +- PublishesDefSeq *operator-> (void); +- TAO_Object_Manager<PublishesDef, PublishesDef_var> operator[] (CORBA::ULong index); ++ IR_PublishesDefSeq_out (IR_PublishesDefSeq *&); ++ IR_PublishesDefSeq_out (IR_PublishesDefSeq_var &); ++ IR_PublishesDefSeq_out (const IR_PublishesDefSeq_out &); ++ IR_PublishesDefSeq_out &operator= (const IR_PublishesDefSeq_out &); ++ IR_PublishesDefSeq_out &operator= (IR_PublishesDefSeq *); ++ operator IR_PublishesDefSeq *&(); ++ IR_PublishesDefSeq *&ptr (void); ++ IR_PublishesDefSeq *operator-> (void); ++ TAO_Object_Manager<IR_PublishesDef, IR_PublishesDef_var> operator[] (CORBA::ULong index); + + private: +- PublishesDefSeq *&ptr_; ++ IR_PublishesDefSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const PublishesDefSeq_var &); ++ void operator= (const IR_PublishesDefSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PublishesDefSeq; +- +-class ConsumesDef; +- +-#if !defined (_TAO_IR_CONSUMESDEF___PTR_CH_) +-#define _TAO_IR_CONSUMESDEF___PTR_CH_ +- +-typedef ConsumesDef *ConsumesDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONSUMESDEF___VAR_CH_) +-#define _TAO_IR_CONSUMESDEF___VAR_CH_ +- +-class TAO_Export ConsumesDef_var : public TAO_Base_var ++class TAO_Export IR_ConsumesDef_var : public TAO_Base_var + { + public: +- ConsumesDef_var (void); // default constructor +- ConsumesDef_var (ConsumesDef_ptr p) : ptr_ (p) {} +- ConsumesDef_var (const ConsumesDef_var &); // copy constructor +- ~ConsumesDef_var (void); // destructor ++ IR_ConsumesDef_var (void); // default constructor ++ IR_ConsumesDef_var (IR_ConsumesDef_ptr p) : ptr_ (p) {} ++ IR_ConsumesDef_var (const IR_ConsumesDef_var &); // copy constructor ++ ~IR_ConsumesDef_var (void); // destructor + +- ConsumesDef_var &operator= (ConsumesDef_ptr); +- ConsumesDef_var &operator= (const ConsumesDef_var &); +- ConsumesDef_ptr operator-> (void) const; ++ IR_ConsumesDef_var &operator= (IR_ConsumesDef_ptr); ++ IR_ConsumesDef_var &operator= (const IR_ConsumesDef_var &); ++ IR_ConsumesDef_ptr operator-> (void) const; + +- operator const ConsumesDef_ptr &() const; +- operator ConsumesDef_ptr &(); ++ operator const IR_ConsumesDef_ptr &() const; ++ operator IR_ConsumesDef_ptr &(); + // in, inout, out, _retn +- ConsumesDef_ptr in (void) const; +- ConsumesDef_ptr &inout (void); +- ConsumesDef_ptr &out (void); +- ConsumesDef_ptr _retn (void); +- ConsumesDef_ptr ptr (void) const; ++ IR_ConsumesDef_ptr in (void) const; ++ IR_ConsumesDef_ptr &inout (void); ++ IR_ConsumesDef_ptr &out (void); ++ IR_ConsumesDef_ptr _retn (void); ++ IR_ConsumesDef_ptr ptr (void) const; + + private: +- ConsumesDef_ptr ptr_; ++ IR_ConsumesDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- ConsumesDef_var (const TAO_Base_var &rhs); +- ConsumesDef_var &operator= (const TAO_Base_var &rhs); ++ IR_ConsumesDef_var (const TAO_Base_var &rhs); ++ IR_ConsumesDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONSUMESDEF___OUT_CH_) +-#define _TAO_IR_CONSUMESDEF___OUT_CH_ +- +-class TAO_Export ConsumesDef_out ++class TAO_Export IR_ConsumesDef_out + { + public: +- ConsumesDef_out (ConsumesDef_ptr &); +- ConsumesDef_out (ConsumesDef_var &); +- ConsumesDef_out (const ConsumesDef_out &); +- ConsumesDef_out &operator= (const ConsumesDef_out &); +- ConsumesDef_out &operator= (const ConsumesDef_var &); +- ConsumesDef_out &operator= (ConsumesDef_ptr); +- operator ConsumesDef_ptr &(); +- ConsumesDef_ptr &ptr (void); +- ConsumesDef_ptr operator-> (void); ++ IR_ConsumesDef_out (IR_ConsumesDef_ptr &); ++ IR_ConsumesDef_out (IR_ConsumesDef_var &); ++ IR_ConsumesDef_out (const IR_ConsumesDef_out &); ++ IR_ConsumesDef_out &operator= (const IR_ConsumesDef_out &); ++ IR_ConsumesDef_out &operator= (const IR_ConsumesDef_var &); ++ IR_ConsumesDef_out &operator= (IR_ConsumesDef_ptr); ++ operator IR_ConsumesDef_ptr &(); ++ IR_ConsumesDef_ptr &ptr (void); ++ IR_ConsumesDef_ptr operator-> (void); + + private: +- ConsumesDef_ptr &ptr_; ++ IR_ConsumesDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -4405,19 +2906,19 @@ + _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum, + CORBA::ULong length, +- ConsumesDef* *value, ++ IR_ConsumesDef* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (void); + _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &rhs); +- TAO_Object_Manager<IR::ConsumesDef,IR::ConsumesDef_var> operator[] (CORBA::ULong index) const; +- static ConsumesDef **allocbuf (CORBA::ULong nelems); +- static void freebuf (ConsumesDef **buffer); ++ TAO_Object_Manager<IR_ConsumesDef,IR_ConsumesDef_var> operator[] (CORBA::ULong index) const; ++ static IR_ConsumesDef **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_ConsumesDef **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- ConsumesDef* *get_buffer (CORBA::Boolean orphan = 0); +- const ConsumesDef* *get_buffer (void) const; ++ IR_ConsumesDef* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_ConsumesDef* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -4429,193 +2930,139 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_CONSUMESDEFSEQ_CH_) +-#define _TAO_IR_CONSUMESDEFSEQ_CH_ +- +-class ConsumesDefSeq; +-class ConsumesDefSeq_var; +- + // ************************************************************* +-// ConsumesDefSeq ++// IR_ConsumesDefSeq + // ************************************************************* + +-class TAO_Export ConsumesDefSeq : public ++class TAO_Export IR_ConsumesDefSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<ConsumesDef,ConsumesDef_var> ++ TAO_Unbounded_Object_Sequence<IR_ConsumesDef,IR_ConsumesDef_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- ConsumesDefSeq (void); // default ctor +- ConsumesDefSeq (CORBA::ULong max); // uses max size +- ConsumesDefSeq ( ++ IR_ConsumesDefSeq (void); // default ctor ++ IR_ConsumesDefSeq (CORBA::ULong max); // uses max size ++ IR_ConsumesDefSeq ( + CORBA::ULong max, + CORBA::ULong length, +- ConsumesDef_ptr *buffer, ++ IR_ConsumesDef_ptr *buffer, + CORBA::Boolean release = 0 + ); +- ConsumesDefSeq (const ConsumesDefSeq &); // copy ctor +- ~ConsumesDefSeq (void); ++ IR_ConsumesDefSeq (const IR_ConsumesDefSeq &); // copy ctor ++ ~IR_ConsumesDefSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ConsumesDefSeq_var _var_type; ++ typedef IR_ConsumesDefSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONSUMESDEFSEQ___VAR_CH_) +-#define _TAO_IR_CONSUMESDEFSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::ConsumesDefSeq_var ++// class IR_ConsumesDefSeq_var + // ************************************************************* + +-class TAO_Export ConsumesDefSeq_var ++class TAO_Export IR_ConsumesDefSeq_var + { + public: +- ConsumesDefSeq_var (void); // default constructor +- ConsumesDefSeq_var (ConsumesDefSeq *); +- ConsumesDefSeq_var (const ConsumesDefSeq_var &); // copy constructor +- ~ConsumesDefSeq_var (void); // destructor ++ IR_ConsumesDefSeq_var (void); // default constructor ++ IR_ConsumesDefSeq_var (IR_ConsumesDefSeq *); ++ IR_ConsumesDefSeq_var (const IR_ConsumesDefSeq_var &); // copy constructor ++ ~IR_ConsumesDefSeq_var (void); // destructor + +- ConsumesDefSeq_var &operator= (ConsumesDefSeq *); +- ConsumesDefSeq_var &operator= (const ConsumesDefSeq_var &); +- ConsumesDefSeq *operator-> (void); +- const ConsumesDefSeq *operator-> (void) const; ++ IR_ConsumesDefSeq_var &operator= (IR_ConsumesDefSeq *); ++ IR_ConsumesDefSeq_var &operator= (const IR_ConsumesDefSeq_var &); ++ IR_ConsumesDefSeq *operator-> (void); ++ const IR_ConsumesDefSeq *operator-> (void) const; + +- operator const ConsumesDefSeq &() const; +- operator ConsumesDefSeq &(); +- operator ConsumesDefSeq &() const; +- operator ConsumesDefSeq *&(); // variable-size base types only ++ operator const IR_ConsumesDefSeq &() const; ++ operator IR_ConsumesDefSeq &(); ++ operator IR_ConsumesDefSeq &() const; ++ operator IR_ConsumesDefSeq *&(); // variable-size base types only + +- TAO_Object_Manager<ConsumesDef, ConsumesDef_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_ConsumesDef, IR_ConsumesDef_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const ConsumesDefSeq &in (void) const; +- ConsumesDefSeq &inout (void); +- ConsumesDefSeq *&out (void); +- ConsumesDefSeq *_retn (void); +- ConsumesDefSeq *ptr (void) const; ++ const IR_ConsumesDefSeq &in (void) const; ++ IR_ConsumesDefSeq &inout (void); ++ IR_ConsumesDefSeq *&out (void); ++ IR_ConsumesDefSeq *_retn (void); ++ IR_ConsumesDefSeq *ptr (void) const; + + private: +- ConsumesDefSeq *ptr_; ++ IR_ConsumesDefSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONSUMESDEFSEQ___OUT_CH_) +-#define _TAO_IR_CONSUMESDEFSEQ___OUT_CH_ +- +-class TAO_Export ConsumesDefSeq_out ++class TAO_Export IR_ConsumesDefSeq_out + { + public: +- ConsumesDefSeq_out (ConsumesDefSeq *&); +- ConsumesDefSeq_out (ConsumesDefSeq_var &); +- ConsumesDefSeq_out (const ConsumesDefSeq_out &); +- ConsumesDefSeq_out &operator= (const ConsumesDefSeq_out &); +- ConsumesDefSeq_out &operator= (ConsumesDefSeq *); +- operator ConsumesDefSeq *&(); +- ConsumesDefSeq *&ptr (void); +- ConsumesDefSeq *operator-> (void); +- TAO_Object_Manager<ConsumesDef, ConsumesDef_var> operator[] (CORBA::ULong index); ++ IR_ConsumesDefSeq_out (IR_ConsumesDefSeq *&); ++ IR_ConsumesDefSeq_out (IR_ConsumesDefSeq_var &); ++ IR_ConsumesDefSeq_out (const IR_ConsumesDefSeq_out &); ++ IR_ConsumesDefSeq_out &operator= (const IR_ConsumesDefSeq_out &); ++ IR_ConsumesDefSeq_out &operator= (IR_ConsumesDefSeq *); ++ operator IR_ConsumesDefSeq *&(); ++ IR_ConsumesDefSeq *&ptr (void); ++ IR_ConsumesDefSeq *operator-> (void); ++ TAO_Object_Manager<IR_ConsumesDef, IR_ConsumesDef_var> operator[] (CORBA::ULong index); + + private: +- ConsumesDefSeq *&ptr_; ++ IR_ConsumesDefSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const ConsumesDefSeq_var &); ++ void operator= (const IR_ConsumesDefSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConsumesDefSeq; +- +-class FactoryDef; +- +-#if !defined (_TAO_IR_FACTORYDEF___PTR_CH_) +-#define _TAO_IR_FACTORYDEF___PTR_CH_ +- +-typedef FactoryDef *FactoryDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FACTORYDEF___VAR_CH_) +-#define _TAO_IR_FACTORYDEF___VAR_CH_ +- +-class TAO_Export FactoryDef_var : public TAO_Base_var ++class TAO_Export IR_FactoryDef_var : public TAO_Base_var + { + public: +- FactoryDef_var (void); // default constructor +- FactoryDef_var (FactoryDef_ptr p) : ptr_ (p) {} +- FactoryDef_var (const FactoryDef_var &); // copy constructor +- ~FactoryDef_var (void); // destructor ++ IR_FactoryDef_var (void); // default constructor ++ IR_FactoryDef_var (IR_FactoryDef_ptr p) : ptr_ (p) {} ++ IR_FactoryDef_var (const IR_FactoryDef_var &); // copy constructor ++ ~IR_FactoryDef_var (void); // destructor + +- FactoryDef_var &operator= (FactoryDef_ptr); +- FactoryDef_var &operator= (const FactoryDef_var &); +- FactoryDef_ptr operator-> (void) const; ++ IR_FactoryDef_var &operator= (IR_FactoryDef_ptr); ++ IR_FactoryDef_var &operator= (const IR_FactoryDef_var &); ++ IR_FactoryDef_ptr operator-> (void) const; + +- operator const FactoryDef_ptr &() const; +- operator FactoryDef_ptr &(); ++ operator const IR_FactoryDef_ptr &() const; ++ operator IR_FactoryDef_ptr &(); + // in, inout, out, _retn +- FactoryDef_ptr in (void) const; +- FactoryDef_ptr &inout (void); +- FactoryDef_ptr &out (void); +- FactoryDef_ptr _retn (void); +- FactoryDef_ptr ptr (void) const; ++ IR_FactoryDef_ptr in (void) const; ++ IR_FactoryDef_ptr &inout (void); ++ IR_FactoryDef_ptr &out (void); ++ IR_FactoryDef_ptr _retn (void); ++ IR_FactoryDef_ptr ptr (void) const; + + private: +- FactoryDef_ptr ptr_; ++ IR_FactoryDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- FactoryDef_var (const TAO_Base_var &rhs); +- FactoryDef_var &operator= (const TAO_Base_var &rhs); ++ IR_FactoryDef_var (const TAO_Base_var &rhs); ++ IR_FactoryDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FACTORYDEF___OUT_CH_) +-#define _TAO_IR_FACTORYDEF___OUT_CH_ +- +-class TAO_Export FactoryDef_out ++class TAO_Export IR_FactoryDef_out + { + public: +- FactoryDef_out (FactoryDef_ptr &); +- FactoryDef_out (FactoryDef_var &); +- FactoryDef_out (const FactoryDef_out &); +- FactoryDef_out &operator= (const FactoryDef_out &); +- FactoryDef_out &operator= (const FactoryDef_var &); +- FactoryDef_out &operator= (FactoryDef_ptr); +- operator FactoryDef_ptr &(); +- FactoryDef_ptr &ptr (void); +- FactoryDef_ptr operator-> (void); ++ IR_FactoryDef_out (IR_FactoryDef_ptr &); ++ IR_FactoryDef_out (IR_FactoryDef_var &); ++ IR_FactoryDef_out (const IR_FactoryDef_out &); ++ IR_FactoryDef_out &operator= (const IR_FactoryDef_out &); ++ IR_FactoryDef_out &operator= (const IR_FactoryDef_var &); ++ IR_FactoryDef_out &operator= (IR_FactoryDef_ptr); ++ operator IR_FactoryDef_ptr &(); ++ IR_FactoryDef_ptr &ptr (void); ++ IR_FactoryDef_ptr operator-> (void); + + private: +- FactoryDef_ptr &ptr_; ++ IR_FactoryDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -4625,19 +3072,19 @@ + _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum, + CORBA::ULong length, +- FactoryDef* *value, ++ IR_FactoryDef* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq(const _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (void); + _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &rhs); +- TAO_Object_Manager<IR::FactoryDef,IR::FactoryDef_var> operator[] (CORBA::ULong index) const; +- static FactoryDef **allocbuf (CORBA::ULong nelems); +- static void freebuf (FactoryDef **buffer); ++ TAO_Object_Manager<IR_FactoryDef,IR_FactoryDef_var> operator[] (CORBA::ULong index) const; ++ static IR_FactoryDef **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_FactoryDef **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- FactoryDef* *get_buffer (CORBA::Boolean orphan = 0); +- const FactoryDef* *get_buffer (void) const; ++ IR_FactoryDef* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_FactoryDef* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -4649,193 +3096,139 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_FACTORYDEFSEQ_CH_) +-#define _TAO_IR_FACTORYDEFSEQ_CH_ +- +-class FactoryDefSeq; +-class FactoryDefSeq_var; +- + // ************************************************************* +-// FactoryDefSeq ++// IR_FactoryDefSeq + // ************************************************************* + +-class TAO_Export FactoryDefSeq : public ++class TAO_Export IR_FactoryDefSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<FactoryDef,FactoryDef_var> ++ TAO_Unbounded_Object_Sequence<IR_FactoryDef,IR_FactoryDef_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- FactoryDefSeq (void); // default ctor +- FactoryDefSeq (CORBA::ULong max); // uses max size +- FactoryDefSeq ( ++ IR_FactoryDefSeq (void); // default ctor ++ IR_FactoryDefSeq (CORBA::ULong max); // uses max size ++ IR_FactoryDefSeq ( + CORBA::ULong max, + CORBA::ULong length, +- FactoryDef_ptr *buffer, ++ IR_FactoryDef_ptr *buffer, + CORBA::Boolean release = 0 + ); +- FactoryDefSeq (const FactoryDefSeq &); // copy ctor +- ~FactoryDefSeq (void); ++ IR_FactoryDefSeq (const IR_FactoryDefSeq &); // copy ctor ++ ~IR_FactoryDefSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef FactoryDefSeq_var _var_type; ++ typedef IR_FactoryDefSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FACTORYDEFSEQ___VAR_CH_) +-#define _TAO_IR_FACTORYDEFSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::FactoryDefSeq_var ++// class IR_FactoryDefSeq_var + // ************************************************************* + +-class TAO_Export FactoryDefSeq_var ++class TAO_Export IR_FactoryDefSeq_var + { + public: +- FactoryDefSeq_var (void); // default constructor +- FactoryDefSeq_var (FactoryDefSeq *); +- FactoryDefSeq_var (const FactoryDefSeq_var &); // copy constructor +- ~FactoryDefSeq_var (void); // destructor ++ IR_FactoryDefSeq_var (void); // default constructor ++ IR_FactoryDefSeq_var (IR_FactoryDefSeq *); ++ IR_FactoryDefSeq_var (const IR_FactoryDefSeq_var &); // copy constructor ++ ~IR_FactoryDefSeq_var (void); // destructor + +- FactoryDefSeq_var &operator= (FactoryDefSeq *); +- FactoryDefSeq_var &operator= (const FactoryDefSeq_var &); +- FactoryDefSeq *operator-> (void); +- const FactoryDefSeq *operator-> (void) const; ++ IR_FactoryDefSeq_var &operator= (IR_FactoryDefSeq *); ++ IR_FactoryDefSeq_var &operator= (const IR_FactoryDefSeq_var &); ++ IR_FactoryDefSeq *operator-> (void); ++ const IR_FactoryDefSeq *operator-> (void) const; + +- operator const FactoryDefSeq &() const; +- operator FactoryDefSeq &(); +- operator FactoryDefSeq &() const; +- operator FactoryDefSeq *&(); // variable-size base types only ++ operator const IR_FactoryDefSeq &() const; ++ operator IR_FactoryDefSeq &(); ++ operator IR_FactoryDefSeq &() const; ++ operator IR_FactoryDefSeq *&(); // variable-size base types only + +- TAO_Object_Manager<FactoryDef, FactoryDef_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_FactoryDef, IR_FactoryDef_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const FactoryDefSeq &in (void) const; +- FactoryDefSeq &inout (void); +- FactoryDefSeq *&out (void); +- FactoryDefSeq *_retn (void); +- FactoryDefSeq *ptr (void) const; ++ const IR_FactoryDefSeq &in (void) const; ++ IR_FactoryDefSeq &inout (void); ++ IR_FactoryDefSeq *&out (void); ++ IR_FactoryDefSeq *_retn (void); ++ IR_FactoryDefSeq *ptr (void) const; + + private: +- FactoryDefSeq *ptr_; ++ IR_FactoryDefSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FACTORYDEFSEQ___OUT_CH_) +-#define _TAO_IR_FACTORYDEFSEQ___OUT_CH_ +- +-class TAO_Export FactoryDefSeq_out ++class TAO_Export IR_FactoryDefSeq_out + { + public: +- FactoryDefSeq_out (FactoryDefSeq *&); +- FactoryDefSeq_out (FactoryDefSeq_var &); +- FactoryDefSeq_out (const FactoryDefSeq_out &); +- FactoryDefSeq_out &operator= (const FactoryDefSeq_out &); +- FactoryDefSeq_out &operator= (FactoryDefSeq *); +- operator FactoryDefSeq *&(); +- FactoryDefSeq *&ptr (void); +- FactoryDefSeq *operator-> (void); +- TAO_Object_Manager<FactoryDef, FactoryDef_var> operator[] (CORBA::ULong index); ++ IR_FactoryDefSeq_out (IR_FactoryDefSeq *&); ++ IR_FactoryDefSeq_out (IR_FactoryDefSeq_var &); ++ IR_FactoryDefSeq_out (const IR_FactoryDefSeq_out &); ++ IR_FactoryDefSeq_out &operator= (const IR_FactoryDefSeq_out &); ++ IR_FactoryDefSeq_out &operator= (IR_FactoryDefSeq *); ++ operator IR_FactoryDefSeq *&(); ++ IR_FactoryDefSeq *&ptr (void); ++ IR_FactoryDefSeq *operator-> (void); ++ TAO_Object_Manager<IR_FactoryDef, IR_FactoryDef_var> operator[] (CORBA::ULong index); + + private: +- FactoryDefSeq *&ptr_; ++ IR_FactoryDefSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const FactoryDefSeq_var &); ++ void operator= (const IR_FactoryDefSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FactoryDefSeq; +- +-class FinderDef; +- +-#if !defined (_TAO_IR_FINDERDEF___PTR_CH_) +-#define _TAO_IR_FINDERDEF___PTR_CH_ +- +-typedef FinderDef *FinderDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FINDERDEF___VAR_CH_) +-#define _TAO_IR_FINDERDEF___VAR_CH_ +- +-class TAO_Export FinderDef_var : public TAO_Base_var ++class TAO_Export IR_FinderDef_var : public TAO_Base_var + { + public: +- FinderDef_var (void); // default constructor +- FinderDef_var (FinderDef_ptr p) : ptr_ (p) {} +- FinderDef_var (const FinderDef_var &); // copy constructor +- ~FinderDef_var (void); // destructor ++ IR_FinderDef_var (void); // default constructor ++ IR_FinderDef_var (IR_FinderDef_ptr p) : ptr_ (p) {} ++ IR_FinderDef_var (const IR_FinderDef_var &); // copy constructor ++ ~IR_FinderDef_var (void); // destructor + +- FinderDef_var &operator= (FinderDef_ptr); +- FinderDef_var &operator= (const FinderDef_var &); +- FinderDef_ptr operator-> (void) const; ++ IR_FinderDef_var &operator= (IR_FinderDef_ptr); ++ IR_FinderDef_var &operator= (const IR_FinderDef_var &); ++ IR_FinderDef_ptr operator-> (void) const; + +- operator const FinderDef_ptr &() const; +- operator FinderDef_ptr &(); ++ operator const IR_FinderDef_ptr &() const; ++ operator IR_FinderDef_ptr &(); + // in, inout, out, _retn +- FinderDef_ptr in (void) const; +- FinderDef_ptr &inout (void); +- FinderDef_ptr &out (void); +- FinderDef_ptr _retn (void); +- FinderDef_ptr ptr (void) const; ++ IR_FinderDef_ptr in (void) const; ++ IR_FinderDef_ptr &inout (void); ++ IR_FinderDef_ptr &out (void); ++ IR_FinderDef_ptr _retn (void); ++ IR_FinderDef_ptr ptr (void) const; + + private: +- FinderDef_ptr ptr_; ++ IR_FinderDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- FinderDef_var (const TAO_Base_var &rhs); +- FinderDef_var &operator= (const TAO_Base_var &rhs); ++ IR_FinderDef_var (const TAO_Base_var &rhs); ++ IR_FinderDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FINDERDEF___OUT_CH_) +-#define _TAO_IR_FINDERDEF___OUT_CH_ +- +-class TAO_Export FinderDef_out ++class TAO_Export IR_FinderDef_out + { + public: +- FinderDef_out (FinderDef_ptr &); +- FinderDef_out (FinderDef_var &); +- FinderDef_out (const FinderDef_out &); +- FinderDef_out &operator= (const FinderDef_out &); +- FinderDef_out &operator= (const FinderDef_var &); +- FinderDef_out &operator= (FinderDef_ptr); +- operator FinderDef_ptr &(); +- FinderDef_ptr &ptr (void); +- FinderDef_ptr operator-> (void); ++ IR_FinderDef_out (IR_FinderDef_ptr &); ++ IR_FinderDef_out (IR_FinderDef_var &); ++ IR_FinderDef_out (const IR_FinderDef_out &); ++ IR_FinderDef_out &operator= (const IR_FinderDef_out &); ++ IR_FinderDef_out &operator= (const IR_FinderDef_var &); ++ IR_FinderDef_out &operator= (IR_FinderDef_ptr); ++ operator IR_FinderDef_ptr &(); ++ IR_FinderDef_ptr &ptr (void); ++ IR_FinderDef_ptr operator-> (void); + + private: +- FinderDef_ptr &ptr_; ++ IR_FinderDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -4845,19 +3238,19 @@ + _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum, + CORBA::ULong length, +- FinderDef* *value, ++ IR_FinderDef* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq(const _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (void); + _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &rhs); +- TAO_Object_Manager<IR::FinderDef,IR::FinderDef_var> operator[] (CORBA::ULong index) const; +- static FinderDef **allocbuf (CORBA::ULong nelems); +- static void freebuf (FinderDef **buffer); ++ TAO_Object_Manager<IR_FinderDef,IR_FinderDef_var> operator[] (CORBA::ULong index) const; ++ static IR_FinderDef **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_FinderDef **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- FinderDef* *get_buffer (CORBA::Boolean orphan = 0); +- const FinderDef* *get_buffer (void) const; ++ IR_FinderDef* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_FinderDef* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -4869,193 +3262,139 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_FINDERDEFSEQ_CH_) +-#define _TAO_IR_FINDERDEFSEQ_CH_ +- +-class FinderDefSeq; +-class FinderDefSeq_var; +- + // ************************************************************* +-// FinderDefSeq ++// IR_FinderDefSeq + // ************************************************************* + +-class TAO_Export FinderDefSeq : public ++class TAO_Export IR_FinderDefSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<FinderDef,FinderDef_var> ++ TAO_Unbounded_Object_Sequence<IR_FinderDef,IR_FinderDef_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- FinderDefSeq (void); // default ctor +- FinderDefSeq (CORBA::ULong max); // uses max size +- FinderDefSeq ( ++ IR_FinderDefSeq (void); // default ctor ++ IR_FinderDefSeq (CORBA::ULong max); // uses max size ++ IR_FinderDefSeq ( + CORBA::ULong max, + CORBA::ULong length, +- FinderDef_ptr *buffer, ++ IR_FinderDef_ptr *buffer, + CORBA::Boolean release = 0 + ); +- FinderDefSeq (const FinderDefSeq &); // copy ctor +- ~FinderDefSeq (void); ++ IR_FinderDefSeq (const IR_FinderDefSeq &); // copy ctor ++ ~IR_FinderDefSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef FinderDefSeq_var _var_type; ++ typedef IR_FinderDefSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FINDERDEFSEQ___VAR_CH_) +-#define _TAO_IR_FINDERDEFSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::FinderDefSeq_var ++// class IR_FinderDefSeq_var + // ************************************************************* + +-class TAO_Export FinderDefSeq_var ++class TAO_Export IR_FinderDefSeq_var + { + public: +- FinderDefSeq_var (void); // default constructor +- FinderDefSeq_var (FinderDefSeq *); +- FinderDefSeq_var (const FinderDefSeq_var &); // copy constructor +- ~FinderDefSeq_var (void); // destructor ++ IR_FinderDefSeq_var (void); // default constructor ++ IR_FinderDefSeq_var (IR_FinderDefSeq *); ++ IR_FinderDefSeq_var (const IR_FinderDefSeq_var &); // copy constructor ++ ~IR_FinderDefSeq_var (void); // destructor + +- FinderDefSeq_var &operator= (FinderDefSeq *); +- FinderDefSeq_var &operator= (const FinderDefSeq_var &); +- FinderDefSeq *operator-> (void); +- const FinderDefSeq *operator-> (void) const; ++ IR_FinderDefSeq_var &operator= (IR_FinderDefSeq *); ++ IR_FinderDefSeq_var &operator= (const IR_FinderDefSeq_var &); ++ IR_FinderDefSeq *operator-> (void); ++ const IR_FinderDefSeq *operator-> (void) const; + +- operator const FinderDefSeq &() const; +- operator FinderDefSeq &(); +- operator FinderDefSeq &() const; +- operator FinderDefSeq *&(); // variable-size base types only ++ operator const IR_FinderDefSeq &() const; ++ operator IR_FinderDefSeq &(); ++ operator IR_FinderDefSeq &() const; ++ operator IR_FinderDefSeq *&(); // variable-size base types only + +- TAO_Object_Manager<FinderDef, FinderDef_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_FinderDef, IR_FinderDef_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const FinderDefSeq &in (void) const; +- FinderDefSeq &inout (void); +- FinderDefSeq *&out (void); +- FinderDefSeq *_retn (void); +- FinderDefSeq *ptr (void) const; ++ const IR_FinderDefSeq &in (void) const; ++ IR_FinderDefSeq &inout (void); ++ IR_FinderDefSeq *&out (void); ++ IR_FinderDefSeq *_retn (void); ++ IR_FinderDefSeq *ptr (void) const; + + private: +- FinderDefSeq *ptr_; ++ IR_FinderDefSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FINDERDEFSEQ___OUT_CH_) +-#define _TAO_IR_FINDERDEFSEQ___OUT_CH_ +- +-class TAO_Export FinderDefSeq_out ++class TAO_Export IR_FinderDefSeq_out + { + public: +- FinderDefSeq_out (FinderDefSeq *&); +- FinderDefSeq_out (FinderDefSeq_var &); +- FinderDefSeq_out (const FinderDefSeq_out &); +- FinderDefSeq_out &operator= (const FinderDefSeq_out &); +- FinderDefSeq_out &operator= (FinderDefSeq *); +- operator FinderDefSeq *&(); +- FinderDefSeq *&ptr (void); +- FinderDefSeq *operator-> (void); +- TAO_Object_Manager<FinderDef, FinderDef_var> operator[] (CORBA::ULong index); ++ IR_FinderDefSeq_out (IR_FinderDefSeq *&); ++ IR_FinderDefSeq_out (IR_FinderDefSeq_var &); ++ IR_FinderDefSeq_out (const IR_FinderDefSeq_out &); ++ IR_FinderDefSeq_out &operator= (const IR_FinderDefSeq_out &); ++ IR_FinderDefSeq_out &operator= (IR_FinderDefSeq *); ++ operator IR_FinderDefSeq *&(); ++ IR_FinderDefSeq *&ptr (void); ++ IR_FinderDefSeq *operator-> (void); ++ TAO_Object_Manager<IR_FinderDef, IR_FinderDef_var> operator[] (CORBA::ULong index); + + private: +- FinderDefSeq *&ptr_; ++ IR_FinderDefSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const FinderDefSeq_var &); ++ void operator= (const IR_FinderDefSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FinderDefSeq; +- +-class PrimaryKeyDef; +- +-#if !defined (_TAO_IR_PRIMARYKEYDEF___PTR_CH_) +-#define _TAO_IR_PRIMARYKEYDEF___PTR_CH_ +- +-typedef PrimaryKeyDef *PrimaryKeyDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PRIMARYKEYDEF___VAR_CH_) +-#define _TAO_IR_PRIMARYKEYDEF___VAR_CH_ +- +-class TAO_Export PrimaryKeyDef_var : public TAO_Base_var ++class TAO_Export IR_PrimaryKeyDef_var : public TAO_Base_var + { + public: +- PrimaryKeyDef_var (void); // default constructor +- PrimaryKeyDef_var (PrimaryKeyDef_ptr p) : ptr_ (p) {} +- PrimaryKeyDef_var (const PrimaryKeyDef_var &); // copy constructor +- ~PrimaryKeyDef_var (void); // destructor ++ IR_PrimaryKeyDef_var (void); // default constructor ++ IR_PrimaryKeyDef_var (IR_PrimaryKeyDef_ptr p) : ptr_ (p) {} ++ IR_PrimaryKeyDef_var (const IR_PrimaryKeyDef_var &); // copy constructor ++ ~IR_PrimaryKeyDef_var (void); // destructor + +- PrimaryKeyDef_var &operator= (PrimaryKeyDef_ptr); +- PrimaryKeyDef_var &operator= (const PrimaryKeyDef_var &); +- PrimaryKeyDef_ptr operator-> (void) const; ++ IR_PrimaryKeyDef_var &operator= (IR_PrimaryKeyDef_ptr); ++ IR_PrimaryKeyDef_var &operator= (const IR_PrimaryKeyDef_var &); ++ IR_PrimaryKeyDef_ptr operator-> (void) const; + +- operator const PrimaryKeyDef_ptr &() const; +- operator PrimaryKeyDef_ptr &(); ++ operator const IR_PrimaryKeyDef_ptr &() const; ++ operator IR_PrimaryKeyDef_ptr &(); + // in, inout, out, _retn +- PrimaryKeyDef_ptr in (void) const; +- PrimaryKeyDef_ptr &inout (void); +- PrimaryKeyDef_ptr &out (void); +- PrimaryKeyDef_ptr _retn (void); +- PrimaryKeyDef_ptr ptr (void) const; ++ IR_PrimaryKeyDef_ptr in (void) const; ++ IR_PrimaryKeyDef_ptr &inout (void); ++ IR_PrimaryKeyDef_ptr &out (void); ++ IR_PrimaryKeyDef_ptr _retn (void); ++ IR_PrimaryKeyDef_ptr ptr (void) const; + + private: +- PrimaryKeyDef_ptr ptr_; ++ IR_PrimaryKeyDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- PrimaryKeyDef_var (const TAO_Base_var &rhs); +- PrimaryKeyDef_var &operator= (const TAO_Base_var &rhs); ++ IR_PrimaryKeyDef_var (const TAO_Base_var &rhs); ++ IR_PrimaryKeyDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PRIMARYKEYDEF___OUT_CH_) +-#define _TAO_IR_PRIMARYKEYDEF___OUT_CH_ +- +-class TAO_Export PrimaryKeyDef_out ++class TAO_Export IR_PrimaryKeyDef_out + { + public: +- PrimaryKeyDef_out (PrimaryKeyDef_ptr &); +- PrimaryKeyDef_out (PrimaryKeyDef_var &); +- PrimaryKeyDef_out (const PrimaryKeyDef_out &); +- PrimaryKeyDef_out &operator= (const PrimaryKeyDef_out &); +- PrimaryKeyDef_out &operator= (const PrimaryKeyDef_var &); +- PrimaryKeyDef_out &operator= (PrimaryKeyDef_ptr); +- operator PrimaryKeyDef_ptr &(); +- PrimaryKeyDef_ptr &ptr (void); +- PrimaryKeyDef_ptr operator-> (void); ++ IR_PrimaryKeyDef_out (IR_PrimaryKeyDef_ptr &); ++ IR_PrimaryKeyDef_out (IR_PrimaryKeyDef_var &); ++ IR_PrimaryKeyDef_out (const IR_PrimaryKeyDef_out &); ++ IR_PrimaryKeyDef_out &operator= (const IR_PrimaryKeyDef_out &); ++ IR_PrimaryKeyDef_out &operator= (const IR_PrimaryKeyDef_var &); ++ IR_PrimaryKeyDef_out &operator= (IR_PrimaryKeyDef_ptr); ++ operator IR_PrimaryKeyDef_ptr &(); ++ IR_PrimaryKeyDef_ptr &ptr (void); ++ IR_PrimaryKeyDef_ptr operator-> (void); + + private: +- PrimaryKeyDef_ptr &ptr_; ++ IR_PrimaryKeyDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONTAINEDSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONTAINEDSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_ContainedSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -5065,19 +3404,19 @@ + _TAO_Unbounded_Object_Sequence_IR_ContainedSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_ContainedSeq (CORBA::ULong maximum, + CORBA::ULong length, +- Contained* *value, ++ IR_Contained* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_ContainedSeq(const _TAO_Unbounded_Object_Sequence_IR_ContainedSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_ContainedSeq (void); + _TAO_Unbounded_Object_Sequence_IR_ContainedSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_ContainedSeq &rhs); +- TAO_Object_Manager<IR::Contained,IR::Contained_var> operator[] (CORBA::ULong index) const; +- static Contained **allocbuf (CORBA::ULong nelems); +- static void freebuf (Contained **buffer); ++ TAO_Object_Manager<IR_Contained,IR_Contained_var> operator[] (CORBA::ULong index) const; ++ static IR_Contained **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_Contained **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- Contained* *get_buffer (CORBA::Boolean orphan = 0); +- const Contained* *get_buffer (void) const; ++ IR_Contained* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_Contained* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -5089,191 +3428,156 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_CONTAINEDSEQ_CH_) +-#define _TAO_IR_CONTAINEDSEQ_CH_ +- +-class ContainedSeq; +-class ContainedSeq_var; +- + // ************************************************************* +-// ContainedSeq ++// IR_ContainedSeq + // ************************************************************* + +-class TAO_Export ContainedSeq : public ++class TAO_Export IR_ContainedSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_ContainedSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<Contained,Contained_var> ++ TAO_Unbounded_Object_Sequence<IR_Contained,IR_Contained_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- ContainedSeq (void); // default ctor +- ContainedSeq (CORBA::ULong max); // uses max size +- ContainedSeq ( ++ IR_ContainedSeq (void); // default ctor ++ IR_ContainedSeq (CORBA::ULong max); // uses max size ++ IR_ContainedSeq ( + CORBA::ULong max, + CORBA::ULong length, +- Contained_ptr *buffer, ++ IR_Contained_ptr *buffer, + CORBA::Boolean release = 0 + ); +- ContainedSeq (const ContainedSeq &); // copy ctor +- ~ContainedSeq (void); ++ IR_ContainedSeq (const IR_ContainedSeq &); // copy ctor ++ ~IR_ContainedSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ContainedSeq_var _var_type; ++ typedef IR_ContainedSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINEDSEQ___VAR_CH_) +-#define _TAO_IR_CONTAINEDSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::ContainedSeq_var ++// class IR_ContainedSeq_var + // ************************************************************* + +-class TAO_Export ContainedSeq_var ++class TAO_Export IR_ContainedSeq_var + { + public: +- ContainedSeq_var (void); // default constructor +- ContainedSeq_var (ContainedSeq *); +- ContainedSeq_var (const ContainedSeq_var &); // copy constructor +- ~ContainedSeq_var (void); // destructor ++ IR_ContainedSeq_var (void); // default constructor ++ IR_ContainedSeq_var (IR_ContainedSeq *); ++ IR_ContainedSeq_var (const IR_ContainedSeq_var &); // copy constructor ++ ~IR_ContainedSeq_var (void); // destructor + +- ContainedSeq_var &operator= (ContainedSeq *); +- ContainedSeq_var &operator= (const ContainedSeq_var &); +- ContainedSeq *operator-> (void); +- const ContainedSeq *operator-> (void) const; ++ IR_ContainedSeq_var &operator= (IR_ContainedSeq *); ++ IR_ContainedSeq_var &operator= (const IR_ContainedSeq_var &); ++ IR_ContainedSeq *operator-> (void); ++ const IR_ContainedSeq *operator-> (void) const; + +- operator const ContainedSeq &() const; +- operator ContainedSeq &(); +- operator ContainedSeq &() const; +- operator ContainedSeq *&(); // variable-size base types only ++ operator const IR_ContainedSeq &() const; ++ operator IR_ContainedSeq &(); ++ operator IR_ContainedSeq &() const; ++ operator IR_ContainedSeq *&(); // variable-size base types only + +- TAO_Object_Manager<Contained, Contained_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_Contained, IR_Contained_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const ContainedSeq &in (void) const; +- ContainedSeq &inout (void); +- ContainedSeq *&out (void); +- ContainedSeq *_retn (void); +- ContainedSeq *ptr (void) const; ++ const IR_ContainedSeq &in (void) const; ++ IR_ContainedSeq &inout (void); ++ IR_ContainedSeq *&out (void); ++ IR_ContainedSeq *_retn (void); ++ IR_ContainedSeq *ptr (void) const; + + private: +- ContainedSeq *ptr_; ++ IR_ContainedSeq *ptr_; + }; + + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINEDSEQ___OUT_CH_) +-#define _TAO_IR_CONTAINEDSEQ___OUT_CH_ +- +-class TAO_Export ContainedSeq_out ++class TAO_Export IR_ContainedSeq_out + { + public: +- ContainedSeq_out (ContainedSeq *&); +- ContainedSeq_out (ContainedSeq_var &); +- ContainedSeq_out (const ContainedSeq_out &); +- ContainedSeq_out &operator= (const ContainedSeq_out &); +- ContainedSeq_out &operator= (ContainedSeq *); +- operator ContainedSeq *&(); +- ContainedSeq *&ptr (void); +- ContainedSeq *operator-> (void); +- TAO_Object_Manager<Contained, Contained_var> operator[] (CORBA::ULong index); ++ IR_ContainedSeq_out (IR_ContainedSeq *&); ++ IR_ContainedSeq_out (IR_ContainedSeq_var &); ++ IR_ContainedSeq_out (const IR_ContainedSeq_out &); ++ IR_ContainedSeq_out &operator= (const IR_ContainedSeq_out &); ++ IR_ContainedSeq_out &operator= (IR_ContainedSeq *); ++ operator IR_ContainedSeq *&(); ++ IR_ContainedSeq *&ptr (void); ++ IR_ContainedSeq *operator-> (void); ++ TAO_Object_Manager<IR_Contained, IR_Contained_var> operator[] (CORBA::ULong index); + + private: +- ContainedSeq *&ptr_; ++ IR_ContainedSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const ContainedSeq_var &); ++ void operator= (const IR_ContainedSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContainedSeq; +- +-struct StructMember; +-class StructMember_var; +- +-struct TAO_Export StructMember ++struct TAO_Export IR_StructMember + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef StructMember_var _var_type; ++ typedef IR_StructMember_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + TAO_String_Manager name; + CORBA::TypeCode_var type; +- ACE_NESTED_CLASS (IR, IDLType_var) type_def; ++ IR_IDLType_var type_def; + }; + +-class TAO_Export StructMember_var ++class TAO_Export IR_StructMember_var + { + public: +- StructMember_var (void); // default constructor +- StructMember_var (StructMember *); +- StructMember_var (const StructMember_var &); // copy constructor +- ~StructMember_var (void); // destructor ++ IR_StructMember_var (void); // default constructor ++ IR_StructMember_var (IR_StructMember *); ++ IR_StructMember_var (const IR_StructMember_var &); // copy constructor ++ ~IR_StructMember_var (void); // destructor + +- StructMember_var &operator= (StructMember *); +- StructMember_var &operator= (const StructMember_var &); +- StructMember *operator-> (void); +- const StructMember *operator-> (void) const; ++ IR_StructMember_var &operator= (IR_StructMember *); ++ IR_StructMember_var &operator= (const IR_StructMember_var &); ++ IR_StructMember *operator-> (void); ++ const IR_StructMember *operator-> (void) const; + +- operator const StructMember &() const; +- operator StructMember &(); +- operator StructMember &() const; +- operator StructMember *&(); // variable-size types only ++ operator const IR_StructMember &() const; ++ operator IR_StructMember &(); ++ operator IR_StructMember &() const; ++ operator IR_StructMember *&(); // variable-size types only + + // in, inout, out, _retn +- const StructMember &in (void) const; +- StructMember &inout (void); +- StructMember *&out (void); +- StructMember *_retn (void); +- StructMember *ptr (void) const; ++ const IR_StructMember &in (void) const; ++ IR_StructMember &inout (void); ++ IR_StructMember *&out (void); ++ IR_StructMember *_retn (void); ++ IR_StructMember *ptr (void) const; + + private: +- StructMember *ptr_; ++ IR_StructMember *ptr_; + }; + +-class TAO_Export StructMember_out ++class TAO_Export IR_StructMember_out + { + public: +- StructMember_out (StructMember *&); +- StructMember_out (StructMember_var &); +- StructMember_out (const StructMember_out &); +- StructMember_out &operator= (const StructMember_out &); +- StructMember_out &operator= (StructMember *); +- operator StructMember *&(); +- StructMember *&ptr (void); +- StructMember *operator-> (void); ++ IR_StructMember_out (IR_StructMember *&); ++ IR_StructMember_out (IR_StructMember_var &); ++ IR_StructMember_out (const IR_StructMember_out &); ++ IR_StructMember_out &operator= (const IR_StructMember_out &); ++ IR_StructMember_out &operator= (IR_StructMember *); ++ operator IR_StructMember *&(); ++ IR_StructMember *&ptr (void); ++ IR_StructMember *operator-> (void); + + private: +- StructMember *&ptr_; ++ IR_StructMember *&ptr_; + // assignment from T_var not allowed +- void operator= (const StructMember_var &); ++ void operator= (const IR_StructMember_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructMember; +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_SEQUENCE_IR_STRUCTMEMBERSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_SEQUENCE_IR_STRUCTMEMBERSEQ_CH_ +- + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_StructMemberSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -5283,214 +3587,178 @@ + _TAO_Unbounded_Sequence_IR_StructMemberSeq (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_IR_StructMemberSeq (CORBA::ULong maximum, + CORBA::ULong length, +- StructMember *data, ++ IR_StructMember *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_IR_StructMemberSeq (const _TAO_Unbounded_Sequence_IR_StructMemberSeq &rhs); + _TAO_Unbounded_Sequence_IR_StructMemberSeq &operator= (const _TAO_Unbounded_Sequence_IR_StructMemberSeq &rhs); + virtual ~_TAO_Unbounded_Sequence_IR_StructMemberSeq (void); // Dtor. + // = Accessors. +- StructMember &operator[] (CORBA::ULong i); +- const StructMember &operator[] (CORBA::ULong i) const; ++ IR_StructMember &operator[] (CORBA::ULong i); ++ const IR_StructMember &operator[] (CORBA::ULong i) const; + // = Static operations. +- static StructMember *allocbuf (CORBA::ULong size); +- static void freebuf (StructMember *buffer); ++ static IR_StructMember *allocbuf (CORBA::ULong size); ++ static void freebuf (IR_StructMember *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + +- StructMember *get_buffer (CORBA::Boolean orphan = 0); +- const StructMember *get_buffer (void) const; ++ IR_StructMember *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_StructMember *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, +- StructMember *data, ++ IR_StructMember *data, + CORBA::Boolean release); + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_STRUCTMEMBERSEQ_CH_) +-#define _TAO_IR_STRUCTMEMBERSEQ_CH_ +- +-class StructMemberSeq; +-class StructMemberSeq_var; +- + // ************************************************************* +-// StructMemberSeq ++// IR_StructMemberSeq + // ************************************************************* + +-class TAO_Export StructMemberSeq : public ++class TAO_Export IR_StructMemberSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IR_StructMemberSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Sequence<StructMember> ++ TAO_Unbounded_Sequence<IR_StructMember> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- StructMemberSeq (void); // default ctor +- StructMemberSeq (CORBA::ULong max); // uses max size +- StructMemberSeq ( ++ IR_StructMemberSeq (void); // default ctor ++ IR_StructMemberSeq (CORBA::ULong max); // uses max size ++ IR_StructMemberSeq ( + CORBA::ULong max, + CORBA::ULong length, +- StructMember *buffer, ++ IR_StructMember *buffer, + CORBA::Boolean release = 0 + ); +- StructMemberSeq (const StructMemberSeq &); // copy ctor +- ~StructMemberSeq (void); ++ IR_StructMemberSeq (const IR_StructMemberSeq &); // copy ctor ++ ~IR_StructMemberSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef StructMemberSeq_var _var_type; ++ typedef IR_StructMemberSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_STRUCTMEMBERSEQ___VAR_CH_) +-#define _TAO_IR_STRUCTMEMBERSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::StructMemberSeq_var ++// class IR_StructMemberSeq_var + // ************************************************************* + +-class TAO_Export StructMemberSeq_var ++class TAO_Export IR_StructMemberSeq_var + { + public: +- StructMemberSeq_var (void); // default constructor +- StructMemberSeq_var (StructMemberSeq *); +- StructMemberSeq_var (const StructMemberSeq_var &); // copy constructor +- ~StructMemberSeq_var (void); // destructor ++ IR_StructMemberSeq_var (void); // default constructor ++ IR_StructMemberSeq_var (IR_StructMemberSeq *); ++ IR_StructMemberSeq_var (const IR_StructMemberSeq_var &); // copy constructor ++ ~IR_StructMemberSeq_var (void); // destructor + +- StructMemberSeq_var &operator= (StructMemberSeq *); +- StructMemberSeq_var &operator= (const StructMemberSeq_var &); +- StructMemberSeq *operator-> (void); +- const StructMemberSeq *operator-> (void) const; ++ IR_StructMemberSeq_var &operator= (IR_StructMemberSeq *); ++ IR_StructMemberSeq_var &operator= (const IR_StructMemberSeq_var &); ++ IR_StructMemberSeq *operator-> (void); ++ const IR_StructMemberSeq *operator-> (void) const; + +- operator const StructMemberSeq &() const; +- operator StructMemberSeq &(); +- operator StructMemberSeq &() const; +- operator StructMemberSeq *&(); // variable-size base types only ++ operator const IR_StructMemberSeq &() const; ++ operator IR_StructMemberSeq &(); ++ operator IR_StructMemberSeq &() const; ++ operator IR_StructMemberSeq *&(); // variable-size base types only + +- StructMember & operator[] (CORBA::ULong index); +- const StructMember & operator[] (CORBA::ULong index) const; ++ IR_StructMember & operator[] (CORBA::ULong index); ++ const IR_StructMember & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn +- const StructMemberSeq &in (void) const; +- StructMemberSeq &inout (void); +- StructMemberSeq *&out (void); +- StructMemberSeq *_retn (void); +- StructMemberSeq *ptr (void) const; ++ const IR_StructMemberSeq &in (void) const; ++ IR_StructMemberSeq &inout (void); ++ IR_StructMemberSeq *&out (void); ++ IR_StructMemberSeq *_retn (void); ++ IR_StructMemberSeq *ptr (void) const; + + private: +- StructMemberSeq *ptr_; ++ IR_StructMemberSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_STRUCTMEMBERSEQ___OUT_CH_) +-#define _TAO_IR_STRUCTMEMBERSEQ___OUT_CH_ +- +-class TAO_Export StructMemberSeq_out ++class TAO_Export IR_StructMemberSeq_out + { + public: +- StructMemberSeq_out (StructMemberSeq *&); +- StructMemberSeq_out (StructMemberSeq_var &); +- StructMemberSeq_out (const StructMemberSeq_out &); +- StructMemberSeq_out &operator= (const StructMemberSeq_out &); +- StructMemberSeq_out &operator= (StructMemberSeq *); +- operator StructMemberSeq *&(); +- StructMemberSeq *&ptr (void); +- StructMemberSeq *operator-> (void); +- StructMember & operator[] (CORBA::ULong index); ++ IR_StructMemberSeq_out (IR_StructMemberSeq *&); ++ IR_StructMemberSeq_out (IR_StructMemberSeq_var &); ++ IR_StructMemberSeq_out (const IR_StructMemberSeq_out &); ++ IR_StructMemberSeq_out &operator= (const IR_StructMemberSeq_out &); ++ IR_StructMemberSeq_out &operator= (IR_StructMemberSeq *); ++ operator IR_StructMemberSeq *&(); ++ IR_StructMemberSeq *&ptr (void); ++ IR_StructMemberSeq *operator-> (void); ++ IR_StructMember & operator[] (CORBA::ULong index); + + private: +- StructMemberSeq *&ptr_; ++ IR_StructMemberSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const StructMemberSeq_var &); ++ void operator= (const IR_StructMemberSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructMemberSeq; +- +-struct Initializer; +-class Initializer_var; +- +-struct TAO_Export Initializer ++struct TAO_Export IR_Initializer + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef Initializer_var _var_type; ++ typedef IR_Initializer_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + +- ACE_NESTED_CLASS (IR, StructMemberSeq) members; ++ IR_StructMemberSeq members; + TAO_String_Manager name; + }; + +-class TAO_Export Initializer_var ++class TAO_Export IR_Initializer_var + { + public: +- Initializer_var (void); // default constructor +- Initializer_var (Initializer *); +- Initializer_var (const Initializer_var &); // copy constructor +- ~Initializer_var (void); // destructor +- +- Initializer_var &operator= (Initializer *); +- Initializer_var &operator= (const Initializer_var &); +- Initializer *operator-> (void); +- const Initializer *operator-> (void) const; +- +- operator const Initializer &() const; +- operator Initializer &(); +- operator Initializer &() const; +- operator Initializer *&(); // variable-size types only ++ IR_Initializer_var (void); // default constructor ++ IR_Initializer_var (IR_Initializer *); ++ IR_Initializer_var (const IR_Initializer_var &); // copy constructor ++ ~IR_Initializer_var (void); // destructor ++ ++ IR_Initializer_var &operator= (IR_Initializer *); ++ IR_Initializer_var &operator= (const IR_Initializer_var &); ++ IR_Initializer *operator-> (void); ++ const IR_Initializer *operator-> (void) const; ++ ++ operator const IR_Initializer &() const; ++ operator IR_Initializer &(); ++ operator IR_Initializer &() const; ++ operator IR_Initializer *&(); // variable-size types only + + // in, inout, out, _retn +- const Initializer &in (void) const; +- Initializer &inout (void); +- Initializer *&out (void); +- Initializer *_retn (void); +- Initializer *ptr (void) const; ++ const IR_Initializer &in (void) const; ++ IR_Initializer &inout (void); ++ IR_Initializer *&out (void); ++ IR_Initializer *_retn (void); ++ IR_Initializer *ptr (void) const; + + private: +- Initializer *ptr_; ++ IR_Initializer *ptr_; + }; + +-class TAO_Export Initializer_out ++class TAO_Export IR_Initializer_out + { + public: +- Initializer_out (Initializer *&); +- Initializer_out (Initializer_var &); +- Initializer_out (const Initializer_out &); +- Initializer_out &operator= (const Initializer_out &); +- Initializer_out &operator= (Initializer *); +- operator Initializer *&(); +- Initializer *&ptr (void); +- Initializer *operator-> (void); ++ IR_Initializer_out (IR_Initializer *&); ++ IR_Initializer_out (IR_Initializer_var &); ++ IR_Initializer_out (const IR_Initializer_out &); ++ IR_Initializer_out &operator= (const IR_Initializer_out &); ++ IR_Initializer_out &operator= (IR_Initializer *); ++ operator IR_Initializer *&(); ++ IR_Initializer *&ptr (void); ++ IR_Initializer *operator-> (void); + + private: +- Initializer *&ptr_; ++ IR_Initializer *&ptr_; + // assignment from T_var not allowed +- void operator= (const Initializer_var &); ++ void operator= (const IR_Initializer_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Initializer; +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_SEQUENCE_IR_INITIALIZERSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_SEQUENCE_IR_INITIALIZERSEQ_CH_ +- + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_InitializerSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -5500,151 +3768,121 @@ + _TAO_Unbounded_Sequence_IR_InitializerSeq (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_IR_InitializerSeq (CORBA::ULong maximum, + CORBA::ULong length, +- Initializer *data, ++ IR_Initializer *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_IR_InitializerSeq (const _TAO_Unbounded_Sequence_IR_InitializerSeq &rhs); + _TAO_Unbounded_Sequence_IR_InitializerSeq &operator= (const _TAO_Unbounded_Sequence_IR_InitializerSeq &rhs); + virtual ~_TAO_Unbounded_Sequence_IR_InitializerSeq (void); // Dtor. + // = Accessors. +- Initializer &operator[] (CORBA::ULong i); +- const Initializer &operator[] (CORBA::ULong i) const; ++ IR_Initializer &operator[] (CORBA::ULong i); ++ const IR_Initializer &operator[] (CORBA::ULong i) const; + // = Static operations. +- static Initializer *allocbuf (CORBA::ULong size); +- static void freebuf (Initializer *buffer); ++ static IR_Initializer *allocbuf (CORBA::ULong size); ++ static void freebuf (IR_Initializer *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + +- Initializer *get_buffer (CORBA::Boolean orphan = 0); +- const Initializer *get_buffer (void) const; ++ IR_Initializer *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_Initializer *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, +- Initializer *data, ++ IR_Initializer *data, + CORBA::Boolean release); + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_INITIALIZERSEQ_CH_) +-#define _TAO_IR_INITIALIZERSEQ_CH_ +- +-class InitializerSeq; +-class InitializerSeq_var; +- + // ************************************************************* +-// InitializerSeq ++// IR_InitializerSeq + // ************************************************************* + +-class TAO_Export InitializerSeq : public ++class TAO_Export IR_InitializerSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IR_InitializerSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Sequence<Initializer> ++ TAO_Unbounded_Sequence<IR_Initializer> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- InitializerSeq (void); // default ctor +- InitializerSeq (CORBA::ULong max); // uses max size +- InitializerSeq ( ++ IR_InitializerSeq (void); // default ctor ++ IR_InitializerSeq (CORBA::ULong max); // uses max size ++ IR_InitializerSeq ( + CORBA::ULong max, + CORBA::ULong length, +- Initializer *buffer, ++ IR_Initializer *buffer, + CORBA::Boolean release = 0 + ); +- InitializerSeq (const InitializerSeq &); // copy ctor +- ~InitializerSeq (void); ++ IR_InitializerSeq (const IR_InitializerSeq &); // copy ctor ++ ~IR_InitializerSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef InitializerSeq_var _var_type; ++ typedef IR_InitializerSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_INITIALIZERSEQ___VAR_CH_) +-#define _TAO_IR_INITIALIZERSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::InitializerSeq_var ++// class IR_InitializerSeq_var + // ************************************************************* + +-class TAO_Export InitializerSeq_var ++class TAO_Export IR_InitializerSeq_var + { + public: +- InitializerSeq_var (void); // default constructor +- InitializerSeq_var (InitializerSeq *); +- InitializerSeq_var (const InitializerSeq_var &); // copy constructor +- ~InitializerSeq_var (void); // destructor ++ IR_InitializerSeq_var (void); // default constructor ++ IR_InitializerSeq_var (IR_InitializerSeq *); ++ IR_InitializerSeq_var (const IR_InitializerSeq_var &); // copy constructor ++ ~IR_InitializerSeq_var (void); // destructor + +- InitializerSeq_var &operator= (InitializerSeq *); +- InitializerSeq_var &operator= (const InitializerSeq_var &); +- InitializerSeq *operator-> (void); +- const InitializerSeq *operator-> (void) const; ++ IR_InitializerSeq_var &operator= (IR_InitializerSeq *); ++ IR_InitializerSeq_var &operator= (const IR_InitializerSeq_var &); ++ IR_InitializerSeq *operator-> (void); ++ const IR_InitializerSeq *operator-> (void) const; + +- operator const InitializerSeq &() const; +- operator InitializerSeq &(); +- operator InitializerSeq &() const; +- operator InitializerSeq *&(); // variable-size base types only ++ operator const IR_InitializerSeq &() const; ++ operator IR_InitializerSeq &(); ++ operator IR_InitializerSeq &() const; ++ operator IR_InitializerSeq *&(); // variable-size base types only + +- Initializer & operator[] (CORBA::ULong index); +- const Initializer & operator[] (CORBA::ULong index) const; ++ IR_Initializer & operator[] (CORBA::ULong index); ++ const IR_Initializer & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn +- const InitializerSeq &in (void) const; +- InitializerSeq &inout (void); +- InitializerSeq *&out (void); +- InitializerSeq *_retn (void); +- InitializerSeq *ptr (void) const; ++ const IR_InitializerSeq &in (void) const; ++ IR_InitializerSeq &inout (void); ++ IR_InitializerSeq *&out (void); ++ IR_InitializerSeq *_retn (void); ++ IR_InitializerSeq *ptr (void) const; + + private: +- InitializerSeq *ptr_; ++ IR_InitializerSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_INITIALIZERSEQ___OUT_CH_) +-#define _TAO_IR_INITIALIZERSEQ___OUT_CH_ +- +-class TAO_Export InitializerSeq_out ++class TAO_Export IR_InitializerSeq_out + { + public: +- InitializerSeq_out (InitializerSeq *&); +- InitializerSeq_out (InitializerSeq_var &); +- InitializerSeq_out (const InitializerSeq_out &); +- InitializerSeq_out &operator= (const InitializerSeq_out &); +- InitializerSeq_out &operator= (InitializerSeq *); +- operator InitializerSeq *&(); +- InitializerSeq *&ptr (void); +- InitializerSeq *operator-> (void); +- Initializer & operator[] (CORBA::ULong index); ++ IR_InitializerSeq_out (IR_InitializerSeq *&); ++ IR_InitializerSeq_out (IR_InitializerSeq_var &); ++ IR_InitializerSeq_out (const IR_InitializerSeq_out &); ++ IR_InitializerSeq_out &operator= (const IR_InitializerSeq_out &); ++ IR_InitializerSeq_out &operator= (IR_InitializerSeq *); ++ operator IR_InitializerSeq *&(); ++ IR_InitializerSeq *&ptr (void); ++ IR_InitializerSeq *operator-> (void); ++ IR_Initializer & operator[] (CORBA::ULong index); + + private: +- InitializerSeq *&ptr_; ++ IR_InitializerSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const InitializerSeq_var &); ++ void operator= (const IR_InitializerSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InitializerSeq; +- +-struct UnionMember; +-class UnionMember_var; +- +-struct TAO_Export UnionMember ++struct TAO_Export IR_UnionMember + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef UnionMember_var _var_type; ++ typedef IR_UnionMember_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -5652,64 +3890,58 @@ + TAO_String_Manager name; + CORBA::Any label; + CORBA::TypeCode_var type; +- ACE_NESTED_CLASS (IR, IDLType_var) type_def; ++ IR_IDLType_var type_def; + }; + +-class TAO_Export UnionMember_var ++class TAO_Export IR_UnionMember_var + { + public: +- UnionMember_var (void); // default constructor +- UnionMember_var (UnionMember *); +- UnionMember_var (const UnionMember_var &); // copy constructor +- ~UnionMember_var (void); // destructor ++ IR_UnionMember_var (void); // default constructor ++ IR_UnionMember_var (IR_UnionMember *); ++ IR_UnionMember_var (const IR_UnionMember_var &); // copy constructor ++ ~IR_UnionMember_var (void); // destructor + +- UnionMember_var &operator= (UnionMember *); +- UnionMember_var &operator= (const UnionMember_var &); +- UnionMember *operator-> (void); +- const UnionMember *operator-> (void) const; ++ IR_UnionMember_var &operator= (IR_UnionMember *); ++ IR_UnionMember_var &operator= (const IR_UnionMember_var &); ++ IR_UnionMember *operator-> (void); ++ const IR_UnionMember *operator-> (void) const; + +- operator const UnionMember &() const; +- operator UnionMember &(); +- operator UnionMember &() const; +- operator UnionMember *&(); // variable-size types only ++ operator const IR_UnionMember &() const; ++ operator IR_UnionMember &(); ++ operator IR_UnionMember &() const; ++ operator IR_UnionMember *&(); // variable-size types only + + // in, inout, out, _retn +- const UnionMember &in (void) const; +- UnionMember &inout (void); +- UnionMember *&out (void); +- UnionMember *_retn (void); +- UnionMember *ptr (void) const; ++ const IR_UnionMember &in (void) const; ++ IR_UnionMember &inout (void); ++ IR_UnionMember *&out (void); ++ IR_UnionMember *_retn (void); ++ IR_UnionMember *ptr (void) const; + + private: +- UnionMember *ptr_; ++ IR_UnionMember *ptr_; + }; + +-class TAO_Export UnionMember_out ++class TAO_Export IR_UnionMember_out + { + public: +- UnionMember_out (UnionMember *&); +- UnionMember_out (UnionMember_var &); +- UnionMember_out (const UnionMember_out &); +- UnionMember_out &operator= (const UnionMember_out &); +- UnionMember_out &operator= (UnionMember *); +- operator UnionMember *&(); +- UnionMember *&ptr (void); +- UnionMember *operator-> (void); ++ IR_UnionMember_out (IR_UnionMember *&); ++ IR_UnionMember_out (IR_UnionMember_var &); ++ IR_UnionMember_out (const IR_UnionMember_out &); ++ IR_UnionMember_out &operator= (const IR_UnionMember_out &); ++ IR_UnionMember_out &operator= (IR_UnionMember *); ++ operator IR_UnionMember *&(); ++ IR_UnionMember *&ptr (void); ++ IR_UnionMember *operator-> (void); + + private: +- UnionMember *&ptr_; ++ IR_UnionMember *&ptr_; + // assignment from T_var not allowed +- void operator= (const UnionMember_var &); ++ void operator= (const IR_UnionMember_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionMember; +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_SEQUENCE_IR_UNIONMEMBERSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_SEQUENCE_IR_UNIONMEMBERSEQ_CH_ +- + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_UnionMemberSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -5719,155 +3951,121 @@ + _TAO_Unbounded_Sequence_IR_UnionMemberSeq (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_IR_UnionMemberSeq (CORBA::ULong maximum, + CORBA::ULong length, +- UnionMember *data, ++ IR_UnionMember *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_IR_UnionMemberSeq (const _TAO_Unbounded_Sequence_IR_UnionMemberSeq &rhs); + _TAO_Unbounded_Sequence_IR_UnionMemberSeq &operator= (const _TAO_Unbounded_Sequence_IR_UnionMemberSeq &rhs); + virtual ~_TAO_Unbounded_Sequence_IR_UnionMemberSeq (void); // Dtor. + // = Accessors. +- UnionMember &operator[] (CORBA::ULong i); +- const UnionMember &operator[] (CORBA::ULong i) const; ++ IR_UnionMember &operator[] (CORBA::ULong i); ++ const IR_UnionMember &operator[] (CORBA::ULong i) const; + // = Static operations. +- static UnionMember *allocbuf (CORBA::ULong size); +- static void freebuf (UnionMember *buffer); ++ static IR_UnionMember *allocbuf (CORBA::ULong size); ++ static void freebuf (IR_UnionMember *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + +- UnionMember *get_buffer (CORBA::Boolean orphan = 0); +- const UnionMember *get_buffer (void) const; ++ IR_UnionMember *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_UnionMember *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, +- UnionMember *data, ++ IR_UnionMember *data, + CORBA::Boolean release); + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_UNIONMEMBERSEQ_CH_) +-#define _TAO_IR_UNIONMEMBERSEQ_CH_ +- +-class UnionMemberSeq; +-class UnionMemberSeq_var; +- + // ************************************************************* +-// UnionMemberSeq ++// IR_UnionMemberSeq + // ************************************************************* + +-class TAO_Export UnionMemberSeq : public ++class TAO_Export IR_UnionMemberSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IR_UnionMemberSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Sequence<UnionMember> ++ TAO_Unbounded_Sequence<IR_UnionMember> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- UnionMemberSeq (void); // default ctor +- UnionMemberSeq (CORBA::ULong max); // uses max size +- UnionMemberSeq ( ++ IR_UnionMemberSeq (void); // default ctor ++ IR_UnionMemberSeq (CORBA::ULong max); // uses max size ++ IR_UnionMemberSeq ( + CORBA::ULong max, + CORBA::ULong length, +- UnionMember *buffer, ++ IR_UnionMember *buffer, + CORBA::Boolean release = 0 + ); +- UnionMemberSeq (const UnionMemberSeq &); // copy ctor +- ~UnionMemberSeq (void); ++ IR_UnionMemberSeq (const IR_UnionMemberSeq &); // copy ctor ++ ~IR_UnionMemberSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef UnionMemberSeq_var _var_type; ++ typedef IR_UnionMemberSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_UNIONMEMBERSEQ___VAR_CH_) +-#define _TAO_IR_UNIONMEMBERSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::UnionMemberSeq_var ++// class IR_UnionMemberSeq_var + // ************************************************************* + +-class TAO_Export UnionMemberSeq_var ++class TAO_Export IR_UnionMemberSeq_var + { + public: +- UnionMemberSeq_var (void); // default constructor +- UnionMemberSeq_var (UnionMemberSeq *); +- UnionMemberSeq_var (const UnionMemberSeq_var &); // copy constructor +- ~UnionMemberSeq_var (void); // destructor ++ IR_UnionMemberSeq_var (void); // default constructor ++ IR_UnionMemberSeq_var (IR_UnionMemberSeq *); ++ IR_UnionMemberSeq_var (const IR_UnionMemberSeq_var &); // copy constructor ++ ~IR_UnionMemberSeq_var (void); // destructor + +- UnionMemberSeq_var &operator= (UnionMemberSeq *); +- UnionMemberSeq_var &operator= (const UnionMemberSeq_var &); +- UnionMemberSeq *operator-> (void); +- const UnionMemberSeq *operator-> (void) const; ++ IR_UnionMemberSeq_var &operator= (IR_UnionMemberSeq *); ++ IR_UnionMemberSeq_var &operator= (const IR_UnionMemberSeq_var &); ++ IR_UnionMemberSeq *operator-> (void); ++ const IR_UnionMemberSeq *operator-> (void) const; + +- operator const UnionMemberSeq &() const; +- operator UnionMemberSeq &(); +- operator UnionMemberSeq &() const; +- operator UnionMemberSeq *&(); // variable-size base types only ++ operator const IR_UnionMemberSeq &() const; ++ operator IR_UnionMemberSeq &(); ++ operator IR_UnionMemberSeq &() const; ++ operator IR_UnionMemberSeq *&(); // variable-size base types only + +- UnionMember & operator[] (CORBA::ULong index); +- const UnionMember & operator[] (CORBA::ULong index) const; ++ IR_UnionMember & operator[] (CORBA::ULong index); ++ const IR_UnionMember & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn +- const UnionMemberSeq &in (void) const; +- UnionMemberSeq &inout (void); +- UnionMemberSeq *&out (void); +- UnionMemberSeq *_retn (void); +- UnionMemberSeq *ptr (void) const; ++ const IR_UnionMemberSeq &in (void) const; ++ IR_UnionMemberSeq &inout (void); ++ IR_UnionMemberSeq *&out (void); ++ IR_UnionMemberSeq *_retn (void); ++ IR_UnionMemberSeq *ptr (void) const; + + private: +- UnionMemberSeq *ptr_; ++ IR_UnionMemberSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_UNIONMEMBERSEQ___OUT_CH_) +-#define _TAO_IR_UNIONMEMBERSEQ___OUT_CH_ +- +-class TAO_Export UnionMemberSeq_out ++class TAO_Export IR_UnionMemberSeq_out + { + public: +- UnionMemberSeq_out (UnionMemberSeq *&); +- UnionMemberSeq_out (UnionMemberSeq_var &); +- UnionMemberSeq_out (const UnionMemberSeq_out &); +- UnionMemberSeq_out &operator= (const UnionMemberSeq_out &); +- UnionMemberSeq_out &operator= (UnionMemberSeq *); +- operator UnionMemberSeq *&(); +- UnionMemberSeq *&ptr (void); +- UnionMemberSeq *operator-> (void); +- UnionMember & operator[] (CORBA::ULong index); ++ IR_UnionMemberSeq_out (IR_UnionMemberSeq *&); ++ IR_UnionMemberSeq_out (IR_UnionMemberSeq_var &); ++ IR_UnionMemberSeq_out (const IR_UnionMemberSeq_out &); ++ IR_UnionMemberSeq_out &operator= (const IR_UnionMemberSeq_out &); ++ IR_UnionMemberSeq_out &operator= (IR_UnionMemberSeq *); ++ operator IR_UnionMemberSeq *&(); ++ IR_UnionMemberSeq *&ptr (void); ++ IR_UnionMemberSeq *operator-> (void); ++ IR_UnionMember & operator[] (CORBA::ULong index); + + private: +- UnionMemberSeq *&ptr_; ++ IR_UnionMemberSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const UnionMemberSeq_var &); ++ void operator= (const IR_UnionMemberSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionMemberSeq; +- +- +-#if !defined (_TAO_IR_ENUMMEMBERSEQ_CH_) +-#define _TAO_IR_ENUMMEMBERSEQ_CH_ +- +-class EnumMemberSeq; +-class EnumMemberSeq_var; +- + // ************************************************************* +-// EnumMemberSeq ++// IR_EnumMemberSeq + // ************************************************************* + +-class TAO_Export EnumMemberSeq : public ++class TAO_Export IR_EnumMemberSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_String_Sequence + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +@@ -5875,202 +4073,112 @@ + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- EnumMemberSeq (void); // default ctor +- EnumMemberSeq (CORBA::ULong max); // uses max size +- EnumMemberSeq ( ++ IR_EnumMemberSeq (void); // default ctor ++ IR_EnumMemberSeq (CORBA::ULong max); // uses max size ++ IR_EnumMemberSeq ( + CORBA::ULong max, + CORBA::ULong length, + char * *buffer, + CORBA::Boolean release = 0 + ); +- EnumMemberSeq (const EnumMemberSeq &); // copy ctor +- ~EnumMemberSeq (void); ++ IR_EnumMemberSeq (const IR_EnumMemberSeq &); // copy ctor ++ ~IR_EnumMemberSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef EnumMemberSeq_var _var_type; ++ typedef IR_EnumMemberSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ENUMMEMBERSEQ___VAR_CH_) +-#define _TAO_IR_ENUMMEMBERSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::EnumMemberSeq_var ++// class IR_EnumMemberSeq_var + // ************************************************************* + +-class TAO_Export EnumMemberSeq_var ++class TAO_Export IR_EnumMemberSeq_var + { + public: +- EnumMemberSeq_var (void); // default constructor +- EnumMemberSeq_var (EnumMemberSeq *); +- EnumMemberSeq_var (const EnumMemberSeq_var &); // copy constructor +- ~EnumMemberSeq_var (void); // destructor ++ IR_EnumMemberSeq_var (void); // default constructor ++ IR_EnumMemberSeq_var (IR_EnumMemberSeq *); ++ IR_EnumMemberSeq_var (const IR_EnumMemberSeq_var &); // copy constructor ++ ~IR_EnumMemberSeq_var (void); // destructor + +- EnumMemberSeq_var &operator= (EnumMemberSeq *); +- EnumMemberSeq_var &operator= (const EnumMemberSeq_var &); +- EnumMemberSeq *operator-> (void); +- const EnumMemberSeq *operator-> (void) const; ++ IR_EnumMemberSeq_var &operator= (IR_EnumMemberSeq *); ++ IR_EnumMemberSeq_var &operator= (const IR_EnumMemberSeq_var &); ++ IR_EnumMemberSeq *operator-> (void); ++ const IR_EnumMemberSeq *operator-> (void) const; + +- operator const EnumMemberSeq &() const; +- operator EnumMemberSeq &(); +- operator EnumMemberSeq &() const; +- operator EnumMemberSeq *&(); // variable-size base types only ++ operator const IR_EnumMemberSeq &() const; ++ operator IR_EnumMemberSeq &(); ++ operator IR_EnumMemberSeq &() const; ++ operator IR_EnumMemberSeq *&(); // variable-size base types only + + TAO_SeqElem_String_Manager operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const EnumMemberSeq &in (void) const; +- EnumMemberSeq &inout (void); +- EnumMemberSeq *&out (void); +- EnumMemberSeq *_retn (void); +- EnumMemberSeq *ptr (void) const; ++ const IR_EnumMemberSeq &in (void) const; ++ IR_EnumMemberSeq &inout (void); ++ IR_EnumMemberSeq *&out (void); ++ IR_EnumMemberSeq *_retn (void); ++ IR_EnumMemberSeq *ptr (void) const; + + private: +- EnumMemberSeq *ptr_; ++ IR_EnumMemberSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ENUMMEMBERSEQ___OUT_CH_) +-#define _TAO_IR_ENUMMEMBERSEQ___OUT_CH_ +- +-class TAO_Export EnumMemberSeq_out ++class TAO_Export IR_EnumMemberSeq_out + { + public: +- EnumMemberSeq_out (EnumMemberSeq *&); +- EnumMemberSeq_out (EnumMemberSeq_var &); +- EnumMemberSeq_out (const EnumMemberSeq_out &); +- EnumMemberSeq_out &operator= (const EnumMemberSeq_out &); +- EnumMemberSeq_out &operator= (EnumMemberSeq *); +- operator EnumMemberSeq *&(); +- EnumMemberSeq *&ptr (void); +- EnumMemberSeq *operator-> (void); ++ IR_EnumMemberSeq_out (IR_EnumMemberSeq *&); ++ IR_EnumMemberSeq_out (IR_EnumMemberSeq_var &); ++ IR_EnumMemberSeq_out (const IR_EnumMemberSeq_out &); ++ IR_EnumMemberSeq_out &operator= (const IR_EnumMemberSeq_out &); ++ IR_EnumMemberSeq_out &operator= (IR_EnumMemberSeq *); ++ operator IR_EnumMemberSeq *&(); ++ IR_EnumMemberSeq *&ptr (void); ++ IR_EnumMemberSeq *operator-> (void); + TAO_SeqElem_String_Manager operator[] (CORBA::ULong index); + + private: +- EnumMemberSeq *&ptr_; ++ IR_EnumMemberSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const EnumMemberSeq_var &); +-}; +- +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EnumMemberSeq; +- +- +-#if !defined (_TAO_IR_CONTAINER___PTR_CH_) +-#define _TAO_IR_CONTAINER___PTR_CH_ +- +-class Container; +-typedef Container *Container_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINER___VAR_CH_) +-#define _TAO_IR_CONTAINER___VAR_CH_ +- +-class TAO_Export Container_var : public TAO_Base_var +-{ +-public: +- Container_var (void); // default constructor +- Container_var (Container_ptr p) : ptr_ (p) {} +- Container_var (const Container_var &); // copy constructor +- ~Container_var (void); // destructor +- +- Container_var &operator= (Container_ptr); +- Container_var &operator= (const Container_var &); +- Container_ptr operator-> (void) const; +- +- operator const Container_ptr &() const; +- operator Container_ptr &(); +- // in, inout, out, _retn +- Container_ptr in (void) const; +- Container_ptr &inout (void); +- Container_ptr &out (void); +- Container_ptr _retn (void); +- Container_ptr ptr (void) const; +- +-private: +- Container_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- Container_var (const TAO_Base_var &rhs); +- Container_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINER___OUT_CH_) +-#define _TAO_IR_CONTAINER___OUT_CH_ +- +-class TAO_Export Container_out +-{ +-public: +- Container_out (Container_ptr &); +- Container_out (Container_var &); +- Container_out (const Container_out &); +- Container_out &operator= (const Container_out &); +- Container_out &operator= (const Container_var &); +- Container_out &operator= (Container_ptr); +- operator Container_ptr &(); +- Container_ptr &ptr (void); +- Container_ptr operator-> (void); +- +-private: +- Container_ptr &ptr_; ++ void operator= (const IR_EnumMemberSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINER_CH_) +-#define _TAO_IR_CONTAINER_CH_ +- + // Forward Classes Declaration + class _TAO_Container_Proxy_Impl; + class _TAO_Container_Remote_Proxy_Impl; + class _TAO_Container_Proxy_Broker; + class _TAO_Container_Remote_Proxy_Broker; + +-class TAO_Export Container: public virtual CORBA::IRObject ++class TAO_Export IR_Container: public virtual CORBA_IRObject + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef Container_ptr _ptr_type; +- typedef Container_var _var_type; ++ typedef IR_Container_ptr _ptr_type; ++ typedef IR_Container_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static Container_ptr _duplicate (Container_ptr obj); +- static Container_ptr _narrow ( ++ static IR_Container_ptr _duplicate (IR_Container_ptr obj); ++ static IR_Container_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static Container_ptr _unchecked_narrow ( ++ static IR_Container_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static Container_ptr _nil (void) ++ static IR_Container_ptr _nil (void) + { +- return (Container_ptr)0; ++ return (IR_Container_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::Contained_ptr lookup ( ++ virtual IR_Contained_ptr lookup ( + const char * search_name, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () +@@ -6079,8 +4187,8 @@ + CORBA::SystemException + )); + +- virtual IR::ContainedSeq * contents ( +- IR::DefinitionKind limit_type, ++ virtual IR_ContainedSeq * contents ( ++ IR_DefinitionKind limit_type, + CORBA::Boolean exclude_inherited, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () +@@ -6089,10 +4197,10 @@ + CORBA::SystemException + )); + +- virtual IR::ContainedSeq * lookup_name ( ++ virtual IR_ContainedSeq * lookup_name ( + const char * search_name, + CORBA::Long levels_to_search, +- IR::DefinitionKind limit_type, ++ IR_DefinitionKind limit_type, + CORBA::Boolean exclude_inherited, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () +@@ -6113,8 +4221,8 @@ + + static void _tao_any_destructor (void*); + +- ACE_NESTED_CLASS (IR, Contained_var) contained_object; +- ACE_NESTED_CLASS (IR, DefinitionKind) kind; ++ IR_Contained_var contained_object; ++ IR_DefinitionKind kind; + CORBA::Any value; + }; + +@@ -6170,9 +4278,6 @@ + + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_SEQUENCE_IR_CONTAINER_DESCRIPTIONSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_SEQUENCE_IR_CONTAINER_DESCRIPTIONSEQ_CH_ +- + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -6205,15 +4310,8 @@ + CORBA::Boolean release); + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_CONTAINER_DESCRIPTIONSEQ_CH_) +-#define _TAO_IR_CONTAINER_DESCRIPTIONSEQ_CH_ +- +- class DescriptionSeq; + class DescriptionSeq_var; + + // ************************************************************* +@@ -6246,14 +4344,8 @@ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINER_DESCRIPTIONSEQ___VAR_CH_) +-#define _TAO_IR_CONTAINER_DESCRIPTIONSEQ___VAR_CH_ +- + // ************************************************************* +- // class IR::Container::DescriptionSeq_var ++ // class IR_Container::DescriptionSeq_var + // ************************************************************* + + class TAO_Export DescriptionSeq_var +@@ -6275,8 +4367,7 @@ + operator DescriptionSeq *&(); // variable-size base types only + + Description & operator[] (CORBA::ULong index); +- const Description & operator[] (CORBA::ULong index) const; +- ++ const Description & operator[] (CORBA::ULong index) const; + // in, inout, out, _retn + const DescriptionSeq &in (void) const; + DescriptionSeq &inout (void); +@@ -6288,13 +4379,6 @@ + DescriptionSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTAINER_DESCRIPTIONSEQ___OUT_CH_) +-#define _TAO_IR_CONTAINER_DESCRIPTIONSEQ___OUT_CH_ +- + class TAO_Export DescriptionSeq_out + { + public: +@@ -6314,13 +4398,10 @@ + void operator= (const DescriptionSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- + static CORBA::TypeCode_ptr _tc_DescriptionSeq; + +- virtual IR::Container::DescriptionSeq * describe_contents ( +- IR::DefinitionKind limit_type, ++ virtual IR_Container::DescriptionSeq * describe_contents ( ++ IR_DefinitionKind limit_type, + CORBA::Boolean exclude_inherited, + CORBA::Long max_returned_objs, + CORBA::Environment &ACE_TRY_ENV = +@@ -6330,7 +4411,7 @@ + CORBA::SystemException + )); + +- virtual IR::ModuleDef_ptr create_module ( ++ virtual IR_ModuleDef_ptr create_module ( + const char * id, + const char * name, + const char * version, +@@ -6341,11 +4422,11 @@ + CORBA::SystemException + )); + +- virtual IR::ConstantDef_ptr create_constant ( ++ virtual IR_ConstantDef_ptr create_constant ( + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr type, ++ IR_IDLType_ptr type, + const CORBA::Any & value, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () +@@ -6354,11 +4435,11 @@ + CORBA::SystemException + )); + +- virtual IR::StructDef_ptr create_struct ( ++ virtual IR_StructDef_ptr create_struct ( + const char * id, + const char * name, + const char * version, +- const IR::StructMemberSeq & members, ++ const IR_StructMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -6366,12 +4447,12 @@ + CORBA::SystemException + )); + +- virtual IR::UnionDef_ptr create_union ( ++ virtual IR_UnionDef_ptr create_union ( + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr discriminator_type, +- const IR::UnionMemberSeq & members, ++ IR_IDLType_ptr discriminator_type, ++ const IR_UnionMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -6379,11 +4460,11 @@ + CORBA::SystemException + )); + +- virtual IR::EnumDef_ptr create_enum ( ++ virtual IR_EnumDef_ptr create_enum ( + const char * id, + const char * name, + const char * version, +- const IR::EnumMemberSeq & members, ++ const IR_EnumMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -6391,11 +4472,11 @@ + CORBA::SystemException + )); + +- virtual IR::AliasDef_ptr create_alias ( ++ virtual IR_AliasDef_ptr create_alias ( + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr original_type, ++ IR_IDLType_ptr original_type, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -6403,11 +4484,11 @@ + CORBA::SystemException + )); + +- virtual IR::InterfaceDef_ptr create_interface ( ++ virtual IR_InterfaceDef_ptr create_interface ( + const char * id, + const char * name, + const char * version, +- const IR::InterfaceDefSeq & base_interfaces, ++ const IR_InterfaceDefSeq & base_interfaces, + CORBA::Boolean is_abstract, + CORBA::Boolean is_local, + CORBA::Environment &ACE_TRY_ENV = +@@ -6417,17 +4498,17 @@ + CORBA::SystemException + )); + +- virtual IR::ValueDef_ptr create_value ( ++ virtual IR_ValueDef_ptr create_value ( + const char * id, + const char * name, + const char * version, + CORBA::Boolean is_custom, + CORBA::Boolean is_abstract, +- IR::ValueDef_ptr base_value, ++ IR_ValueDef_ptr base_value, + CORBA::Boolean is_truncatable, +- const IR::ValueDefSeq & abstract_base_values, +- const IR::InterfaceDefSeq & supported_interfaces, +- const IR::InitializerSeq & initializers, ++ const IR_ValueDefSeq & abstract_base_values, ++ const IR_InterfaceDefSeq & supported_interfaces, ++ const IR_InitializerSeq & initializers, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -6435,11 +4516,11 @@ + CORBA::SystemException + )); + +- virtual IR::ValueBoxDef_ptr create_value_box ( ++ virtual IR_ValueBoxDef_ptr create_value_box ( + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr original_type_def, ++ IR_IDLType_ptr original_type_def, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -6447,11 +4528,11 @@ + CORBA::SystemException + )); + +- virtual IR::ExceptionDef_ptr create_exception ( ++ virtual IR_ExceptionDef_ptr create_exception ( + const char * id, + const char * name, + const char * version, +- const IR::StructMemberSeq & members, ++ const IR_StructMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -6459,7 +4540,7 @@ + CORBA::SystemException + )); + +- virtual IR::NativeDef_ptr create_native ( ++ virtual IR_NativeDef_ptr create_native ( + const char * id, + const char * name, + const char * version, +@@ -6483,804 +4564,27 @@ + _TAO_Container_Proxy_Broker *the_TAO_Container_Proxy_Broker_; + + protected: +- Container (int collocated = 0); ++ IR_Container (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- Container ( ++ IR_Container ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +- virtual ~Container (void); +- private: +- Container (const Container &); +- void operator= (const Container &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_Container_lookup : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_Container_lookup ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * search_name, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_Container_lookup (const TAO_ClientRequestInfo_IR_Container_lookup &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_lookup &); +- const char * search_name_; +- void result (IR::Contained_ptr result); +- // update the result +- IR::Contained_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_Container_contents : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_Container_contents ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::DefinitionKind & limit_type, +- const CORBA::Boolean & exclude_inherited, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); ++ ++ friend class _TAO_Container_Remote_Proxy_Impl; ++ friend class _TAO_Container_ThruPOA_Proxy_Impl; ++ friend class _TAO_Container_Direct_Proxy_Impl; + +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_Container (void); + private: +- TAO_ClientRequestInfo_IR_Container_contents (const TAO_ClientRequestInfo_IR_Container_contents &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_contents &); +- const IR::DefinitionKind & limit_type_; +- const CORBA::Boolean & exclude_inherited_; +- void result (IR::ContainedSeq * result); +- // update the result +- IR::ContainedSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_lookup_name : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_lookup_name ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * search_name, +- const CORBA::Long & levels_to_search, +- IR::DefinitionKind & limit_type, +- const CORBA::Boolean & exclude_inherited, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_lookup_name (const TAO_ClientRequestInfo_IR_Container_lookup_name &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_lookup_name &); +- const char * search_name_; +- const CORBA::Long & levels_to_search_; +- const IR::DefinitionKind & limit_type_; +- const CORBA::Boolean & exclude_inherited_; +- void result (IR::ContainedSeq * result); +- // update the result +- IR::ContainedSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_describe_contents : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_describe_contents ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::DefinitionKind & limit_type, +- const CORBA::Boolean & exclude_inherited, +- const CORBA::Long & max_returned_objs, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_describe_contents (const TAO_ClientRequestInfo_IR_Container_describe_contents &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_describe_contents &); +- const IR::DefinitionKind & limit_type_; +- const CORBA::Boolean & exclude_inherited_; +- const CORBA::Long & max_returned_objs_; +- void result (ACE_NESTED_CLASS (IR::Container,DescriptionSeq) * result); +- // update the result +- ACE_NESTED_CLASS (IR::Container,DescriptionSeq) * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_create_module : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_create_module ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_create_module (const TAO_ClientRequestInfo_IR_Container_create_module &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_create_module &); +- const char * id_; +- const char * name_; +- const char * version_; +- void result (IR::ModuleDef_ptr result); +- // update the result +- IR::ModuleDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_create_constant : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_create_constant ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::IDLType_ptr type, +- const CORBA::Any & value, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_create_constant (const TAO_ClientRequestInfo_IR_Container_create_constant &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_create_constant &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::IDLType_ptr type_; +- const CORBA::Any & value_; +- void result (IR::ConstantDef_ptr result); +- // update the result +- IR::ConstantDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_create_struct : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_create_struct ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- const IR::StructMemberSeq & members, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_create_struct (const TAO_ClientRequestInfo_IR_Container_create_struct &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_create_struct &); +- const char * id_; +- const char * name_; +- const char * version_; +- const IR::StructMemberSeq & members_; +- void result (IR::StructDef_ptr result); +- // update the result +- IR::StructDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_create_union : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_create_union ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::IDLType_ptr discriminator_type, +- const IR::UnionMemberSeq & members, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_create_union (const TAO_ClientRequestInfo_IR_Container_create_union &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_create_union &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::IDLType_ptr discriminator_type_; +- const IR::UnionMemberSeq & members_; +- void result (IR::UnionDef_ptr result); +- // update the result +- IR::UnionDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_create_enum : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_create_enum ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- const IR::EnumMemberSeq & members, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_create_enum (const TAO_ClientRequestInfo_IR_Container_create_enum &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_create_enum &); +- const char * id_; +- const char * name_; +- const char * version_; +- const IR::EnumMemberSeq & members_; +- void result (IR::EnumDef_ptr result); +- // update the result +- IR::EnumDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_create_alias : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_create_alias ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::IDLType_ptr original_type, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_create_alias (const TAO_ClientRequestInfo_IR_Container_create_alias &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_create_alias &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::IDLType_ptr original_type_; +- void result (IR::AliasDef_ptr result); +- // update the result +- IR::AliasDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_create_interface : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_create_interface ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- const IR::InterfaceDefSeq & base_interfaces, +- const CORBA::Boolean & is_abstract, +- const CORBA::Boolean & is_local, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_create_interface (const TAO_ClientRequestInfo_IR_Container_create_interface &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_create_interface &); +- const char * id_; +- const char * name_; +- const char * version_; +- const IR::InterfaceDefSeq & base_interfaces_; +- const CORBA::Boolean & is_abstract_; +- const CORBA::Boolean & is_local_; +- void result (IR::InterfaceDef_ptr result); +- // update the result +- IR::InterfaceDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_create_value : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_create_value ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- const CORBA::Boolean & is_custom, +- const CORBA::Boolean & is_abstract, +- IR::ValueDef_ptr base_value, +- const CORBA::Boolean & is_truncatable, +- const IR::ValueDefSeq & abstract_base_values, +- const IR::InterfaceDefSeq & supported_interfaces, +- const IR::InitializerSeq & initializers, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_create_value (const TAO_ClientRequestInfo_IR_Container_create_value &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_create_value &); +- const char * id_; +- const char * name_; +- const char * version_; +- const CORBA::Boolean & is_custom_; +- const CORBA::Boolean & is_abstract_; +- IR::ValueDef_ptr base_value_; +- const CORBA::Boolean & is_truncatable_; +- const IR::ValueDefSeq & abstract_base_values_; +- const IR::InterfaceDefSeq & supported_interfaces_; +- const IR::InitializerSeq & initializers_; +- void result (IR::ValueDef_ptr result); +- // update the result +- IR::ValueDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_create_value_box : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_create_value_box ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::IDLType_ptr original_type_def, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_create_value_box (const TAO_ClientRequestInfo_IR_Container_create_value_box &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_create_value_box &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::IDLType_ptr original_type_def_; +- void result (IR::ValueBoxDef_ptr result); +- // update the result +- IR::ValueBoxDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_create_exception : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_create_exception ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- const IR::StructMemberSeq & members, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_create_exception (const TAO_ClientRequestInfo_IR_Container_create_exception &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_create_exception &); +- const char * id_; +- const char * name_; +- const char * version_; +- const IR::StructMemberSeq & members_; +- void result (IR::ExceptionDef_ptr result); +- // update the result +- IR::ExceptionDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Container_create_native : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Container; +- +- friend class _TAO_Container_Remote_Proxy_Impl; +- friend class _TAO_Container_ThruPOA_Proxy_Impl; +- friend class _TAO_Container_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Container_create_native ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Container_create_native (const TAO_ClientRequestInfo_IR_Container_create_native &); +- void operator= (const TAO_ClientRequestInfo_IR_Container_create_native &); +- const char * id_; +- const char * name_; +- const char * version_; +- void result (IR::NativeDef_ptr result); +- // update the result +- IR::NativeDef_ptr result_; +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_Container (const IR_Container &); ++ void operator= (const IR_Container &); + }; + + +@@ -7294,12 +4598,12 @@ + // + + class TAO_Export _TAO_Container_Proxy_Impl : +- public virtual CORBA::_TAO_IRObject_Proxy_Impl ++ public virtual _TAO_IRObject_Proxy_Impl + { + public: + virtual ~_TAO_Container_Proxy_Impl (void) { } + +- virtual IR::Contained_ptr lookup ( ++ virtual IR_Contained_ptr lookup ( + CORBA_Object *_collocated_tao_target_, + const char * search_name, + CORBA::Environment &ACE_TRY_ENV +@@ -7308,9 +4612,9 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::ContainedSeq * contents ( ++ virtual IR_ContainedSeq * contents ( + CORBA_Object *_collocated_tao_target_, +- IR::DefinitionKind limit_type, ++ IR_DefinitionKind limit_type, + CORBA::Boolean exclude_inherited, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -7318,11 +4622,11 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::ContainedSeq * lookup_name ( ++ virtual IR_ContainedSeq * lookup_name ( + CORBA_Object *_collocated_tao_target_, + const char * search_name, + CORBA::Long levels_to_search, +- IR::DefinitionKind limit_type, ++ IR_DefinitionKind limit_type, + CORBA::Boolean exclude_inherited, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -7330,9 +4634,9 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::Container::DescriptionSeq * describe_contents ( ++ virtual IR_Container::DescriptionSeq * describe_contents ( + CORBA_Object *_collocated_tao_target_, +- IR::DefinitionKind limit_type, ++ IR_DefinitionKind limit_type, + CORBA::Boolean exclude_inherited, + CORBA::Long max_returned_objs, + CORBA::Environment &ACE_TRY_ENV +@@ -7341,7 +4645,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::ModuleDef_ptr create_module ( ++ virtual IR_ModuleDef_ptr create_module ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, +@@ -7352,12 +4656,12 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::ConstantDef_ptr create_constant ( ++ virtual IR_ConstantDef_ptr create_constant ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr type, ++ IR_IDLType_ptr type, + const CORBA::Any & value, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -7365,61 +4669,61 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::StructDef_ptr create_struct ( ++ virtual IR_StructDef_ptr create_struct ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- const IR::StructMemberSeq & members, ++ const IR_StructMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::UnionDef_ptr create_union ( ++ virtual IR_UnionDef_ptr create_union ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr discriminator_type, +- const IR::UnionMemberSeq & members, ++ IR_IDLType_ptr discriminator_type, ++ const IR_UnionMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::EnumDef_ptr create_enum ( ++ virtual IR_EnumDef_ptr create_enum ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- const IR::EnumMemberSeq & members, ++ const IR_EnumMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::AliasDef_ptr create_alias ( ++ virtual IR_AliasDef_ptr create_alias ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr original_type, ++ IR_IDLType_ptr original_type, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::InterfaceDef_ptr create_interface ( ++ virtual IR_InterfaceDef_ptr create_interface ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- const IR::InterfaceDefSeq & base_interfaces, ++ const IR_InterfaceDefSeq & base_interfaces, + CORBA::Boolean is_abstract, + CORBA::Boolean is_local, + CORBA::Environment &ACE_TRY_ENV +@@ -7428,49 +4732,49 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::ValueDef_ptr create_value ( ++ virtual IR_ValueDef_ptr create_value ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, + CORBA::Boolean is_custom, + CORBA::Boolean is_abstract, +- IR::ValueDef_ptr base_value, ++ IR_ValueDef_ptr base_value, + CORBA::Boolean is_truncatable, +- const IR::ValueDefSeq & abstract_base_values, +- const IR::InterfaceDefSeq & supported_interfaces, +- const IR::InitializerSeq & initializers, ++ const IR_ValueDefSeq & abstract_base_values, ++ const IR_InterfaceDefSeq & supported_interfaces, ++ const IR_InitializerSeq & initializers, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::ValueBoxDef_ptr create_value_box ( ++ virtual IR_ValueBoxDef_ptr create_value_box ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr original_type_def, ++ IR_IDLType_ptr original_type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::ExceptionDef_ptr create_exception ( ++ virtual IR_ExceptionDef_ptr create_exception ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- const IR::StructMemberSeq & members, ++ const IR_StructMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::NativeDef_ptr create_native ( ++ virtual IR_NativeDef_ptr create_native ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, +@@ -7485,6 +4789,7 @@ + _TAO_Container_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -7497,7 +4802,7 @@ + class TAO_Export _TAO_Container_Remote_Proxy_Impl : + public virtual _TAO_Container_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual CORBA::_TAO_IRObject_Remote_Proxy_Impl ++ public virtual _TAO_IRObject_Remote_Proxy_Impl + + { + public: +@@ -7505,7 +4810,7 @@ + + virtual ~_TAO_Container_Remote_Proxy_Impl (void) { } + +- virtual IR::Contained_ptr lookup ( ++ virtual IR_Contained_ptr lookup ( + CORBA_Object *_collocated_tao_target_, + const char * search_name, + CORBA::Environment &ACE_TRY_ENV +@@ -7514,9 +4819,9 @@ + CORBA::SystemException + )); + +- virtual IR::ContainedSeq * contents ( ++ virtual IR_ContainedSeq * contents ( + CORBA_Object *_collocated_tao_target_, +- IR::DefinitionKind limit_type, ++ IR_DefinitionKind limit_type, + CORBA::Boolean exclude_inherited, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -7524,11 +4829,11 @@ + CORBA::SystemException + )); + +- virtual IR::ContainedSeq * lookup_name ( ++ virtual IR_ContainedSeq * lookup_name ( + CORBA_Object *_collocated_tao_target_, + const char * search_name, + CORBA::Long levels_to_search, +- IR::DefinitionKind limit_type, ++ IR_DefinitionKind limit_type, + CORBA::Boolean exclude_inherited, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -7536,9 +4841,9 @@ + CORBA::SystemException + )); + +- virtual IR::Container::DescriptionSeq * describe_contents ( ++ virtual IR_Container::DescriptionSeq * describe_contents ( + CORBA_Object *_collocated_tao_target_, +- IR::DefinitionKind limit_type, ++ IR_DefinitionKind limit_type, + CORBA::Boolean exclude_inherited, + CORBA::Long max_returned_objs, + CORBA::Environment &ACE_TRY_ENV +@@ -7547,7 +4852,7 @@ + CORBA::SystemException + )); + +- virtual IR::ModuleDef_ptr create_module ( ++ virtual IR_ModuleDef_ptr create_module ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, +@@ -7558,12 +4863,12 @@ + CORBA::SystemException + )); + +- virtual IR::ConstantDef_ptr create_constant ( ++ virtual IR_ConstantDef_ptr create_constant ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr type, ++ IR_IDLType_ptr type, + const CORBA::Any & value, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -7571,61 +4876,61 @@ + CORBA::SystemException + )); + +- virtual IR::StructDef_ptr create_struct ( ++ virtual IR_StructDef_ptr create_struct ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- const IR::StructMemberSeq & members, ++ const IR_StructMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::UnionDef_ptr create_union ( ++ virtual IR_UnionDef_ptr create_union ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr discriminator_type, +- const IR::UnionMemberSeq & members, ++ IR_IDLType_ptr discriminator_type, ++ const IR_UnionMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::EnumDef_ptr create_enum ( ++ virtual IR_EnumDef_ptr create_enum ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- const IR::EnumMemberSeq & members, ++ const IR_EnumMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::AliasDef_ptr create_alias ( ++ virtual IR_AliasDef_ptr create_alias ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr original_type, ++ IR_IDLType_ptr original_type, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::InterfaceDef_ptr create_interface ( ++ virtual IR_InterfaceDef_ptr create_interface ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- const IR::InterfaceDefSeq & base_interfaces, ++ const IR_InterfaceDefSeq & base_interfaces, + CORBA::Boolean is_abstract, + CORBA::Boolean is_local, + CORBA::Environment &ACE_TRY_ENV +@@ -7634,49 +4939,49 @@ + CORBA::SystemException + )); + +- virtual IR::ValueDef_ptr create_value ( ++ virtual IR_ValueDef_ptr create_value ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, + CORBA::Boolean is_custom, + CORBA::Boolean is_abstract, +- IR::ValueDef_ptr base_value, ++ IR_ValueDef_ptr base_value, + CORBA::Boolean is_truncatable, +- const IR::ValueDefSeq & abstract_base_values, +- const IR::InterfaceDefSeq & supported_interfaces, +- const IR::InitializerSeq & initializers, ++ const IR_ValueDefSeq & abstract_base_values, ++ const IR_InterfaceDefSeq & supported_interfaces, ++ const IR_InitializerSeq & initializers, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::ValueBoxDef_ptr create_value_box ( ++ virtual IR_ValueBoxDef_ptr create_value_box ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr original_type_def, ++ IR_IDLType_ptr original_type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::ExceptionDef_ptr create_exception ( ++ virtual IR_ExceptionDef_ptr create_exception ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- const IR::StructMemberSeq & members, ++ const IR_StructMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::NativeDef_ptr create_native ( ++ virtual IR_NativeDef_ptr create_native ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, +@@ -7686,7 +4991,6 @@ + ACE_THROW_SPEC (( + CORBA::SystemException + )); +- + }; + + // +@@ -7709,8 +5013,9 @@ + { + public: + virtual ~_TAO_Container_Proxy_Broker (void); ++ + virtual _TAO_Container_Proxy_Impl &select_proxy ( +- Container *object, ++ IR_Container *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -7735,9 +5040,9 @@ + _TAO_Container_Remote_Proxy_Broker (void); + + virtual ~_TAO_Container_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_Container_Proxy_Impl &select_proxy ( +- Container *object, ++ IR_Container *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -7751,123 +5056,45 @@ + static _TAO_Container_Remote_Proxy_Broker *the_TAO_Container_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Container; +- +- +-#if !defined (_TAO_IR_IDLTYPE___PTR_CH_) +-#define _TAO_IR_IDLTYPE___PTR_CH_ +- +-class IDLType; +-typedef IDLType *IDLType_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_IDLTYPE___VAR_CH_) +-#define _TAO_IR_IDLTYPE___VAR_CH_ +- +-class TAO_Export IDLType_var : public TAO_Base_var +-{ +-public: +- IDLType_var (void); // default constructor +- IDLType_var (IDLType_ptr p) : ptr_ (p) {} +- IDLType_var (const IDLType_var &); // copy constructor +- ~IDLType_var (void); // destructor +- +- IDLType_var &operator= (IDLType_ptr); +- IDLType_var &operator= (const IDLType_var &); +- IDLType_ptr operator-> (void) const; +- +- operator const IDLType_ptr &() const; +- operator IDLType_ptr &(); +- // in, inout, out, _retn +- IDLType_ptr in (void) const; +- IDLType_ptr &inout (void); +- IDLType_ptr &out (void); +- IDLType_ptr _retn (void); +- IDLType_ptr ptr (void) const; +- +-private: +- IDLType_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- IDLType_var (const TAO_Base_var &rhs); +- IDLType_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_IDLTYPE___OUT_CH_) +-#define _TAO_IR_IDLTYPE___OUT_CH_ +- +-class TAO_Export IDLType_out +-{ +-public: +- IDLType_out (IDLType_ptr &); +- IDLType_out (IDLType_var &); +- IDLType_out (const IDLType_out &); +- IDLType_out &operator= (const IDLType_out &); +- IDLType_out &operator= (const IDLType_var &); +- IDLType_out &operator= (IDLType_ptr); +- operator IDLType_ptr &(); +- IDLType_ptr &ptr (void); +- IDLType_ptr operator-> (void); +- +-private: +- IDLType_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_IDLTYPE_CH_) +-#define _TAO_IR_IDLTYPE_CH_ +- + // Forward Classes Declaration + class _TAO_IDLType_Proxy_Impl; + class _TAO_IDLType_Remote_Proxy_Impl; + class _TAO_IDLType_Proxy_Broker; + class _TAO_IDLType_Remote_Proxy_Broker; + +-class TAO_Export IDLType: public virtual CORBA::IRObject ++class TAO_Export IR_IDLType: public virtual CORBA_IRObject + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef IDLType_ptr _ptr_type; +- typedef IDLType_var _var_type; ++ typedef IR_IDLType_ptr _ptr_type; ++ typedef IR_IDLType_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static IDLType_ptr _duplicate (IDLType_ptr obj); +- static IDLType_ptr _narrow ( ++ static IR_IDLType_ptr _duplicate (IR_IDLType_ptr obj); ++ static IR_IDLType_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static IDLType_ptr _unchecked_narrow ( ++ static IR_IDLType_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static IDLType_ptr _nil (void) ++ static IR_IDLType_ptr _nil (void) + { +- return (IDLType_ptr)0; ++ return (IR_IDLType_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual CORBA::TypeCode_ptr type ( +- CORBA::Environment &ACE_TRY_ENV = ++ virtual CORBA::TypeCode_ptr type ( ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -7887,78 +5114,27 @@ + _TAO_IDLType_Proxy_Broker *the_TAO_IDLType_Proxy_Broker_; + + protected: +- IDLType (int collocated = 0); ++ IR_IDLType (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- IDLType ( ++ IR_IDLType ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_IDLType_Remote_Proxy_Impl; +- friend class _TAO_IDLType_ThruPOA_Proxy_Impl; +- friend class _TAO_IDLType_Direct_Proxy_Impl; +- +- virtual ~IDLType (void); +- private: +- IDLType (const IDLType &); +- void operator= (const IDLType &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_IDLType_type_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::IDLType; +- +- friend class _TAO_IDLType_Remote_Proxy_Impl; +- friend class _TAO_IDLType_ThruPOA_Proxy_Impl; +- friend class _TAO_IDLType_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_IDLType_type_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ ); + +- private: +- TAO_ClientRequestInfo_IR_IDLType_type_get (const TAO_ClientRequestInfo_IR_IDLType_type_get &); +- void operator= (const TAO_ClientRequestInfo_IR_IDLType_type_get &); +- void result (CORBA::TypeCode_ptr result); +- // update the result +- CORBA::TypeCode_ptr result_; +- }; ++ friend class _TAO_IDLType_Remote_Proxy_Impl; ++ friend class _TAO_IDLType_ThruPOA_Proxy_Impl; ++ friend class _TAO_IDLType_Direct_Proxy_Impl; + +- #endif /* TAO_HAS_INTERCEPTORS */ +- ++ virtual ~IR_IDLType (void); ++private: ++ IR_IDLType (const IR_IDLType &); ++ void operator= (const IR_IDLType &); + }; + + +@@ -7972,14 +5148,14 @@ + // + + class TAO_Export _TAO_IDLType_Proxy_Impl : +- public virtual CORBA::_TAO_IRObject_Proxy_Impl ++ public virtual _TAO_IRObject_Proxy_Impl + { + public: + virtual ~_TAO_IDLType_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr type ( ++ virtual CORBA::TypeCode_ptr type ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException +@@ -7989,6 +5165,7 @@ + _TAO_IDLType_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -8001,7 +5178,7 @@ + class TAO_Export _TAO_IDLType_Remote_Proxy_Impl : + public virtual _TAO_IDLType_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual CORBA::_TAO_IRObject_Remote_Proxy_Impl ++ public virtual _TAO_IRObject_Remote_Proxy_Impl + + { + public: +@@ -8009,9 +5186,9 @@ + + virtual ~_TAO_IDLType_Remote_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr type ( ++ virtual CORBA::TypeCode_ptr type ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException +@@ -8039,8 +5216,9 @@ + { + public: + virtual ~_TAO_IDLType_Proxy_Broker (void); ++ + virtual _TAO_IDLType_Proxy_Impl &select_proxy ( +- IDLType *object, ++ IR_IDLType *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -8065,9 +5243,9 @@ + _TAO_IDLType_Remote_Proxy_Broker (void); + + virtual ~_TAO_IDLType_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_IDLType_Proxy_Impl &select_proxy ( +- IDLType *object, ++ IR_IDLType *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -8081,426 +5259,283 @@ + static _TAO_IDLType_Remote_Proxy_Broker *the_TAO_IDLType_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IDLType; +- +-class PrimitiveDef; +- +-#if !defined (_TAO_IR_PRIMITIVEDEF___PTR_CH_) +-#define _TAO_IR_PRIMITIVEDEF___PTR_CH_ +- +-typedef PrimitiveDef *PrimitiveDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PRIMITIVEDEF___VAR_CH_) +-#define _TAO_IR_PRIMITIVEDEF___VAR_CH_ +- +-class TAO_Export PrimitiveDef_var : public TAO_Base_var ++class TAO_Export IR_PrimitiveDef_var : public TAO_Base_var + { + public: +- PrimitiveDef_var (void); // default constructor +- PrimitiveDef_var (PrimitiveDef_ptr p) : ptr_ (p) {} +- PrimitiveDef_var (const PrimitiveDef_var &); // copy constructor +- ~PrimitiveDef_var (void); // destructor ++ IR_PrimitiveDef_var (void); // default constructor ++ IR_PrimitiveDef_var (IR_PrimitiveDef_ptr p) : ptr_ (p) {} ++ IR_PrimitiveDef_var (const IR_PrimitiveDef_var &); // copy constructor ++ ~IR_PrimitiveDef_var (void); // destructor + +- PrimitiveDef_var &operator= (PrimitiveDef_ptr); +- PrimitiveDef_var &operator= (const PrimitiveDef_var &); +- PrimitiveDef_ptr operator-> (void) const; ++ IR_PrimitiveDef_var &operator= (IR_PrimitiveDef_ptr); ++ IR_PrimitiveDef_var &operator= (const IR_PrimitiveDef_var &); ++ IR_PrimitiveDef_ptr operator-> (void) const; + +- operator const PrimitiveDef_ptr &() const; +- operator PrimitiveDef_ptr &(); ++ operator const IR_PrimitiveDef_ptr &() const; ++ operator IR_PrimitiveDef_ptr &(); + // in, inout, out, _retn +- PrimitiveDef_ptr in (void) const; +- PrimitiveDef_ptr &inout (void); +- PrimitiveDef_ptr &out (void); +- PrimitiveDef_ptr _retn (void); +- PrimitiveDef_ptr ptr (void) const; ++ IR_PrimitiveDef_ptr in (void) const; ++ IR_PrimitiveDef_ptr &inout (void); ++ IR_PrimitiveDef_ptr &out (void); ++ IR_PrimitiveDef_ptr _retn (void); ++ IR_PrimitiveDef_ptr ptr (void) const; + + private: +- PrimitiveDef_ptr ptr_; ++ IR_PrimitiveDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- PrimitiveDef_var (const TAO_Base_var &rhs); +- PrimitiveDef_var &operator= (const TAO_Base_var &rhs); ++ IR_PrimitiveDef_var (const TAO_Base_var &rhs); ++ IR_PrimitiveDef_var &operator= (const TAO_Base_var &rhs); + }; + + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PRIMITIVEDEF___OUT_CH_) +-#define _TAO_IR_PRIMITIVEDEF___OUT_CH_ +- +-class TAO_Export PrimitiveDef_out ++class TAO_Export IR_PrimitiveDef_out + { + public: +- PrimitiveDef_out (PrimitiveDef_ptr &); +- PrimitiveDef_out (PrimitiveDef_var &); +- PrimitiveDef_out (const PrimitiveDef_out &); +- PrimitiveDef_out &operator= (const PrimitiveDef_out &); +- PrimitiveDef_out &operator= (const PrimitiveDef_var &); +- PrimitiveDef_out &operator= (PrimitiveDef_ptr); +- operator PrimitiveDef_ptr &(); +- PrimitiveDef_ptr &ptr (void); +- PrimitiveDef_ptr operator-> (void); ++ IR_PrimitiveDef_out (IR_PrimitiveDef_ptr &); ++ IR_PrimitiveDef_out (IR_PrimitiveDef_var &); ++ IR_PrimitiveDef_out (const IR_PrimitiveDef_out &); ++ IR_PrimitiveDef_out &operator= (const IR_PrimitiveDef_out &); ++ IR_PrimitiveDef_out &operator= (const IR_PrimitiveDef_var &); ++ IR_PrimitiveDef_out &operator= (IR_PrimitiveDef_ptr); ++ operator IR_PrimitiveDef_ptr &(); ++ IR_PrimitiveDef_ptr &ptr (void); ++ IR_PrimitiveDef_ptr operator-> (void); + + private: +- PrimitiveDef_ptr &ptr_; ++ IR_PrimitiveDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class StringDef; +- +-#if !defined (_TAO_IR_STRINGDEF___PTR_CH_) +-#define _TAO_IR_STRINGDEF___PTR_CH_ +- +-typedef StringDef *StringDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_STRINGDEF___VAR_CH_) +-#define _TAO_IR_STRINGDEF___VAR_CH_ +- +-class TAO_Export StringDef_var : public TAO_Base_var ++class TAO_Export IR_StringDef_var : public TAO_Base_var + { + public: +- StringDef_var (void); // default constructor +- StringDef_var (StringDef_ptr p) : ptr_ (p) {} +- StringDef_var (const StringDef_var &); // copy constructor +- ~StringDef_var (void); // destructor ++ IR_StringDef_var (void); // default constructor ++ IR_StringDef_var (IR_StringDef_ptr p) : ptr_ (p) {} ++ IR_StringDef_var (const IR_StringDef_var &); // copy constructor ++ ~IR_StringDef_var (void); // destructor + +- StringDef_var &operator= (StringDef_ptr); +- StringDef_var &operator= (const StringDef_var &); +- StringDef_ptr operator-> (void) const; ++ IR_StringDef_var &operator= (IR_StringDef_ptr); ++ IR_StringDef_var &operator= (const IR_StringDef_var &); ++ IR_StringDef_ptr operator-> (void) const; + +- operator const StringDef_ptr &() const; +- operator StringDef_ptr &(); ++ operator const IR_StringDef_ptr &() const; ++ operator IR_StringDef_ptr &(); + // in, inout, out, _retn +- StringDef_ptr in (void) const; +- StringDef_ptr &inout (void); +- StringDef_ptr &out (void); +- StringDef_ptr _retn (void); +- StringDef_ptr ptr (void) const; ++ IR_StringDef_ptr in (void) const; ++ IR_StringDef_ptr &inout (void); ++ IR_StringDef_ptr &out (void); ++ IR_StringDef_ptr _retn (void); ++ IR_StringDef_ptr ptr (void) const; + + private: +- StringDef_ptr ptr_; ++ IR_StringDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- StringDef_var (const TAO_Base_var &rhs); +- StringDef_var &operator= (const TAO_Base_var &rhs); ++ IR_StringDef_var (const TAO_Base_var &rhs); ++ IR_StringDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_STRINGDEF___OUT_CH_) +-#define _TAO_IR_STRINGDEF___OUT_CH_ +- +-class TAO_Export StringDef_out ++class TAO_Export IR_StringDef_out + { + public: +- StringDef_out (StringDef_ptr &); +- StringDef_out (StringDef_var &); +- StringDef_out (const StringDef_out &); +- StringDef_out &operator= (const StringDef_out &); +- StringDef_out &operator= (const StringDef_var &); +- StringDef_out &operator= (StringDef_ptr); +- operator StringDef_ptr &(); +- StringDef_ptr &ptr (void); +- StringDef_ptr operator-> (void); ++ IR_StringDef_out (IR_StringDef_ptr &); ++ IR_StringDef_out (IR_StringDef_var &); ++ IR_StringDef_out (const IR_StringDef_out &); ++ IR_StringDef_out &operator= (const IR_StringDef_out &); ++ IR_StringDef_out &operator= (const IR_StringDef_var &); ++ IR_StringDef_out &operator= (IR_StringDef_ptr); ++ operator IR_StringDef_ptr &(); ++ IR_StringDef_ptr &ptr (void); ++ IR_StringDef_ptr operator-> (void); + + private: +- StringDef_ptr &ptr_; ++ IR_StringDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class SequenceDef; +- +-#if !defined (_TAO_IR_SEQUENCEDEF___PTR_CH_) +-#define _TAO_IR_SEQUENCEDEF___PTR_CH_ +- +-typedef SequenceDef *SequenceDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_SEQUENCEDEF___VAR_CH_) +-#define _TAO_IR_SEQUENCEDEF___VAR_CH_ +- +-class TAO_Export SequenceDef_var : public TAO_Base_var ++class TAO_Export IR_SequenceDef_var : public TAO_Base_var + { + public: +- SequenceDef_var (void); // default constructor +- SequenceDef_var (SequenceDef_ptr p) : ptr_ (p) {} +- SequenceDef_var (const SequenceDef_var &); // copy constructor +- ~SequenceDef_var (void); // destructor ++ IR_SequenceDef_var (void); // default constructor ++ IR_SequenceDef_var (IR_SequenceDef_ptr p) : ptr_ (p) {} ++ IR_SequenceDef_var (const IR_SequenceDef_var &); // copy constructor ++ ~IR_SequenceDef_var (void); // destructor + +- SequenceDef_var &operator= (SequenceDef_ptr); +- SequenceDef_var &operator= (const SequenceDef_var &); +- SequenceDef_ptr operator-> (void) const; ++ IR_SequenceDef_var &operator= (IR_SequenceDef_ptr); ++ IR_SequenceDef_var &operator= (const IR_SequenceDef_var &); ++ IR_SequenceDef_ptr operator-> (void) const; + +- operator const SequenceDef_ptr &() const; +- operator SequenceDef_ptr &(); ++ operator const IR_SequenceDef_ptr &() const; ++ operator IR_SequenceDef_ptr &(); + // in, inout, out, _retn +- SequenceDef_ptr in (void) const; +- SequenceDef_ptr &inout (void); +- SequenceDef_ptr &out (void); +- SequenceDef_ptr _retn (void); +- SequenceDef_ptr ptr (void) const; ++ IR_SequenceDef_ptr in (void) const; ++ IR_SequenceDef_ptr &inout (void); ++ IR_SequenceDef_ptr &out (void); ++ IR_SequenceDef_ptr _retn (void); ++ IR_SequenceDef_ptr ptr (void) const; + + private: +- SequenceDef_ptr ptr_; ++ IR_SequenceDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- SequenceDef_var (const TAO_Base_var &rhs); +- SequenceDef_var &operator= (const TAO_Base_var &rhs); ++ IR_SequenceDef_var (const TAO_Base_var &rhs); ++ IR_SequenceDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_SEQUENCEDEF___OUT_CH_) +-#define _TAO_IR_SEQUENCEDEF___OUT_CH_ +- +-class TAO_Export SequenceDef_out ++class TAO_Export IR_SequenceDef_out + { + public: +- SequenceDef_out (SequenceDef_ptr &); +- SequenceDef_out (SequenceDef_var &); +- SequenceDef_out (const SequenceDef_out &); +- SequenceDef_out &operator= (const SequenceDef_out &); +- SequenceDef_out &operator= (const SequenceDef_var &); +- SequenceDef_out &operator= (SequenceDef_ptr); +- operator SequenceDef_ptr &(); +- SequenceDef_ptr &ptr (void); +- SequenceDef_ptr operator-> (void); ++ IR_SequenceDef_out (IR_SequenceDef_ptr &); ++ IR_SequenceDef_out (IR_SequenceDef_var &); ++ IR_SequenceDef_out (const IR_SequenceDef_out &); ++ IR_SequenceDef_out &operator= (const IR_SequenceDef_out &); ++ IR_SequenceDef_out &operator= (const IR_SequenceDef_var &); ++ IR_SequenceDef_out &operator= (IR_SequenceDef_ptr); ++ operator IR_SequenceDef_ptr &(); ++ IR_SequenceDef_ptr &ptr (void); ++ IR_SequenceDef_ptr operator-> (void); + + private: +- SequenceDef_ptr &ptr_; ++ IR_SequenceDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class ArrayDef; +- +-#if !defined (_TAO_IR_ARRAYDEF___PTR_CH_) +-#define _TAO_IR_ARRAYDEF___PTR_CH_ +- +-typedef ArrayDef *ArrayDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ARRAYDEF___VAR_CH_) +-#define _TAO_IR_ARRAYDEF___VAR_CH_ +- +-class TAO_Export ArrayDef_var : public TAO_Base_var ++class TAO_Export IR_ArrayDef_var : public TAO_Base_var + { + public: +- ArrayDef_var (void); // default constructor +- ArrayDef_var (ArrayDef_ptr p) : ptr_ (p) {} +- ArrayDef_var (const ArrayDef_var &); // copy constructor +- ~ArrayDef_var (void); // destructor ++ IR_ArrayDef_var (void); // default constructor ++ IR_ArrayDef_var (IR_ArrayDef_ptr p) : ptr_ (p) {} ++ IR_ArrayDef_var (const IR_ArrayDef_var &); // copy constructor ++ ~IR_ArrayDef_var (void); // destructor + +- ArrayDef_var &operator= (ArrayDef_ptr); +- ArrayDef_var &operator= (const ArrayDef_var &); +- ArrayDef_ptr operator-> (void) const; ++ IR_ArrayDef_var &operator= (IR_ArrayDef_ptr); ++ IR_ArrayDef_var &operator= (const IR_ArrayDef_var &); ++ IR_ArrayDef_ptr operator-> (void) const; + +- operator const ArrayDef_ptr &() const; +- operator ArrayDef_ptr &(); ++ operator const IR_ArrayDef_ptr &() const; ++ operator IR_ArrayDef_ptr &(); + // in, inout, out, _retn +- ArrayDef_ptr in (void) const; +- ArrayDef_ptr &inout (void); +- ArrayDef_ptr &out (void); +- ArrayDef_ptr _retn (void); +- ArrayDef_ptr ptr (void) const; ++ IR_ArrayDef_ptr in (void) const; ++ IR_ArrayDef_ptr &inout (void); ++ IR_ArrayDef_ptr &out (void); ++ IR_ArrayDef_ptr _retn (void); ++ IR_ArrayDef_ptr ptr (void) const; + + private: +- ArrayDef_ptr ptr_; ++ IR_ArrayDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- ArrayDef_var (const TAO_Base_var &rhs); +- ArrayDef_var &operator= (const TAO_Base_var &rhs); ++ IR_ArrayDef_var (const TAO_Base_var &rhs); ++ IR_ArrayDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ARRAYDEF___OUT_CH_) +-#define _TAO_IR_ARRAYDEF___OUT_CH_ +- +-class TAO_Export ArrayDef_out ++class TAO_Export IR_ArrayDef_out + { + public: +- ArrayDef_out (ArrayDef_ptr &); +- ArrayDef_out (ArrayDef_var &); +- ArrayDef_out (const ArrayDef_out &); +- ArrayDef_out &operator= (const ArrayDef_out &); +- ArrayDef_out &operator= (const ArrayDef_var &); +- ArrayDef_out &operator= (ArrayDef_ptr); +- operator ArrayDef_ptr &(); +- ArrayDef_ptr &ptr (void); +- ArrayDef_ptr operator-> (void); ++ IR_ArrayDef_out (IR_ArrayDef_ptr &); ++ IR_ArrayDef_out (IR_ArrayDef_var &); ++ IR_ArrayDef_out (const IR_ArrayDef_out &); ++ IR_ArrayDef_out &operator= (const IR_ArrayDef_out &); ++ IR_ArrayDef_out &operator= (const IR_ArrayDef_var &); ++ IR_ArrayDef_out &operator= (IR_ArrayDef_ptr); ++ operator IR_ArrayDef_ptr &(); ++ IR_ArrayDef_ptr &ptr (void); ++ IR_ArrayDef_ptr operator-> (void); + + private: +- ArrayDef_ptr &ptr_; ++ IR_ArrayDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class WstringDef; +- +-#if !defined (_TAO_IR_WSTRINGDEF___PTR_CH_) +-#define _TAO_IR_WSTRINGDEF___PTR_CH_ +- +-typedef WstringDef *WstringDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_WSTRINGDEF___VAR_CH_) +-#define _TAO_IR_WSTRINGDEF___VAR_CH_ +- +-class TAO_Export WstringDef_var : public TAO_Base_var ++class TAO_Export IR_WstringDef_var : public TAO_Base_var + { + public: +- WstringDef_var (void); // default constructor +- WstringDef_var (WstringDef_ptr p) : ptr_ (p) {} +- WstringDef_var (const WstringDef_var &); // copy constructor +- ~WstringDef_var (void); // destructor ++ IR_WstringDef_var (void); // default constructor ++ IR_WstringDef_var (IR_WstringDef_ptr p) : ptr_ (p) {} ++ IR_WstringDef_var (const IR_WstringDef_var &); // copy constructor ++ ~IR_WstringDef_var (void); // destructor + +- WstringDef_var &operator= (WstringDef_ptr); +- WstringDef_var &operator= (const WstringDef_var &); +- WstringDef_ptr operator-> (void) const; ++ IR_WstringDef_var &operator= (IR_WstringDef_ptr); ++ IR_WstringDef_var &operator= (const IR_WstringDef_var &); ++ IR_WstringDef_ptr operator-> (void) const; + +- operator const WstringDef_ptr &() const; +- operator WstringDef_ptr &(); ++ operator const IR_WstringDef_ptr &() const; ++ operator IR_WstringDef_ptr &(); + // in, inout, out, _retn +- WstringDef_ptr in (void) const; +- WstringDef_ptr &inout (void); +- WstringDef_ptr &out (void); +- WstringDef_ptr _retn (void); +- WstringDef_ptr ptr (void) const; ++ IR_WstringDef_ptr in (void) const; ++ IR_WstringDef_ptr &inout (void); ++ IR_WstringDef_ptr &out (void); ++ IR_WstringDef_ptr _retn (void); ++ IR_WstringDef_ptr ptr (void) const; + + private: +- WstringDef_ptr ptr_; ++ IR_WstringDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- WstringDef_var (const TAO_Base_var &rhs); +- WstringDef_var &operator= (const TAO_Base_var &rhs); ++ IR_WstringDef_var (const TAO_Base_var &rhs); ++ IR_WstringDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_WSTRINGDEF___OUT_CH_) +-#define _TAO_IR_WSTRINGDEF___OUT_CH_ +- +-class TAO_Export WstringDef_out ++class TAO_Export IR_WstringDef_out + { + public: +- WstringDef_out (WstringDef_ptr &); +- WstringDef_out (WstringDef_var &); +- WstringDef_out (const WstringDef_out &); +- WstringDef_out &operator= (const WstringDef_out &); +- WstringDef_out &operator= (const WstringDef_var &); +- WstringDef_out &operator= (WstringDef_ptr); +- operator WstringDef_ptr &(); +- WstringDef_ptr &ptr (void); +- WstringDef_ptr operator-> (void); ++ IR_WstringDef_out (IR_WstringDef_ptr &); ++ IR_WstringDef_out (IR_WstringDef_var &); ++ IR_WstringDef_out (const IR_WstringDef_out &); ++ IR_WstringDef_out &operator= (const IR_WstringDef_out &); ++ IR_WstringDef_out &operator= (const IR_WstringDef_var &); ++ IR_WstringDef_out &operator= (IR_WstringDef_ptr); ++ operator IR_WstringDef_ptr &(); ++ IR_WstringDef_ptr &ptr (void); ++ IR_WstringDef_ptr operator-> (void); + + private: +- WstringDef_ptr &ptr_; ++ IR_WstringDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-class FixedDef; +- +-#if !defined (_TAO_IR_FIXEDDEF___PTR_CH_) +-#define _TAO_IR_FIXEDDEF___PTR_CH_ +- +-typedef FixedDef *FixedDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FIXEDDEF___VAR_CH_) +-#define _TAO_IR_FIXEDDEF___VAR_CH_ +- +-class TAO_Export FixedDef_var : public TAO_Base_var ++class TAO_Export IR_FixedDef_var : public TAO_Base_var + { + public: +- FixedDef_var (void); // default constructor +- FixedDef_var (FixedDef_ptr p) : ptr_ (p) {} +- FixedDef_var (const FixedDef_var &); // copy constructor +- ~FixedDef_var (void); // destructor ++ IR_FixedDef_var (void); // default constructor ++ IR_FixedDef_var (IR_FixedDef_ptr p) : ptr_ (p) {} ++ IR_FixedDef_var (const IR_FixedDef_var &); // copy constructor ++ ~IR_FixedDef_var (void); // destructor + +- FixedDef_var &operator= (FixedDef_ptr); +- FixedDef_var &operator= (const FixedDef_var &); +- FixedDef_ptr operator-> (void) const; ++ IR_FixedDef_var &operator= (IR_FixedDef_ptr); ++ IR_FixedDef_var &operator= (const IR_FixedDef_var &); ++ IR_FixedDef_ptr operator-> (void) const; + +- operator const FixedDef_ptr &() const; +- operator FixedDef_ptr &(); ++ operator const IR_FixedDef_ptr &() const; ++ operator IR_FixedDef_ptr &(); + // in, inout, out, _retn +- FixedDef_ptr in (void) const; +- FixedDef_ptr &inout (void); +- FixedDef_ptr &out (void); +- FixedDef_ptr _retn (void); +- FixedDef_ptr ptr (void) const; ++ IR_FixedDef_ptr in (void) const; ++ IR_FixedDef_ptr &inout (void); ++ IR_FixedDef_ptr &out (void); ++ IR_FixedDef_ptr _retn (void); ++ IR_FixedDef_ptr ptr (void) const; + + private: +- FixedDef_ptr ptr_; ++ IR_FixedDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- FixedDef_var (const TAO_Base_var &rhs); +- FixedDef_var &operator= (const TAO_Base_var &rhs); ++ IR_FixedDef_var (const TAO_Base_var &rhs); ++ IR_FixedDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FIXEDDEF___OUT_CH_) +-#define _TAO_IR_FIXEDDEF___OUT_CH_ +- +-class TAO_Export FixedDef_out ++class TAO_Export IR_FixedDef_out + { + public: +- FixedDef_out (FixedDef_ptr &); +- FixedDef_out (FixedDef_var &); +- FixedDef_out (const FixedDef_out &); +- FixedDef_out &operator= (const FixedDef_out &); +- FixedDef_out &operator= (const FixedDef_var &); +- FixedDef_out &operator= (FixedDef_ptr); +- operator FixedDef_ptr &(); +- FixedDef_ptr &ptr (void); +- FixedDef_ptr operator-> (void); ++ IR_FixedDef_out (IR_FixedDef_ptr &); ++ IR_FixedDef_out (IR_FixedDef_var &); ++ IR_FixedDef_out (const IR_FixedDef_out &); ++ IR_FixedDef_out &operator= (const IR_FixedDef_out &); ++ IR_FixedDef_out &operator= (const IR_FixedDef_var &); ++ IR_FixedDef_out &operator= (IR_FixedDef_ptr); ++ operator IR_FixedDef_ptr &(); ++ IR_FixedDef_ptr &ptr (void); ++ IR_FixedDef_ptr operator-> (void); + + private: +- FixedDef_ptr &ptr_; ++ IR_FixedDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +-enum PrimitiveKind +-{ ++enum IR_PrimitiveKind ++ { + pk_null, + pk_void, + pk_short, +@@ -8522,82 +5557,8 @@ + pk_longdouble, + pk_wchar, + pk_wstring, +- pk_value_base +-}; +-typedef PrimitiveKind &PrimitiveKind_out; +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimitiveKind; +- +- +-#if !defined (_TAO_IR_REPOSITORY___PTR_CH_) +-#define _TAO_IR_REPOSITORY___PTR_CH_ +- +-class Repository; +-typedef Repository *Repository_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_REPOSITORY___VAR_CH_) +-#define _TAO_IR_REPOSITORY___VAR_CH_ +- +-class TAO_Export Repository_var : public TAO_Base_var +-{ +-public: +- Repository_var (void); // default constructor +- Repository_var (Repository_ptr p) : ptr_ (p) {} +- Repository_var (const Repository_var &); // copy constructor +- ~Repository_var (void); // destructor +- +- Repository_var &operator= (Repository_ptr); +- Repository_var &operator= (const Repository_var &); +- Repository_ptr operator-> (void) const; +- +- operator const Repository_ptr &() const; +- operator Repository_ptr &(); +- // in, inout, out, _retn +- Repository_ptr in (void) const; +- Repository_ptr &inout (void); +- Repository_ptr &out (void); +- Repository_ptr _retn (void); +- Repository_ptr ptr (void) const; +- +-private: +- Repository_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- Repository_var (const TAO_Base_var &rhs); +- Repository_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_REPOSITORY___OUT_CH_) +-#define _TAO_IR_REPOSITORY___OUT_CH_ +- +-class TAO_Export Repository_out +-{ +-public: +- Repository_out (Repository_ptr &); +- Repository_out (Repository_var &); +- Repository_out (const Repository_out &); +- Repository_out &operator= (const Repository_out &); +- Repository_out &operator= (const Repository_var &); +- Repository_out &operator= (Repository_ptr); +- operator Repository_ptr &(); +- Repository_ptr &ptr (void); +- Repository_ptr operator-> (void); +- +-private: +- Repository_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_REPOSITORY_CH_) +-#define _TAO_IR_REPOSITORY_CH_ ++ pk_value_base ++ }; + + // Forward Classes Declaration + class _TAO_Repository_Proxy_Impl; +@@ -8605,34 +5566,34 @@ + class _TAO_Repository_Proxy_Broker; + class _TAO_Repository_Remote_Proxy_Broker; + +-class TAO_Export Repository: public virtual Container ++class TAO_Export IR_Repository: public virtual IR_Container + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef Repository_ptr _ptr_type; +- typedef Repository_var _var_type; ++ typedef IR_Repository_ptr _ptr_type; ++ typedef IR_Repository_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static Repository_ptr _duplicate (Repository_ptr obj); +- static Repository_ptr _narrow ( ++ static IR_Repository_ptr _duplicate (IR_Repository_ptr obj); ++ static IR_Repository_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static Repository_ptr _unchecked_narrow ( ++ static IR_Repository_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static Repository_ptr _nil (void) ++ static IR_Repository_ptr _nil (void) + { +- return (Repository_ptr)0; ++ return (IR_Repository_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::Contained_ptr lookup_id ( ++ virtual IR_Contained_ptr lookup_id ( + const char * search_id, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () +@@ -8650,8 +5611,8 @@ + CORBA::SystemException + )); + +- virtual IR::PrimitiveDef_ptr get_primitive ( +- IR::PrimitiveKind kind, ++ virtual IR_PrimitiveDef_ptr get_primitive ( ++ IR_PrimitiveKind kind, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -8659,7 +5620,7 @@ + CORBA::SystemException + )); + +- virtual IR::StringDef_ptr create_string ( ++ virtual IR_StringDef_ptr create_string ( + CORBA::ULong bound, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () +@@ -8668,7 +5629,7 @@ + CORBA::SystemException + )); + +- virtual IR::WstringDef_ptr create_wstring ( ++ virtual IR_WstringDef_ptr create_wstring ( + CORBA::ULong bound, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () +@@ -8677,9 +5638,9 @@ + CORBA::SystemException + )); + +- virtual IR::SequenceDef_ptr create_sequence ( ++ virtual IR_SequenceDef_ptr create_sequence ( + CORBA::ULong bound, +- IR::IDLType_ptr element_type, ++ IR_IDLType_ptr element_type, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -8687,9 +5648,9 @@ + CORBA::SystemException + )); + +- virtual IR::ArrayDef_ptr create_array ( ++ virtual IR_ArrayDef_ptr create_array ( + CORBA::ULong length, +- IR::IDLType_ptr element_type, ++ IR_IDLType_ptr element_type, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -8697,7 +5658,7 @@ + CORBA::SystemException + )); + +- virtual IR::FixedDef_ptr create_fixed ( ++ virtual IR_FixedDef_ptr create_fixed ( + CORBA::UShort digits, + CORBA::Short scale, + CORBA::Environment &ACE_TRY_ENV = +@@ -8720,401 +5681,27 @@ + _TAO_Repository_Proxy_Broker *the_TAO_Repository_Proxy_Broker_; + + protected: +- Repository (int collocated = 0); ++ IR_Repository (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- Repository ( ++ IR_Repository ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_Repository_Remote_Proxy_Impl; +- friend class _TAO_Repository_ThruPOA_Proxy_Impl; +- friend class _TAO_Repository_Direct_Proxy_Impl; +- +- virtual ~Repository (void); +- private: +- Repository (const Repository &); +- void operator= (const Repository &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_Repository_lookup_id : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::Repository; +- +- friend class _TAO_Repository_Remote_Proxy_Impl; +- friend class _TAO_Repository_ThruPOA_Proxy_Impl; +- friend class _TAO_Repository_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_Repository_lookup_id ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * search_id, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_Repository_lookup_id (const TAO_ClientRequestInfo_IR_Repository_lookup_id &); +- void operator= (const TAO_ClientRequestInfo_IR_Repository_lookup_id &); +- const char * search_id_; +- void result (IR::Contained_ptr result); +- // update the result +- IR::Contained_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_Repository_get_canonical_typecode : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::Repository; +- +- friend class _TAO_Repository_Remote_Proxy_Impl; +- friend class _TAO_Repository_ThruPOA_Proxy_Impl; +- friend class _TAO_Repository_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_Repository_get_canonical_typecode ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::TypeCode_ptr tc, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Repository_get_canonical_typecode (const TAO_ClientRequestInfo_IR_Repository_get_canonical_typecode &); +- void operator= (const TAO_ClientRequestInfo_IR_Repository_get_canonical_typecode &); +- CORBA::TypeCode_ptr tc_; +- void result (CORBA::TypeCode_ptr result); +- // update the result +- CORBA::TypeCode_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Repository_get_primitive : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Repository; +- +- friend class _TAO_Repository_Remote_Proxy_Impl; +- friend class _TAO_Repository_ThruPOA_Proxy_Impl; +- friend class _TAO_Repository_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Repository_get_primitive ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::PrimitiveKind & kind, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Repository_get_primitive (const TAO_ClientRequestInfo_IR_Repository_get_primitive &); +- void operator= (const TAO_ClientRequestInfo_IR_Repository_get_primitive &); +- const IR::PrimitiveKind & kind_; +- void result (IR::PrimitiveDef_ptr result); +- // update the result +- IR::PrimitiveDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Repository_create_string : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Repository; +- +- friend class _TAO_Repository_Remote_Proxy_Impl; +- friend class _TAO_Repository_ThruPOA_Proxy_Impl; +- friend class _TAO_Repository_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Repository_create_string ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::ULong & bound, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Repository_create_string (const TAO_ClientRequestInfo_IR_Repository_create_string &); +- void operator= (const TAO_ClientRequestInfo_IR_Repository_create_string &); +- const CORBA::ULong & bound_; +- void result (IR::StringDef_ptr result); +- // update the result +- IR::StringDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Repository_create_wstring : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Repository; +- +- friend class _TAO_Repository_Remote_Proxy_Impl; +- friend class _TAO_Repository_ThruPOA_Proxy_Impl; +- friend class _TAO_Repository_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Repository_create_wstring ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::ULong & bound, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Repository_create_wstring (const TAO_ClientRequestInfo_IR_Repository_create_wstring &); +- void operator= (const TAO_ClientRequestInfo_IR_Repository_create_wstring &); +- const CORBA::ULong & bound_; +- void result (IR::WstringDef_ptr result); +- // update the result +- IR::WstringDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Repository_create_sequence : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Repository; +- +- friend class _TAO_Repository_Remote_Proxy_Impl; +- friend class _TAO_Repository_ThruPOA_Proxy_Impl; +- friend class _TAO_Repository_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Repository_create_sequence ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::ULong & bound, +- IR::IDLType_ptr element_type, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Repository_create_sequence (const TAO_ClientRequestInfo_IR_Repository_create_sequence &); +- void operator= (const TAO_ClientRequestInfo_IR_Repository_create_sequence &); +- const CORBA::ULong & bound_; +- IR::IDLType_ptr element_type_; +- void result (IR::SequenceDef_ptr result); +- // update the result +- IR::SequenceDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Repository_create_array : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Repository; +- ++ + friend class _TAO_Repository_Remote_Proxy_Impl; + friend class _TAO_Repository_ThruPOA_Proxy_Impl; + friend class _TAO_Repository_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Repository_create_array ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::ULong & length, +- IR::IDLType_ptr element_type, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Repository_create_array (const TAO_ClientRequestInfo_IR_Repository_create_array &); +- void operator= (const TAO_ClientRequestInfo_IR_Repository_create_array &); +- const CORBA::ULong & length_; +- IR::IDLType_ptr element_type_; +- void result (IR::ArrayDef_ptr result); +- // update the result +- IR::ArrayDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_Repository_create_fixed : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::Repository; + +- friend class _TAO_Repository_Remote_Proxy_Impl; +- friend class _TAO_Repository_ThruPOA_Proxy_Impl; +- friend class _TAO_Repository_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_Repository_create_fixed ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::UShort & digits, +- const CORBA::Short & scale, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_Repository_create_fixed (const TAO_ClientRequestInfo_IR_Repository_create_fixed &); +- void operator= (const TAO_ClientRequestInfo_IR_Repository_create_fixed &); +- const CORBA::UShort & digits_; +- const CORBA::Short & scale_; +- void result (IR::FixedDef_ptr result); +- // update the result +- IR::FixedDef_ptr result_; +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ virtual ~IR_Repository (void); ++private: ++ IR_Repository (const IR_Repository &); ++ void operator= (const IR_Repository &); + }; + + +@@ -9128,12 +5715,12 @@ + // + + class TAO_Export _TAO_Repository_Proxy_Impl : +- public virtual IR::_TAO_Container_Proxy_Impl ++ public virtual _TAO_Container_Proxy_Impl + { + public: + virtual ~_TAO_Repository_Proxy_Impl (void) { } + +- virtual IR::Contained_ptr lookup_id ( ++ virtual IR_Contained_ptr lookup_id ( + CORBA_Object *_collocated_tao_target_, + const char * search_id, + CORBA::Environment &ACE_TRY_ENV +@@ -9151,16 +5738,16 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::PrimitiveDef_ptr get_primitive ( ++ virtual IR_PrimitiveDef_ptr get_primitive ( + CORBA_Object *_collocated_tao_target_, +- IR::PrimitiveKind kind, ++ IR_PrimitiveKind kind, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::StringDef_ptr create_string ( ++ virtual IR_StringDef_ptr create_string ( + CORBA_Object *_collocated_tao_target_, + CORBA::ULong bound, + CORBA::Environment &ACE_TRY_ENV +@@ -9169,7 +5756,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::WstringDef_ptr create_wstring ( ++ virtual IR_WstringDef_ptr create_wstring ( + CORBA_Object *_collocated_tao_target_, + CORBA::ULong bound, + CORBA::Environment &ACE_TRY_ENV +@@ -9178,27 +5765,27 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::SequenceDef_ptr create_sequence ( ++ virtual IR_SequenceDef_ptr create_sequence ( + CORBA_Object *_collocated_tao_target_, + CORBA::ULong bound, +- IR::IDLType_ptr element_type, ++ IR_IDLType_ptr element_type, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::ArrayDef_ptr create_array ( ++ virtual IR_ArrayDef_ptr create_array ( + CORBA_Object *_collocated_tao_target_, + CORBA::ULong length, +- IR::IDLType_ptr element_type, ++ IR_IDLType_ptr element_type, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::FixedDef_ptr create_fixed ( ++ virtual IR_FixedDef_ptr create_fixed ( + CORBA_Object *_collocated_tao_target_, + CORBA::UShort digits, + CORBA::Short scale, +@@ -9212,6 +5799,7 @@ + _TAO_Repository_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -9224,7 +5812,7 @@ + class TAO_Export _TAO_Repository_Remote_Proxy_Impl : + public virtual _TAO_Repository_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Container_Remote_Proxy_Impl ++ public virtual _TAO_Container_Remote_Proxy_Impl + + { + public: +@@ -9232,7 +5820,7 @@ + + virtual ~_TAO_Repository_Remote_Proxy_Impl (void) { } + +- virtual IR::Contained_ptr lookup_id ( ++ virtual IR_Contained_ptr lookup_id ( + CORBA_Object *_collocated_tao_target_, + const char * search_id, + CORBA::Environment &ACE_TRY_ENV +@@ -9250,16 +5838,16 @@ + CORBA::SystemException + )); + +- virtual IR::PrimitiveDef_ptr get_primitive ( ++ virtual IR_PrimitiveDef_ptr get_primitive ( + CORBA_Object *_collocated_tao_target_, +- IR::PrimitiveKind kind, ++ IR_PrimitiveKind kind, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::StringDef_ptr create_string ( ++ virtual IR_StringDef_ptr create_string ( + CORBA_Object *_collocated_tao_target_, + CORBA::ULong bound, + CORBA::Environment &ACE_TRY_ENV +@@ -9268,7 +5856,7 @@ + CORBA::SystemException + )); + +- virtual IR::WstringDef_ptr create_wstring ( ++ virtual IR_WstringDef_ptr create_wstring ( + CORBA_Object *_collocated_tao_target_, + CORBA::ULong bound, + CORBA::Environment &ACE_TRY_ENV +@@ -9277,27 +5865,27 @@ + CORBA::SystemException + )); + +- virtual IR::SequenceDef_ptr create_sequence ( ++ virtual IR_SequenceDef_ptr create_sequence ( + CORBA_Object *_collocated_tao_target_, + CORBA::ULong bound, +- IR::IDLType_ptr element_type, ++ IR_IDLType_ptr element_type, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::ArrayDef_ptr create_array ( ++ virtual IR_ArrayDef_ptr create_array ( + CORBA_Object *_collocated_tao_target_, + CORBA::ULong length, +- IR::IDLType_ptr element_type, ++ IR_IDLType_ptr element_type, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::FixedDef_ptr create_fixed ( ++ virtual IR_FixedDef_ptr create_fixed ( + CORBA_Object *_collocated_tao_target_, + CORBA::UShort digits, + CORBA::Short scale, +@@ -9329,8 +5917,9 @@ + { + public: + virtual ~_TAO_Repository_Proxy_Broker (void); ++ + virtual _TAO_Repository_Proxy_Impl &select_proxy ( +- Repository *object, ++ IR_Repository *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -9355,9 +5944,9 @@ + _TAO_Repository_Remote_Proxy_Broker (void); + + virtual ~_TAO_Repository_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_Repository_Proxy_Impl &select_proxy ( +- Repository *object, ++ IR_Repository *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -9371,127 +5960,94 @@ + static _TAO_Repository_Remote_Proxy_Broker *the_TAO_Repository_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Repository; +- +- +-#if !defined (_TAO_IR_COMPONENTREPOSITORY___PTR_CH_) +-#define _TAO_IR_COMPONENTREPOSITORY___PTR_CH_ +- +-class ComponentRepository; +-typedef ComponentRepository *ComponentRepository_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_COMPONENTREPOSITORY___VAR_CH_) +-#define _TAO_IR_COMPONENTREPOSITORY___VAR_CH_ +- +-class TAO_Export ComponentRepository_var : public TAO_Base_var ++class TAO_Export IR_ComponentRepository_var : public TAO_Base_var + { + public: +- ComponentRepository_var (void); // default constructor +- ComponentRepository_var (ComponentRepository_ptr p) : ptr_ (p) {} +- ComponentRepository_var (const ComponentRepository_var &); // copy constructor +- ~ComponentRepository_var (void); // destructor ++ IR_ComponentRepository_var (void); // default constructor ++ IR_ComponentRepository_var (IR_ComponentRepository_ptr p) : ptr_ (p) {} ++ IR_ComponentRepository_var (const IR_ComponentRepository_var &); // copy constructor ++ ~IR_ComponentRepository_var (void); // destructor + +- ComponentRepository_var &operator= (ComponentRepository_ptr); +- ComponentRepository_var &operator= (const ComponentRepository_var &); +- ComponentRepository_ptr operator-> (void) const; ++ IR_ComponentRepository_var &operator= (IR_ComponentRepository_ptr); ++ IR_ComponentRepository_var &operator= (const IR_ComponentRepository_var &); ++ IR_ComponentRepository_ptr operator-> (void) const; + +- operator const ComponentRepository_ptr &() const; +- operator ComponentRepository_ptr &(); ++ operator const IR_ComponentRepository_ptr &() const; ++ operator IR_ComponentRepository_ptr &(); + // in, inout, out, _retn +- ComponentRepository_ptr in (void) const; +- ComponentRepository_ptr &inout (void); +- ComponentRepository_ptr &out (void); +- ComponentRepository_ptr _retn (void); +- ComponentRepository_ptr ptr (void) const; ++ IR_ComponentRepository_ptr in (void) const; ++ IR_ComponentRepository_ptr &inout (void); ++ IR_ComponentRepository_ptr &out (void); ++ IR_ComponentRepository_ptr _retn (void); ++ IR_ComponentRepository_ptr ptr (void) const; + + private: +- ComponentRepository_ptr ptr_; ++ IR_ComponentRepository_ptr ptr_; + // Unimplemented - prevents widening assignment. +- ComponentRepository_var (const TAO_Base_var &rhs); +- ComponentRepository_var &operator= (const TAO_Base_var &rhs); ++ IR_ComponentRepository_var (const TAO_Base_var &rhs); ++ IR_ComponentRepository_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_COMPONENTREPOSITORY___OUT_CH_) +-#define _TAO_IR_COMPONENTREPOSITORY___OUT_CH_ +- +-class TAO_Export ComponentRepository_out ++class TAO_Export IR_ComponentRepository_out + { + public: +- ComponentRepository_out (ComponentRepository_ptr &); +- ComponentRepository_out (ComponentRepository_var &); +- ComponentRepository_out (const ComponentRepository_out &); +- ComponentRepository_out &operator= (const ComponentRepository_out &); +- ComponentRepository_out &operator= (const ComponentRepository_var &); +- ComponentRepository_out &operator= (ComponentRepository_ptr); +- operator ComponentRepository_ptr &(); +- ComponentRepository_ptr &ptr (void); +- ComponentRepository_ptr operator-> (void); ++ IR_ComponentRepository_out (IR_ComponentRepository_ptr &); ++ IR_ComponentRepository_out (IR_ComponentRepository_var &); ++ IR_ComponentRepository_out (const IR_ComponentRepository_out &); ++ IR_ComponentRepository_out &operator= (const IR_ComponentRepository_out &); ++ IR_ComponentRepository_out &operator= (const IR_ComponentRepository_var &); ++ IR_ComponentRepository_out &operator= (IR_ComponentRepository_ptr); ++ operator IR_ComponentRepository_ptr &(); ++ IR_ComponentRepository_ptr &ptr (void); ++ IR_ComponentRepository_ptr operator-> (void); + + private: +- ComponentRepository_ptr &ptr_; ++ IR_ComponentRepository_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_COMPONENTREPOSITORY_CH_) +-#define _TAO_IR_COMPONENTREPOSITORY_CH_ +- + // Forward Classes Declaration + class _TAO_ComponentRepository_Proxy_Impl; + class _TAO_ComponentRepository_Remote_Proxy_Impl; + class _TAO_ComponentRepository_Proxy_Broker; + class _TAO_ComponentRepository_Remote_Proxy_Broker; + +-class TAO_Export ComponentRepository: public virtual Repository ++class TAO_Export IR_ComponentRepository: public virtual IR_Repository + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ComponentRepository_ptr _ptr_type; +- typedef ComponentRepository_var _var_type; ++ typedef IR_ComponentRepository_ptr _ptr_type; ++ typedef IR_ComponentRepository_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static ComponentRepository_ptr _duplicate (ComponentRepository_ptr obj); +- static ComponentRepository_ptr _narrow ( ++ static IR_ComponentRepository_ptr _duplicate (IR_ComponentRepository_ptr obj); ++ static IR_ComponentRepository_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ComponentRepository_ptr _unchecked_narrow ( ++ static IR_ComponentRepository_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ComponentRepository_ptr _nil (void) ++ static IR_ComponentRepository_ptr _nil (void) + { +- return (ComponentRepository_ptr)0; ++ return (IR_ComponentRepository_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::ComponentDef_ptr create_component ( ++ virtual IR_ComponentDef_ptr create_component ( + const char * id, + const char * name, + const char * version, +- IR::ComponentDef_ptr base_component, +- const IR::InterfaceDefSeq & supports_interfaces, ++ IR_ComponentDef_ptr base_component, ++ const IR_InterfaceDefSeq & supports_interfaces, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -9499,13 +6055,13 @@ + CORBA::SystemException + )); + +- virtual IR::HomeDef_ptr create_home ( ++ virtual IR_HomeDef_ptr create_home ( + const char * id, + const char * name, + const char * version, +- IR::HomeDef_ptr base_home, +- IR::ComponentDef_ptr managed_component, +- IR::ValueDef_ptr primary_key, ++ IR_HomeDef_ptr base_home, ++ IR_ComponentDef_ptr managed_component, ++ IR_ValueDef_ptr primary_key, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -9526,143 +6082,27 @@ + _TAO_ComponentRepository_Proxy_Broker *the_TAO_ComponentRepository_Proxy_Broker_; + + protected: +- ComponentRepository (int collocated = 0); ++ IR_ComponentRepository (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- ComponentRepository ( ++ IR_ComponentRepository ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_ComponentRepository_Remote_Proxy_Impl; +- friend class _TAO_ComponentRepository_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentRepository_Direct_Proxy_Impl; +- +- virtual ~ComponentRepository (void); +- private: +- ComponentRepository (const ComponentRepository &); +- void operator= (const ComponentRepository &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_ComponentRepository_create_component : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ComponentRepository; +- +- friend class _TAO_ComponentRepository_Remote_Proxy_Impl; +- friend class _TAO_ComponentRepository_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentRepository_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ComponentRepository_create_component ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::ComponentDef_ptr base_component, +- const IR::InterfaceDefSeq & supports_interfaces, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_ComponentRepository_create_component (const TAO_ClientRequestInfo_IR_ComponentRepository_create_component &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentRepository_create_component &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::ComponentDef_ptr base_component_; +- const IR::InterfaceDefSeq & supports_interfaces_; +- void result (IR::ComponentDef_ptr result); +- // update the result +- IR::ComponentDef_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_ComponentRepository_create_home : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ComponentRepository; +- +- friend class _TAO_ComponentRepository_Remote_Proxy_Impl; +- friend class _TAO_ComponentRepository_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentRepository_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ComponentRepository_create_home ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::HomeDef_ptr base_home, +- IR::ComponentDef_ptr managed_component, +- IR::ValueDef_ptr primary_key, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); ++ ++ friend class _TAO_ComponentRepository_Remote_Proxy_Impl; ++ friend class _TAO_ComponentRepository_ThruPOA_Proxy_Impl; ++ friend class _TAO_ComponentRepository_Direct_Proxy_Impl; + +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_ComponentRepository (void); + private: +- TAO_ClientRequestInfo_IR_ComponentRepository_create_home (const TAO_ClientRequestInfo_IR_ComponentRepository_create_home &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentRepository_create_home &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::HomeDef_ptr base_home_; +- IR::ComponentDef_ptr managed_component_; +- IR::ValueDef_ptr primary_key_; +- void result (IR::HomeDef_ptr result); +- // update the result +- IR::HomeDef_ptr result_; +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_ComponentRepository (const IR_ComponentRepository &); ++ void operator= (const IR_ComponentRepository &); + }; + + +@@ -9676,32 +6116,32 @@ + // + + class TAO_Export _TAO_ComponentRepository_Proxy_Impl : +- public virtual IR::_TAO_Repository_Proxy_Impl ++ public virtual _TAO_Repository_Proxy_Impl + { + public: + virtual ~_TAO_ComponentRepository_Proxy_Impl (void) { } + +- virtual IR::ComponentDef_ptr create_component ( ++ virtual IR_ComponentDef_ptr create_component ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::ComponentDef_ptr base_component, +- const IR::InterfaceDefSeq & supports_interfaces, ++ IR_ComponentDef_ptr base_component, ++ const IR_InterfaceDefSeq & supports_interfaces, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::HomeDef_ptr create_home ( ++ virtual IR_HomeDef_ptr create_home ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::HomeDef_ptr base_home, +- IR::ComponentDef_ptr managed_component, +- IR::ValueDef_ptr primary_key, ++ IR_HomeDef_ptr base_home, ++ IR_ComponentDef_ptr managed_component, ++ IR_ValueDef_ptr primary_key, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -9712,6 +6152,7 @@ + _TAO_ComponentRepository_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -9724,7 +6165,7 @@ + class TAO_Export _TAO_ComponentRepository_Remote_Proxy_Impl : + public virtual _TAO_ComponentRepository_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Repository_Remote_Proxy_Impl ++ public virtual _TAO_Repository_Remote_Proxy_Impl + + { + public: +@@ -9732,27 +6173,27 @@ + + virtual ~_TAO_ComponentRepository_Remote_Proxy_Impl (void) { } + +- virtual IR::ComponentDef_ptr create_component ( ++ virtual IR_ComponentDef_ptr create_component ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::ComponentDef_ptr base_component, +- const IR::InterfaceDefSeq & supports_interfaces, ++ IR_ComponentDef_ptr base_component, ++ const IR_InterfaceDefSeq & supports_interfaces, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::HomeDef_ptr create_home ( ++ virtual IR_HomeDef_ptr create_home ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::HomeDef_ptr base_home, +- IR::ComponentDef_ptr managed_component, +- IR::ValueDef_ptr primary_key, ++ IR_HomeDef_ptr base_home, ++ IR_ComponentDef_ptr managed_component, ++ IR_ValueDef_ptr primary_key, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -9781,8 +6222,9 @@ + { + public: + virtual ~_TAO_ComponentRepository_Proxy_Broker (void); ++ + virtual _TAO_ComponentRepository_Proxy_Impl &select_proxy ( +- ComponentRepository *object, ++ IR_ComponentRepository *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -9807,9 +6249,9 @@ + _TAO_ComponentRepository_Remote_Proxy_Broker (void); + + virtual ~_TAO_ComponentRepository_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_ComponentRepository_Proxy_Impl &select_proxy ( +- ComponentRepository *object, ++ IR_ComponentRepository *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -9823,117 +6265,39 @@ + static _TAO_ComponentRepository_Remote_Proxy_Broker *the_TAO_ComponentRepository_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + ++// Forward Classes Declaration ++class _TAO_ModuleDef_Proxy_Impl; ++class _TAO_ModuleDef_Remote_Proxy_Impl; ++class _TAO_ModuleDef_Proxy_Broker; ++class _TAO_ModuleDef_Remote_Proxy_Broker; + +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentRepository; +- +- +-#if !defined (_TAO_IR_MODULEDEF___PTR_CH_) +-#define _TAO_IR_MODULEDEF___PTR_CH_ +- +-class ModuleDef; +-typedef ModuleDef *ModuleDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_MODULEDEF___VAR_CH_) +-#define _TAO_IR_MODULEDEF___VAR_CH_ +- +-class TAO_Export ModuleDef_var : public TAO_Base_var +-{ +-public: +- ModuleDef_var (void); // default constructor +- ModuleDef_var (ModuleDef_ptr p) : ptr_ (p) {} +- ModuleDef_var (const ModuleDef_var &); // copy constructor +- ~ModuleDef_var (void); // destructor +- +- ModuleDef_var &operator= (ModuleDef_ptr); +- ModuleDef_var &operator= (const ModuleDef_var &); +- ModuleDef_ptr operator-> (void) const; +- +- operator const ModuleDef_ptr &() const; +- operator ModuleDef_ptr &(); +- // in, inout, out, _retn +- ModuleDef_ptr in (void) const; +- ModuleDef_ptr &inout (void); +- ModuleDef_ptr &out (void); +- ModuleDef_ptr _retn (void); +- ModuleDef_ptr ptr (void) const; +- +-private: +- ModuleDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- ModuleDef_var (const TAO_Base_var &rhs); +- ModuleDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_MODULEDEF___OUT_CH_) +-#define _TAO_IR_MODULEDEF___OUT_CH_ +- +-class TAO_Export ModuleDef_out +-{ +-public: +- ModuleDef_out (ModuleDef_ptr &); +- ModuleDef_out (ModuleDef_var &); +- ModuleDef_out (const ModuleDef_out &); +- ModuleDef_out &operator= (const ModuleDef_out &); +- ModuleDef_out &operator= (const ModuleDef_var &); +- ModuleDef_out &operator= (ModuleDef_ptr); +- operator ModuleDef_ptr &(); +- ModuleDef_ptr &ptr (void); +- ModuleDef_ptr operator-> (void); +- +-private: +- ModuleDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_MODULEDEF_CH_) +-#define _TAO_IR_MODULEDEF_CH_ +- +-// Forward Classes Declaration +-class _TAO_ModuleDef_Proxy_Impl; +-class _TAO_ModuleDef_Remote_Proxy_Impl; +-class _TAO_ModuleDef_Proxy_Broker; +-class _TAO_ModuleDef_Remote_Proxy_Broker; +- +-class TAO_Export ModuleDef: public virtual Container, public virtual Contained +-{ +-public: +-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ModuleDef_ptr _ptr_type; +- typedef ModuleDef_var _var_type; +-#endif /* ! __GNUC__ || g++ >= 2.8 */ ++class TAO_Export IR_ModuleDef: public virtual IR_Container, public virtual IR_Contained ++{ ++public: ++#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) ++ typedef IR_ModuleDef_ptr _ptr_type; ++ typedef IR_ModuleDef_var _var_type; ++#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static ModuleDef_ptr _duplicate (ModuleDef_ptr obj); +- static ModuleDef_ptr _narrow ( ++ static IR_ModuleDef_ptr _duplicate (IR_ModuleDef_ptr obj); ++ static IR_ModuleDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ModuleDef_ptr _unchecked_narrow ( ++ static IR_ModuleDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ModuleDef_ptr _nil (void) ++ static IR_ModuleDef_ptr _nil (void) + { +- return (ModuleDef_ptr)0; ++ return (IR_ModuleDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -9951,58 +6315,51 @@ + _TAO_ModuleDef_Proxy_Broker *the_TAO_ModuleDef_Proxy_Broker_; + + protected: +- ModuleDef (int collocated = 0); ++ IR_ModuleDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- ModuleDef ( ++ IR_ModuleDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); ++ ); + +- friend class _TAO_ModuleDef_Remote_Proxy_Impl; +- friend class _TAO_ModuleDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ModuleDef_Direct_Proxy_Impl; ++ friend class _TAO_ModuleDef_Remote_Proxy_Impl; ++ friend class _TAO_ModuleDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_ModuleDef_Direct_Proxy_Impl; + +- virtual ~ModuleDef (void); +- private: +- ModuleDef (const ModuleDef &); +- void operator= (const ModuleDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- #endif /* TAO_HAS_INTERCEPTORS */ +- +- }; ++ virtual ~IR_ModuleDef (void); ++private: ++ IR_ModuleDef (const IR_ModuleDef &); ++ void operator= (const IR_ModuleDef &); ++}; + + + // The Proxy Implementations are used by each interface to + // perform a call. Each different implementation encapsulate + // an invocation logics. + +- ++ + /////////////////////////////////////////////////////////////////////// + // Base Impl. Declaration + // + + class TAO_Export _TAO_ModuleDef_Proxy_Impl : +- public virtual IR::_TAO_Container_Proxy_Impl, +- public virtual IR::_TAO_Contained_Proxy_Impl ++ public virtual _TAO_Container_Proxy_Impl, ++ public virtual _TAO_Contained_Proxy_Impl + { + public: + virtual ~_TAO_ModuleDef_Proxy_Impl (void) { } + +- protected: ++ protected: + _TAO_ModuleDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -10015,8 +6372,8 @@ + class TAO_Export _TAO_ModuleDef_Remote_Proxy_Impl : + public virtual _TAO_ModuleDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Container_Remote_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl ++ public virtual _TAO_Container_Remote_Proxy_Impl, ++ public virtual _TAO_Contained_Remote_Proxy_Impl + + { + public: +@@ -10024,7 +6381,7 @@ + + virtual ~_TAO_ModuleDef_Remote_Proxy_Impl (void) { } + +- }; ++}; + + // + // Base Proxy Impl. Declaration +@@ -10046,8 +6403,9 @@ + { + public: + virtual ~_TAO_ModuleDef_Proxy_Broker (void); ++ + virtual _TAO_ModuleDef_Proxy_Impl &select_proxy ( +- ModuleDef *object, ++ IR_ModuleDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -10072,9 +6430,9 @@ + _TAO_ModuleDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_ModuleDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_ModuleDef_Proxy_Impl &select_proxy ( +- ModuleDef *object, ++ IR_ModuleDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -10088,24 +6446,15 @@ + static _TAO_ModuleDef_Remote_Proxy_Broker *the_TAO_ModuleDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ModuleDef; +- +-struct ModuleDescription; +-class ModuleDescription_var; +- +-struct TAO_Export ModuleDescription ++struct TAO_Export IR_ModuleDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ModuleDescription_var _var_type; ++ typedef IR_ModuleDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -10116,170 +6465,96 @@ + TAO_String_Manager version; + }; + +-class TAO_Export ModuleDescription_var +-{ +-public: +- ModuleDescription_var (void); // default constructor +- ModuleDescription_var (ModuleDescription *); +- ModuleDescription_var (const ModuleDescription_var &); // copy constructor +- ~ModuleDescription_var (void); // destructor +- +- ModuleDescription_var &operator= (ModuleDescription *); +- ModuleDescription_var &operator= (const ModuleDescription_var &); +- ModuleDescription *operator-> (void); +- const ModuleDescription *operator-> (void) const; +- +- operator const ModuleDescription &() const; +- operator ModuleDescription &(); +- operator ModuleDescription &() const; +- operator ModuleDescription *&(); // variable-size types only +- +- // in, inout, out, _retn +- const ModuleDescription &in (void) const; +- ModuleDescription &inout (void); +- ModuleDescription *&out (void); +- ModuleDescription *_retn (void); +- ModuleDescription *ptr (void) const; +- +-private: +- ModuleDescription *ptr_; +-}; +- +-class TAO_Export ModuleDescription_out ++class TAO_Export IR_ModuleDescription_var + { + public: +- ModuleDescription_out (ModuleDescription *&); +- ModuleDescription_out (ModuleDescription_var &); +- ModuleDescription_out (const ModuleDescription_out &); +- ModuleDescription_out &operator= (const ModuleDescription_out &); +- ModuleDescription_out &operator= (ModuleDescription *); +- operator ModuleDescription *&(); +- ModuleDescription *&ptr (void); +- ModuleDescription *operator-> (void); ++ IR_ModuleDescription_var (void); // default constructor ++ IR_ModuleDescription_var (IR_ModuleDescription *); ++ IR_ModuleDescription_var (const IR_ModuleDescription_var &); // copy constructor ++ ~IR_ModuleDescription_var (void); // destructor + +-private: +- ModuleDescription *&ptr_; +- // assignment from T_var not allowed +- void operator= (const ModuleDescription_var &); +-}; +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ModuleDescription; +- +- +-#if !defined (_TAO_IR_CONSTANTDEF___PTR_CH_) +-#define _TAO_IR_CONSTANTDEF___PTR_CH_ +- +-class ConstantDef; +-typedef ConstantDef *ConstantDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONSTANTDEF___VAR_CH_) +-#define _TAO_IR_CONSTANTDEF___VAR_CH_ +- +-class TAO_Export ConstantDef_var : public TAO_Base_var +-{ +-public: +- ConstantDef_var (void); // default constructor +- ConstantDef_var (ConstantDef_ptr p) : ptr_ (p) {} +- ConstantDef_var (const ConstantDef_var &); // copy constructor +- ~ConstantDef_var (void); // destructor ++ IR_ModuleDescription_var &operator= (IR_ModuleDescription *); ++ IR_ModuleDescription_var &operator= (const IR_ModuleDescription_var &); ++ IR_ModuleDescription *operator-> (void); ++ const IR_ModuleDescription *operator-> (void) const; + +- ConstantDef_var &operator= (ConstantDef_ptr); +- ConstantDef_var &operator= (const ConstantDef_var &); +- ConstantDef_ptr operator-> (void) const; ++ operator const IR_ModuleDescription &() const; ++ operator IR_ModuleDescription &(); ++ operator IR_ModuleDescription &() const; ++ operator IR_ModuleDescription *&(); // variable-size types only + +- operator const ConstantDef_ptr &() const; +- operator ConstantDef_ptr &(); + // in, inout, out, _retn +- ConstantDef_ptr in (void) const; +- ConstantDef_ptr &inout (void); +- ConstantDef_ptr &out (void); +- ConstantDef_ptr _retn (void); +- ConstantDef_ptr ptr (void) const; ++ const IR_ModuleDescription &in (void) const; ++ IR_ModuleDescription &inout (void); ++ IR_ModuleDescription *&out (void); ++ IR_ModuleDescription *_retn (void); ++ IR_ModuleDescription *ptr (void) const; + + private: +- ConstantDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- ConstantDef_var (const TAO_Base_var &rhs); +- ConstantDef_var &operator= (const TAO_Base_var &rhs); ++ IR_ModuleDescription *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONSTANTDEF___OUT_CH_) +-#define _TAO_IR_CONSTANTDEF___OUT_CH_ +- +-class TAO_Export ConstantDef_out ++class TAO_Export IR_ModuleDescription_out + { + public: +- ConstantDef_out (ConstantDef_ptr &); +- ConstantDef_out (ConstantDef_var &); +- ConstantDef_out (const ConstantDef_out &); +- ConstantDef_out &operator= (const ConstantDef_out &); +- ConstantDef_out &operator= (const ConstantDef_var &); +- ConstantDef_out &operator= (ConstantDef_ptr); +- operator ConstantDef_ptr &(); +- ConstantDef_ptr &ptr (void); +- ConstantDef_ptr operator-> (void); ++ IR_ModuleDescription_out (IR_ModuleDescription *&); ++ IR_ModuleDescription_out (IR_ModuleDescription_var &); ++ IR_ModuleDescription_out (const IR_ModuleDescription_out &); ++ IR_ModuleDescription_out &operator= (const IR_ModuleDescription_out &); ++ IR_ModuleDescription_out &operator= (IR_ModuleDescription *); ++ operator IR_ModuleDescription *&(); ++ IR_ModuleDescription *&ptr (void); ++ IR_ModuleDescription *operator-> (void); + + private: +- ConstantDef_ptr &ptr_; ++ IR_ModuleDescription *&ptr_; ++ // assignment from T_var not allowed ++ void operator= (const IR_ModuleDescription_var &); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONSTANTDEF_CH_) +-#define _TAO_IR_CONSTANTDEF_CH_ +- + // Forward Classes Declaration + class _TAO_ConstantDef_Proxy_Impl; + class _TAO_ConstantDef_Remote_Proxy_Impl; + class _TAO_ConstantDef_Proxy_Broker; + class _TAO_ConstantDef_Remote_Proxy_Broker; + +-class TAO_Export ConstantDef: public virtual Contained ++class TAO_Export IR_ConstantDef: public virtual IR_Contained + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ConstantDef_ptr _ptr_type; +- typedef ConstantDef_var _var_type; ++ typedef IR_ConstantDef_ptr _ptr_type; ++ typedef IR_ConstantDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static ConstantDef_ptr _duplicate (ConstantDef_ptr obj); +- static ConstantDef_ptr _narrow ( ++ static IR_ConstantDef_ptr _duplicate (IR_ConstantDef_ptr obj); ++ static IR_ConstantDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ConstantDef_ptr _unchecked_narrow ( ++ static IR_ConstantDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ConstantDef_ptr _nil (void) ++ static IR_ConstantDef_ptr _nil (void) + { +- return (ConstantDef_ptr)0; ++ return (IR_ConstantDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual CORBA::TypeCode_ptr type ( +- CORBA::Environment &ACE_TRY_ENV = ++ virtual CORBA::TypeCode_ptr type ( ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr type_def ( +- CORBA::Environment &ACE_TRY_ENV = ++ virtual IR_IDLType_ptr type_def ( ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -10287,7 +6562,7 @@ + )); + + virtual void type_def ( +- IR::IDLType_ptr type_def, ++ IR_IDLType_ptr type_def, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -10325,250 +6600,27 @@ + _TAO_ConstantDef_Proxy_Broker *the_TAO_ConstantDef_Proxy_Broker_; + + protected: +- ConstantDef (int collocated = 0); ++ IR_ConstantDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- ConstantDef ( ++ IR_ConstantDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_ConstantDef_Remote_Proxy_Impl; +- friend class _TAO_ConstantDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ConstantDef_Direct_Proxy_Impl; +- +- virtual ~ConstantDef (void); +- private: +- ConstantDef (const ConstantDef &); +- void operator= (const ConstantDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_ConstantDef_type_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ConstantDef; +- +- friend class _TAO_ConstantDef_Remote_Proxy_Impl; +- friend class _TAO_ConstantDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ConstantDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ConstantDef_type_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_ConstantDef_type_get (const TAO_ClientRequestInfo_IR_ConstantDef_type_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ConstantDef_type_get &); +- void result (CORBA::TypeCode_ptr result); +- // update the result +- CORBA::TypeCode_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_ConstantDef_type_def_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ConstantDef; +- +- friend class _TAO_ConstantDef_Remote_Proxy_Impl; +- friend class _TAO_ConstantDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ConstantDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ConstantDef_type_def_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ConstantDef_type_def_get (const TAO_ClientRequestInfo_IR_ConstantDef_type_def_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ConstantDef_type_def_get &); +- void result (IR::IDLType_ptr result); +- // update the result +- IR::IDLType_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ConstantDef_type_def_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ConstantDef; +- +- friend class _TAO_ConstantDef_Remote_Proxy_Impl; +- friend class _TAO_ConstantDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ConstantDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ConstantDef_type_def_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::IDLType_ptr type_def, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ConstantDef_type_def_set (const TAO_ClientRequestInfo_IR_ConstantDef_type_def_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ConstantDef_type_def_set &); +- IR::IDLType_ptr type_def_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_ConstantDef_value_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ConstantDef; +- ++ + friend class _TAO_ConstantDef_Remote_Proxy_Impl; + friend class _TAO_ConstantDef_ThruPOA_Proxy_Impl; + friend class _TAO_ConstantDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ConstantDef_value_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ConstantDef_value_get (const TAO_ClientRequestInfo_IR_ConstantDef_value_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ConstantDef_value_get &); +- void result (CORBA::Any * result); +- // update the result +- CORBA::Any * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ConstantDef_value_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ConstantDef; + +- friend class _TAO_ConstantDef_Remote_Proxy_Impl; +- friend class _TAO_ConstantDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ConstantDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ConstantDef_value_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::Any & value, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_ConstantDef (void); + private: +- TAO_ClientRequestInfo_IR_ConstantDef_value_set (const TAO_ClientRequestInfo_IR_ConstantDef_value_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ConstantDef_value_set &); +- const CORBA::Any & value_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_ConstantDef (const IR_ConstantDef &); ++ void operator= (const IR_ConstantDef &); + }; + + +@@ -10582,12 +6634,12 @@ + // + + class TAO_Export _TAO_ConstantDef_Proxy_Impl : +- public virtual IR::_TAO_Contained_Proxy_Impl ++ public virtual _TAO_Contained_Proxy_Impl + { + public: + virtual ~_TAO_ConstantDef_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr type ( ++ virtual CORBA::TypeCode_ptr type ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -10595,7 +6647,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::IDLType_ptr type_def ( ++ virtual IR_IDLType_ptr type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -10605,7 +6657,7 @@ + + virtual void type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr type_def, ++ IR_IDLType_ptr type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -10633,6 +6685,7 @@ + _TAO_ConstantDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -10645,7 +6698,7 @@ + class TAO_Export _TAO_ConstantDef_Remote_Proxy_Impl : + public virtual _TAO_ConstantDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl ++ public virtual _TAO_Contained_Remote_Proxy_Impl + + { + public: +@@ -10653,15 +6706,15 @@ + + virtual ~_TAO_ConstantDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr type ( ++ virtual CORBA::TypeCode_ptr type ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr type_def ( ++ virtual IR_IDLType_ptr type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -10671,22 +6724,22 @@ + + virtual void type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr type_def, ++ IR_IDLType_ptr type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual CORBA::Any * value ( ++ virtual CORBA::Any * value ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual void value ( ++ virtual void value ( + CORBA_Object *_collocated_tao_target_, + const CORBA::Any & value, + CORBA::Environment &ACE_TRY_ENV +@@ -10717,8 +6770,9 @@ + { + public: + virtual ~_TAO_ConstantDef_Proxy_Broker (void); ++ + virtual _TAO_ConstantDef_Proxy_Impl &select_proxy ( +- ConstantDef *object, ++ IR_ConstantDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -10743,9 +6797,9 @@ + _TAO_ConstantDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_ConstantDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_ConstantDef_Proxy_Impl &select_proxy ( +- ConstantDef *object, ++ IR_ConstantDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -10759,24 +6813,15 @@ + static _TAO_ConstantDef_Remote_Proxy_Broker *the_TAO_ConstantDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConstantDef; +- +-struct ConstantDescription; +-class ConstantDescription_var; +- +-struct TAO_Export ConstantDescription ++struct TAO_Export IR_ConstantDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ConstantDescription_var _var_type; ++ typedef IR_ConstantDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -10789,156 +6834,127 @@ + CORBA::Any value; + }; + +-class TAO_Export ConstantDescription_var ++class TAO_Export IR_ConstantDescription_var + { + public: +- ConstantDescription_var (void); // default constructor +- ConstantDescription_var (ConstantDescription *); +- ConstantDescription_var (const ConstantDescription_var &); // copy constructor +- ~ConstantDescription_var (void); // destructor +- +- ConstantDescription_var &operator= (ConstantDescription *); +- ConstantDescription_var &operator= (const ConstantDescription_var &); +- ConstantDescription *operator-> (void); +- const ConstantDescription *operator-> (void) const; +- +- operator const ConstantDescription &() const; +- operator ConstantDescription &(); +- operator ConstantDescription &() const; +- operator ConstantDescription *&(); // variable-size types only ++ IR_ConstantDescription_var (void); // default constructor ++ IR_ConstantDescription_var (IR_ConstantDescription *); ++ IR_ConstantDescription_var (const IR_ConstantDescription_var &); // copy constructor ++ ~IR_ConstantDescription_var (void); // destructor ++ ++ IR_ConstantDescription_var &operator= (IR_ConstantDescription *); ++ IR_ConstantDescription_var &operator= (const IR_ConstantDescription_var &); ++ IR_ConstantDescription *operator-> (void); ++ const IR_ConstantDescription *operator-> (void) const; ++ ++ operator const IR_ConstantDescription &() const; ++ operator IR_ConstantDescription &(); ++ operator IR_ConstantDescription &() const; ++ operator IR_ConstantDescription *&(); // variable-size types only + + // in, inout, out, _retn +- const ConstantDescription &in (void) const; +- ConstantDescription &inout (void); +- ConstantDescription *&out (void); +- ConstantDescription *_retn (void); +- ConstantDescription *ptr (void) const; ++ const IR_ConstantDescription &in (void) const; ++ IR_ConstantDescription &inout (void); ++ IR_ConstantDescription *&out (void); ++ IR_ConstantDescription *_retn (void); ++ IR_ConstantDescription *ptr (void) const; + + private: +- ConstantDescription *ptr_; ++ IR_ConstantDescription *ptr_; + }; + +-class TAO_Export ConstantDescription_out ++class TAO_Export IR_ConstantDescription_out + { + public: +- ConstantDescription_out (ConstantDescription *&); +- ConstantDescription_out (ConstantDescription_var &); +- ConstantDescription_out (const ConstantDescription_out &); +- ConstantDescription_out &operator= (const ConstantDescription_out &); +- ConstantDescription_out &operator= (ConstantDescription *); +- operator ConstantDescription *&(); +- ConstantDescription *&ptr (void); +- ConstantDescription *operator-> (void); ++ IR_ConstantDescription_out (IR_ConstantDescription *&); ++ IR_ConstantDescription_out (IR_ConstantDescription_var &); ++ IR_ConstantDescription_out (const IR_ConstantDescription_out &); ++ IR_ConstantDescription_out &operator= (const IR_ConstantDescription_out &); ++ IR_ConstantDescription_out &operator= (IR_ConstantDescription *); ++ operator IR_ConstantDescription *&(); ++ IR_ConstantDescription *&ptr (void); ++ IR_ConstantDescription *operator-> (void); + + private: +- ConstantDescription *&ptr_; ++ IR_ConstantDescription *&ptr_; + // assignment from T_var not allowed +- void operator= (const ConstantDescription_var &); ++ void operator= (const IR_ConstantDescription_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConstantDescription; +- +- +-#if !defined (_TAO_IR_TYPEDEFDEF___PTR_CH_) +-#define _TAO_IR_TYPEDEFDEF___PTR_CH_ +- +-class TypedefDef; +-typedef TypedefDef *TypedefDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_TYPEDEFDEF___VAR_CH_) +-#define _TAO_IR_TYPEDEFDEF___VAR_CH_ +- +-class TAO_Export TypedefDef_var : public TAO_Base_var ++class TAO_Export IR_TypedefDef_var : public TAO_Base_var + { + public: +- TypedefDef_var (void); // default constructor +- TypedefDef_var (TypedefDef_ptr p) : ptr_ (p) {} +- TypedefDef_var (const TypedefDef_var &); // copy constructor +- ~TypedefDef_var (void); // destructor ++ IR_TypedefDef_var (void); // default constructor ++ IR_TypedefDef_var (IR_TypedefDef_ptr p) : ptr_ (p) {} ++ IR_TypedefDef_var (const IR_TypedefDef_var &); // copy constructor ++ ~IR_TypedefDef_var (void); // destructor + +- TypedefDef_var &operator= (TypedefDef_ptr); +- TypedefDef_var &operator= (const TypedefDef_var &); +- TypedefDef_ptr operator-> (void) const; ++ IR_TypedefDef_var &operator= (IR_TypedefDef_ptr); ++ IR_TypedefDef_var &operator= (const IR_TypedefDef_var &); ++ IR_TypedefDef_ptr operator-> (void) const; + +- operator const TypedefDef_ptr &() const; +- operator TypedefDef_ptr &(); ++ operator const IR_TypedefDef_ptr &() const; ++ operator IR_TypedefDef_ptr &(); + // in, inout, out, _retn +- TypedefDef_ptr in (void) const; +- TypedefDef_ptr &inout (void); +- TypedefDef_ptr &out (void); +- TypedefDef_ptr _retn (void); +- TypedefDef_ptr ptr (void) const; ++ IR_TypedefDef_ptr in (void) const; ++ IR_TypedefDef_ptr &inout (void); ++ IR_TypedefDef_ptr &out (void); ++ IR_TypedefDef_ptr _retn (void); ++ IR_TypedefDef_ptr ptr (void) const; + + private: +- TypedefDef_ptr ptr_; ++ IR_TypedefDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- TypedefDef_var (const TAO_Base_var &rhs); +- TypedefDef_var &operator= (const TAO_Base_var &rhs); ++ IR_TypedefDef_var (const TAO_Base_var &rhs); ++ IR_TypedefDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_TYPEDEFDEF___OUT_CH_) +-#define _TAO_IR_TYPEDEFDEF___OUT_CH_ +- +-class TAO_Export TypedefDef_out ++class TAO_Export IR_TypedefDef_out + { + public: +- TypedefDef_out (TypedefDef_ptr &); +- TypedefDef_out (TypedefDef_var &); +- TypedefDef_out (const TypedefDef_out &); +- TypedefDef_out &operator= (const TypedefDef_out &); +- TypedefDef_out &operator= (const TypedefDef_var &); +- TypedefDef_out &operator= (TypedefDef_ptr); +- operator TypedefDef_ptr &(); +- TypedefDef_ptr &ptr (void); +- TypedefDef_ptr operator-> (void); ++ IR_TypedefDef_out (IR_TypedefDef_ptr &); ++ IR_TypedefDef_out (IR_TypedefDef_var &); ++ IR_TypedefDef_out (const IR_TypedefDef_out &); ++ IR_TypedefDef_out &operator= (const IR_TypedefDef_out &); ++ IR_TypedefDef_out &operator= (const IR_TypedefDef_var &); ++ IR_TypedefDef_out &operator= (IR_TypedefDef_ptr); ++ operator IR_TypedefDef_ptr &(); ++ IR_TypedefDef_ptr &ptr (void); ++ IR_TypedefDef_ptr operator-> (void); + + private: +- TypedefDef_ptr &ptr_; ++ IR_TypedefDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_TYPEDEFDEF_CH_) +-#define _TAO_IR_TYPEDEFDEF_CH_ +- + // Forward Classes Declaration + class _TAO_TypedefDef_Proxy_Impl; + class _TAO_TypedefDef_Remote_Proxy_Impl; + class _TAO_TypedefDef_Proxy_Broker; + class _TAO_TypedefDef_Remote_Proxy_Broker; + +-class TAO_Export TypedefDef: public virtual Contained, public virtual IDLType ++class TAO_Export IR_TypedefDef: public virtual IR_Contained, public virtual IR_IDLType + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef TypedefDef_ptr _ptr_type; +- typedef TypedefDef_var _var_type; ++ typedef IR_TypedefDef_ptr _ptr_type; ++ typedef IR_TypedefDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static TypedefDef_ptr _duplicate (TypedefDef_ptr obj); +- static TypedefDef_ptr _narrow ( ++ static IR_TypedefDef_ptr _duplicate (IR_TypedefDef_ptr obj); ++ static IR_TypedefDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static TypedefDef_ptr _unchecked_narrow ( ++ static IR_TypedefDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static TypedefDef_ptr _nil (void) ++ static IR_TypedefDef_ptr _nil (void) + { +- return (TypedefDef_ptr)0; ++ return (IR_TypedefDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -10956,61 +6972,54 @@ + _TAO_TypedefDef_Proxy_Broker *the_TAO_TypedefDef_Proxy_Broker_; + + protected: +- TypedefDef (int collocated = 0); ++ IR_TypedefDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- TypedefDef ( ++ IR_TypedefDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); ++ ); + +- friend class _TAO_TypedefDef_Remote_Proxy_Impl; +- friend class _TAO_TypedefDef_ThruPOA_Proxy_Impl; +- friend class _TAO_TypedefDef_Direct_Proxy_Impl; ++ friend class _TAO_TypedefDef_Remote_Proxy_Impl; ++ friend class _TAO_TypedefDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_TypedefDef_Direct_Proxy_Impl; + +- virtual ~TypedefDef (void); +- private: +- TypedefDef (const TypedefDef &); +- void operator= (const TypedefDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- #endif /* TAO_HAS_INTERCEPTORS */ +- +- }; ++ virtual ~IR_TypedefDef (void); ++private: ++ IR_TypedefDef (const IR_TypedefDef &); ++ void operator= (const IR_TypedefDef &); ++}; + + + // The Proxy Implementations are used by each interface to + // perform a call. Each different implementation encapsulate + // an invocation logics. + +- ++ + /////////////////////////////////////////////////////////////////////// + // Base Impl. Declaration + // + + class TAO_Export _TAO_TypedefDef_Proxy_Impl : +- public virtual IR::_TAO_Contained_Proxy_Impl, +- public virtual IR::_TAO_IDLType_Proxy_Impl ++ public virtual _TAO_Contained_Proxy_Impl, ++ public virtual _TAO_IDLType_Proxy_Impl + { + public: + virtual ~_TAO_TypedefDef_Proxy_Impl (void) { } + +- protected: ++ protected: + _TAO_TypedefDef_Proxy_Impl (void); + + }; +- // +- // Base Proxy Impl. Declaration +- /////////////////////////////////////////////////////////////////////// ++ ++// ++// Base Proxy Impl. Declaration ++/////////////////////////////////////////////////////////////////////// + + + /////////////////////////////////////////////////////////////////////// +@@ -11020,8 +7029,8 @@ + class TAO_Export _TAO_TypedefDef_Remote_Proxy_Impl : + public virtual _TAO_TypedefDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl, +- public virtual IR::_TAO_IDLType_Remote_Proxy_Impl ++ public virtual _TAO_Contained_Remote_Proxy_Impl, ++ public virtual _TAO_IDLType_Remote_Proxy_Impl + + { + public: +@@ -11029,7 +7038,7 @@ + + virtual ~_TAO_TypedefDef_Remote_Proxy_Impl (void) { } + +- }; ++}; + + // + // Base Proxy Impl. Declaration +@@ -11051,8 +7060,9 @@ + { + public: + virtual ~_TAO_TypedefDef_Proxy_Broker (void); ++ + virtual _TAO_TypedefDef_Proxy_Impl &select_proxy ( +- TypedefDef *object, ++ IR_TypedefDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -11077,9 +7087,9 @@ + _TAO_TypedefDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_TypedefDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_TypedefDef_Proxy_Impl &select_proxy ( +- TypedefDef *object, ++ IR_TypedefDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -11093,24 +7103,15 @@ + static _TAO_TypedefDef_Remote_Proxy_Broker *the_TAO_TypedefDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypedefDef; +- +-struct TypeDescription; +-class TypeDescription_var; +- +-struct TAO_Export TypeDescription ++struct TAO_Export IR_TypeDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef TypeDescription_var _var_type; ++ typedef IR_TypeDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -11122,170 +7123,96 @@ + CORBA::TypeCode_var type; + }; + +-class TAO_Export TypeDescription_var +-{ +-public: +- TypeDescription_var (void); // default constructor +- TypeDescription_var (TypeDescription *); +- TypeDescription_var (const TypeDescription_var &); // copy constructor +- ~TypeDescription_var (void); // destructor +- +- TypeDescription_var &operator= (TypeDescription *); +- TypeDescription_var &operator= (const TypeDescription_var &); +- TypeDescription *operator-> (void); +- const TypeDescription *operator-> (void) const; +- +- operator const TypeDescription &() const; +- operator TypeDescription &(); +- operator TypeDescription &() const; +- operator TypeDescription *&(); // variable-size types only +- +- // in, inout, out, _retn +- const TypeDescription &in (void) const; +- TypeDescription &inout (void); +- TypeDescription *&out (void); +- TypeDescription *_retn (void); +- TypeDescription *ptr (void) const; +- +-private: +- TypeDescription *ptr_; +-}; +- +-class TAO_Export TypeDescription_out ++class TAO_Export IR_TypeDescription_var + { + public: +- TypeDescription_out (TypeDescription *&); +- TypeDescription_out (TypeDescription_var &); +- TypeDescription_out (const TypeDescription_out &); +- TypeDescription_out &operator= (const TypeDescription_out &); +- TypeDescription_out &operator= (TypeDescription *); +- operator TypeDescription *&(); +- TypeDescription *&ptr (void); +- TypeDescription *operator-> (void); ++ IR_TypeDescription_var (void); // default constructor ++ IR_TypeDescription_var (IR_TypeDescription *); ++ IR_TypeDescription_var (const IR_TypeDescription_var &); // copy constructor ++ ~IR_TypeDescription_var (void); // destructor + +-private: +- TypeDescription *&ptr_; +- // assignment from T_var not allowed +- void operator= (const TypeDescription_var &); +-}; +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypeDescription; +- +- +-#if !defined (_TAO_IR_STRUCTDEF___PTR_CH_) +-#define _TAO_IR_STRUCTDEF___PTR_CH_ +- +-class StructDef; +-typedef StructDef *StructDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_STRUCTDEF___VAR_CH_) +-#define _TAO_IR_STRUCTDEF___VAR_CH_ +- +-class TAO_Export StructDef_var : public TAO_Base_var +-{ +-public: +- StructDef_var (void); // default constructor +- StructDef_var (StructDef_ptr p) : ptr_ (p) {} +- StructDef_var (const StructDef_var &); // copy constructor +- ~StructDef_var (void); // destructor ++ IR_TypeDescription_var &operator= (IR_TypeDescription *); ++ IR_TypeDescription_var &operator= (const IR_TypeDescription_var &); ++ IR_TypeDescription *operator-> (void); ++ const IR_TypeDescription *operator-> (void) const; + +- StructDef_var &operator= (StructDef_ptr); +- StructDef_var &operator= (const StructDef_var &); +- StructDef_ptr operator-> (void) const; ++ operator const IR_TypeDescription &() const; ++ operator IR_TypeDescription &(); ++ operator IR_TypeDescription &() const; ++ operator IR_TypeDescription *&(); // variable-size types only + +- operator const StructDef_ptr &() const; +- operator StructDef_ptr &(); + // in, inout, out, _retn +- StructDef_ptr in (void) const; +- StructDef_ptr &inout (void); +- StructDef_ptr &out (void); +- StructDef_ptr _retn (void); +- StructDef_ptr ptr (void) const; ++ const IR_TypeDescription &in (void) const; ++ IR_TypeDescription &inout (void); ++ IR_TypeDescription *&out (void); ++ IR_TypeDescription *_retn (void); ++ IR_TypeDescription *ptr (void) const; + + private: +- StructDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- StructDef_var (const TAO_Base_var &rhs); +- StructDef_var &operator= (const TAO_Base_var &rhs); ++ IR_TypeDescription *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_STRUCTDEF___OUT_CH_) +-#define _TAO_IR_STRUCTDEF___OUT_CH_ +- +-class TAO_Export StructDef_out ++class TAO_Export IR_TypeDescription_out + { + public: +- StructDef_out (StructDef_ptr &); +- StructDef_out (StructDef_var &); +- StructDef_out (const StructDef_out &); +- StructDef_out &operator= (const StructDef_out &); +- StructDef_out &operator= (const StructDef_var &); +- StructDef_out &operator= (StructDef_ptr); +- operator StructDef_ptr &(); +- StructDef_ptr &ptr (void); +- StructDef_ptr operator-> (void); ++ IR_TypeDescription_out (IR_TypeDescription *&); ++ IR_TypeDescription_out (IR_TypeDescription_var &); ++ IR_TypeDescription_out (const IR_TypeDescription_out &); ++ IR_TypeDescription_out &operator= (const IR_TypeDescription_out &); ++ IR_TypeDescription_out &operator= (IR_TypeDescription *); ++ operator IR_TypeDescription *&(); ++ IR_TypeDescription *&ptr (void); ++ IR_TypeDescription *operator-> (void); + + private: +- StructDef_ptr &ptr_; ++ IR_TypeDescription *&ptr_; ++ // assignment from T_var not allowed ++ void operator= (const IR_TypeDescription_var &); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_STRUCTDEF_CH_) +-#define _TAO_IR_STRUCTDEF_CH_ +- + // Forward Classes Declaration + class _TAO_StructDef_Proxy_Impl; + class _TAO_StructDef_Remote_Proxy_Impl; + class _TAO_StructDef_Proxy_Broker; + class _TAO_StructDef_Remote_Proxy_Broker; + +-class TAO_Export StructDef: public virtual TypedefDef, public virtual Container ++class TAO_Export IR_StructDef: public virtual IR_TypedefDef, public virtual IR_Container + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef StructDef_ptr _ptr_type; +- typedef StructDef_var _var_type; ++ typedef IR_StructDef_ptr _ptr_type; ++ typedef IR_StructDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static StructDef_ptr _duplicate (StructDef_ptr obj); +- static StructDef_ptr _narrow ( ++ static IR_StructDef_ptr _duplicate (IR_StructDef_ptr obj); ++ static IR_StructDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static StructDef_ptr _unchecked_narrow ( ++ static IR_StructDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static StructDef_ptr _nil (void) ++ static IR_StructDef_ptr _nil (void) + { +- return (StructDef_ptr)0; ++ return (IR_StructDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::StructMemberSeq * members ( +- CORBA::Environment &ACE_TRY_ENV = ++ virtual IR_StructMemberSeq * members ( ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual void members ( +- const IR::StructMemberSeq & members, ++ virtual void members ( ++ const IR_StructMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -11306,121 +7233,27 @@ + _TAO_StructDef_Proxy_Broker *the_TAO_StructDef_Proxy_Broker_; + + protected: +- StructDef (int collocated = 0); ++ IR_StructDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- StructDef ( ++ IR_StructDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_StructDef_Remote_Proxy_Impl; +- friend class _TAO_StructDef_ThruPOA_Proxy_Impl; +- friend class _TAO_StructDef_Direct_Proxy_Impl; +- +- virtual ~StructDef (void); +- private: +- StructDef (const StructDef &); +- void operator= (const StructDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_StructDef_members_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::StructDef; +- +- friend class _TAO_StructDef_Remote_Proxy_Impl; +- friend class _TAO_StructDef_ThruPOA_Proxy_Impl; +- friend class _TAO_StructDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_StructDef_members_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_StructDef_members_get (const TAO_ClientRequestInfo_IR_StructDef_members_get &); +- void operator= (const TAO_ClientRequestInfo_IR_StructDef_members_get &); +- void result (IR::StructMemberSeq * result); +- // update the result +- IR::StructMemberSeq * result_; +- }; +- +- class TAO_ClientRequestInfo_IR_StructDef_members_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::StructDef; +- +- friend class _TAO_StructDef_Remote_Proxy_Impl; +- friend class _TAO_StructDef_ThruPOA_Proxy_Impl; +- friend class _TAO_StructDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_StructDef_members_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const IR::StructMemberSeq & members, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); ++ ++ friend class _TAO_StructDef_Remote_Proxy_Impl; ++ friend class _TAO_StructDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_StructDef_Direct_Proxy_Impl; + +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_StructDef (void); + private: +- TAO_ClientRequestInfo_IR_StructDef_members_set (const TAO_ClientRequestInfo_IR_StructDef_members_set &); +- void operator= (const TAO_ClientRequestInfo_IR_StructDef_members_set &); +- const IR::StructMemberSeq & members_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_StructDef (const IR_StructDef &); ++ void operator= (const IR_StructDef &); + }; + + +@@ -11434,13 +7267,13 @@ + // + + class TAO_Export _TAO_StructDef_Proxy_Impl : +- public virtual IR::_TAO_TypedefDef_Proxy_Impl, +- public virtual IR::_TAO_Container_Proxy_Impl ++ public virtual _TAO_TypedefDef_Proxy_Impl, ++ public virtual _TAO_Container_Proxy_Impl + { + public: + virtual ~_TAO_StructDef_Proxy_Impl (void) { } + +- virtual IR::StructMemberSeq * members ( ++ virtual IR_StructMemberSeq * members ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -11450,7 +7283,7 @@ + + virtual void members ( + CORBA_Object *_collocated_tao_target_, +- const IR::StructMemberSeq & members, ++ const IR_StructMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -11461,6 +7294,7 @@ + _TAO_StructDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -11473,8 +7307,8 @@ + class TAO_Export _TAO_StructDef_Remote_Proxy_Impl : + public virtual _TAO_StructDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_TypedefDef_Remote_Proxy_Impl, +- public virtual IR::_TAO_Container_Remote_Proxy_Impl ++ public virtual _TAO_TypedefDef_Remote_Proxy_Impl, ++ public virtual _TAO_Container_Remote_Proxy_Impl + + { + public: +@@ -11482,7 +7316,7 @@ + + virtual ~_TAO_StructDef_Remote_Proxy_Impl (void) { } + +- virtual IR::StructMemberSeq * members ( ++ virtual IR_StructMemberSeq * members ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -11492,7 +7326,7 @@ + + virtual void members ( + CORBA_Object *_collocated_tao_target_, +- const IR::StructMemberSeq & members, ++ const IR_StructMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -11521,8 +7355,9 @@ + { + public: + virtual ~_TAO_StructDef_Proxy_Broker (void); ++ + virtual _TAO_StructDef_Proxy_Impl &select_proxy ( +- StructDef *object, ++ IR_StructDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -11547,9 +7382,9 @@ + _TAO_StructDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_StructDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_StructDef_Proxy_Impl &select_proxy ( +- StructDef *object, ++ IR_StructDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -11563,117 +7398,39 @@ + static _TAO_StructDef_Remote_Proxy_Broker *the_TAO_StructDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructDef; +- +- +-#if !defined (_TAO_IR_UNIONDEF___PTR_CH_) +-#define _TAO_IR_UNIONDEF___PTR_CH_ +- +-class UnionDef; +-typedef UnionDef *UnionDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_UNIONDEF___VAR_CH_) +-#define _TAO_IR_UNIONDEF___VAR_CH_ +- +-class TAO_Export UnionDef_var : public TAO_Base_var +-{ +-public: +- UnionDef_var (void); // default constructor +- UnionDef_var (UnionDef_ptr p) : ptr_ (p) {} +- UnionDef_var (const UnionDef_var &); // copy constructor +- ~UnionDef_var (void); // destructor +- +- UnionDef_var &operator= (UnionDef_ptr); +- UnionDef_var &operator= (const UnionDef_var &); +- UnionDef_ptr operator-> (void) const; +- +- operator const UnionDef_ptr &() const; +- operator UnionDef_ptr &(); +- // in, inout, out, _retn +- UnionDef_ptr in (void) const; +- UnionDef_ptr &inout (void); +- UnionDef_ptr &out (void); +- UnionDef_ptr _retn (void); +- UnionDef_ptr ptr (void) const; +- +-private: +- UnionDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- UnionDef_var (const TAO_Base_var &rhs); +- UnionDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_UNIONDEF___OUT_CH_) +-#define _TAO_IR_UNIONDEF___OUT_CH_ +- +-class TAO_Export UnionDef_out +-{ +-public: +- UnionDef_out (UnionDef_ptr &); +- UnionDef_out (UnionDef_var &); +- UnionDef_out (const UnionDef_out &); +- UnionDef_out &operator= (const UnionDef_out &); +- UnionDef_out &operator= (const UnionDef_var &); +- UnionDef_out &operator= (UnionDef_ptr); +- operator UnionDef_ptr &(); +- UnionDef_ptr &ptr (void); +- UnionDef_ptr operator-> (void); +- +-private: +- UnionDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_UNIONDEF_CH_) +-#define _TAO_IR_UNIONDEF_CH_ +- + // Forward Classes Declaration + class _TAO_UnionDef_Proxy_Impl; + class _TAO_UnionDef_Remote_Proxy_Impl; + class _TAO_UnionDef_Proxy_Broker; + class _TAO_UnionDef_Remote_Proxy_Broker; + +-class TAO_Export UnionDef: public virtual TypedefDef, public virtual Container ++class TAO_Export IR_UnionDef: public virtual IR_TypedefDef, public virtual IR_Container + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef UnionDef_ptr _ptr_type; +- typedef UnionDef_var _var_type; ++ typedef IR_UnionDef_ptr _ptr_type; ++ typedef IR_UnionDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static UnionDef_ptr _duplicate (UnionDef_ptr obj); +- static UnionDef_ptr _narrow ( ++ static IR_UnionDef_ptr _duplicate (IR_UnionDef_ptr obj); ++ static IR_UnionDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static UnionDef_ptr _unchecked_narrow ( ++ static IR_UnionDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static UnionDef_ptr _nil (void) ++ static IR_UnionDef_ptr _nil (void) + { +- return (UnionDef_ptr)0; ++ return (IR_UnionDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -11686,7 +7443,7 @@ + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr discriminator_type_def ( ++ virtual IR_IDLType_ptr discriminator_type_def ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -11695,7 +7452,7 @@ + )); + + virtual void discriminator_type_def ( +- IR::IDLType_ptr discriminator_type_def, ++ IR_IDLType_ptr discriminator_type_def, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -11703,7 +7460,7 @@ + CORBA::SystemException + )); + +- virtual IR::UnionMemberSeq * members ( ++ virtual IR_UnionMemberSeq * members ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -11712,7 +7469,7 @@ + )); + + virtual void members ( +- const IR::UnionMemberSeq & members, ++ const IR_UnionMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -11733,250 +7490,27 @@ + _TAO_UnionDef_Proxy_Broker *the_TAO_UnionDef_Proxy_Broker_; + + protected: +- UnionDef (int collocated = 0); ++ IR_UnionDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- UnionDef ( ++ IR_UnionDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_UnionDef_Remote_Proxy_Impl; +- friend class _TAO_UnionDef_ThruPOA_Proxy_Impl; +- friend class _TAO_UnionDef_Direct_Proxy_Impl; +- +- virtual ~UnionDef (void); +- private: +- UnionDef (const UnionDef &); +- void operator= (const UnionDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::UnionDef; +- +- friend class _TAO_UnionDef_Remote_Proxy_Impl; +- friend class _TAO_UnionDef_ThruPOA_Proxy_Impl; +- friend class _TAO_UnionDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_get (const TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_get &); +- void operator= (const TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_get &); +- void result (CORBA::TypeCode_ptr result); +- // update the result +- CORBA::TypeCode_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::UnionDef; +- +- friend class _TAO_UnionDef_Remote_Proxy_Impl; +- friend class _TAO_UnionDef_ThruPOA_Proxy_Impl; +- friend class _TAO_UnionDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); + +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_get (const TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_get &); +- void operator= (const TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_get &); +- void result (IR::IDLType_ptr result); +- // update the result +- IR::IDLType_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::UnionDef; +- +- friend class _TAO_UnionDef_Remote_Proxy_Impl; +- friend class _TAO_UnionDef_ThruPOA_Proxy_Impl; +- friend class _TAO_UnionDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::IDLType_ptr discriminator_type_def, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_set (const TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_set &); +- void operator= (const TAO_ClientRequestInfo_IR_UnionDef_discriminator_type_def_set &); +- IR::IDLType_ptr discriminator_type_def_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_UnionDef_members_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::UnionDef; +- + friend class _TAO_UnionDef_Remote_Proxy_Impl; + friend class _TAO_UnionDef_ThruPOA_Proxy_Impl; + friend class _TAO_UnionDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_UnionDef_members_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_UnionDef_members_get (const TAO_ClientRequestInfo_IR_UnionDef_members_get &); +- void operator= (const TAO_ClientRequestInfo_IR_UnionDef_members_get &); +- void result (IR::UnionMemberSeq * result); +- // update the result +- IR::UnionMemberSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_UnionDef_members_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::UnionDef; + +- friend class _TAO_UnionDef_Remote_Proxy_Impl; +- friend class _TAO_UnionDef_ThruPOA_Proxy_Impl; +- friend class _TAO_UnionDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_UnionDef_members_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const IR::UnionMemberSeq & members, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_UnionDef (void); + private: +- TAO_ClientRequestInfo_IR_UnionDef_members_set (const TAO_ClientRequestInfo_IR_UnionDef_members_set &); +- void operator= (const TAO_ClientRequestInfo_IR_UnionDef_members_set &); +- const IR::UnionMemberSeq & members_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_UnionDef (const IR_UnionDef &); ++ void operator= (const IR_UnionDef &); + }; + + +@@ -11990,13 +7524,13 @@ + // + + class TAO_Export _TAO_UnionDef_Proxy_Impl : +- public virtual IR::_TAO_TypedefDef_Proxy_Impl, +- public virtual IR::_TAO_Container_Proxy_Impl ++ public virtual _TAO_TypedefDef_Proxy_Impl, ++ public virtual _TAO_Container_Proxy_Impl + { + public: + virtual ~_TAO_UnionDef_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr discriminator_type ( ++ virtual CORBA::TypeCode_ptr discriminator_type ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -12004,7 +7538,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::IDLType_ptr discriminator_type_def ( ++ virtual IR_IDLType_ptr discriminator_type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -12014,24 +7548,24 @@ + + virtual void discriminator_type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr discriminator_type_def, ++ IR_IDLType_ptr discriminator_type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::UnionMemberSeq * members ( ++ virtual IR_UnionMemberSeq * members ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual void members ( ++ virtual void members ( + CORBA_Object *_collocated_tao_target_, +- const IR::UnionMemberSeq & members, ++ const IR_UnionMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -12042,6 +7576,7 @@ + _TAO_UnionDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -12054,8 +7589,8 @@ + class TAO_Export _TAO_UnionDef_Remote_Proxy_Impl : + public virtual _TAO_UnionDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_TypedefDef_Remote_Proxy_Impl, +- public virtual IR::_TAO_Container_Remote_Proxy_Impl ++ public virtual _TAO_TypedefDef_Remote_Proxy_Impl, ++ public virtual _TAO_Container_Remote_Proxy_Impl + + { + public: +@@ -12063,7 +7598,7 @@ + + virtual ~_TAO_UnionDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr discriminator_type ( ++ virtual CORBA::TypeCode_ptr discriminator_type ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -12071,7 +7606,7 @@ + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr discriminator_type_def ( ++ virtual IR_IDLType_ptr discriminator_type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -12081,14 +7616,14 @@ + + virtual void discriminator_type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr discriminator_type_def, ++ IR_IDLType_ptr discriminator_type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::UnionMemberSeq * members ( ++ virtual IR_UnionMemberSeq * members ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -12098,7 +7633,7 @@ + + virtual void members ( + CORBA_Object *_collocated_tao_target_, +- const IR::UnionMemberSeq & members, ++ const IR_UnionMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -12127,8 +7662,9 @@ + { + public: + virtual ~_TAO_UnionDef_Proxy_Broker (void); ++ + virtual _TAO_UnionDef_Proxy_Impl &select_proxy ( +- UnionDef *object, ++ IR_UnionDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -12153,9 +7689,9 @@ + _TAO_UnionDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_UnionDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_UnionDef_Proxy_Impl &select_proxy ( +- UnionDef *object, ++ IR_UnionDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -12169,122 +7705,44 @@ + static _TAO_UnionDef_Remote_Proxy_Broker *the_TAO_UnionDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + ++// Forward Classes Declaration ++class _TAO_EnumDef_Proxy_Impl; ++class _TAO_EnumDef_Remote_Proxy_Impl; ++class _TAO_EnumDef_Proxy_Broker; ++class _TAO_EnumDef_Remote_Proxy_Broker; + +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionDef; +- +- +-#if !defined (_TAO_IR_ENUMDEF___PTR_CH_) +-#define _TAO_IR_ENUMDEF___PTR_CH_ +- +-class EnumDef; +-typedef EnumDef *EnumDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ENUMDEF___VAR_CH_) +-#define _TAO_IR_ENUMDEF___VAR_CH_ +- +-class TAO_Export EnumDef_var : public TAO_Base_var +-{ +-public: +- EnumDef_var (void); // default constructor +- EnumDef_var (EnumDef_ptr p) : ptr_ (p) {} +- EnumDef_var (const EnumDef_var &); // copy constructor +- ~EnumDef_var (void); // destructor +- +- EnumDef_var &operator= (EnumDef_ptr); +- EnumDef_var &operator= (const EnumDef_var &); +- EnumDef_ptr operator-> (void) const; +- +- operator const EnumDef_ptr &() const; +- operator EnumDef_ptr &(); +- // in, inout, out, _retn +- EnumDef_ptr in (void) const; +- EnumDef_ptr &inout (void); +- EnumDef_ptr &out (void); +- EnumDef_ptr _retn (void); +- EnumDef_ptr ptr (void) const; +- +-private: +- EnumDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- EnumDef_var (const TAO_Base_var &rhs); +- EnumDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ENUMDEF___OUT_CH_) +-#define _TAO_IR_ENUMDEF___OUT_CH_ +- +-class TAO_Export EnumDef_out +-{ +-public: +- EnumDef_out (EnumDef_ptr &); +- EnumDef_out (EnumDef_var &); +- EnumDef_out (const EnumDef_out &); +- EnumDef_out &operator= (const EnumDef_out &); +- EnumDef_out &operator= (const EnumDef_var &); +- EnumDef_out &operator= (EnumDef_ptr); +- operator EnumDef_ptr &(); +- EnumDef_ptr &ptr (void); +- EnumDef_ptr operator-> (void); +- +-private: +- EnumDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ENUMDEF_CH_) +-#define _TAO_IR_ENUMDEF_CH_ +- +-// Forward Classes Declaration +-class _TAO_EnumDef_Proxy_Impl; +-class _TAO_EnumDef_Remote_Proxy_Impl; +-class _TAO_EnumDef_Proxy_Broker; +-class _TAO_EnumDef_Remote_Proxy_Broker; +- +-class TAO_Export EnumDef: public virtual TypedefDef ++class TAO_Export IR_EnumDef: public virtual IR_TypedefDef + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef EnumDef_ptr _ptr_type; +- typedef EnumDef_var _var_type; ++ typedef IR_EnumDef_ptr _ptr_type; ++ typedef IR_EnumDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static EnumDef_ptr _duplicate (EnumDef_ptr obj); +- static EnumDef_ptr _narrow ( ++ static IR_EnumDef_ptr _duplicate (IR_EnumDef_ptr obj); ++ static IR_EnumDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static EnumDef_ptr _unchecked_narrow ( ++ static IR_EnumDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static EnumDef_ptr _nil (void) ++ static IR_EnumDef_ptr _nil (void) + { +- return (EnumDef_ptr)0; ++ return (IR_EnumDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::EnumMemberSeq * members ( ++ virtual IR_EnumMemberSeq * members ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -12293,7 +7751,7 @@ + )); + + virtual void members ( +- const IR::EnumMemberSeq & members, ++ const IR_EnumMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -12314,121 +7772,27 @@ + _TAO_EnumDef_Proxy_Broker *the_TAO_EnumDef_Proxy_Broker_; + + protected: +- EnumDef (int collocated = 0); ++ IR_EnumDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- EnumDef ( ++ IR_EnumDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_EnumDef_Remote_Proxy_Impl; +- friend class _TAO_EnumDef_ThruPOA_Proxy_Impl; +- friend class _TAO_EnumDef_Direct_Proxy_Impl; +- +- virtual ~EnumDef (void); +- private: +- EnumDef (const EnumDef &); +- void operator= (const EnumDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_EnumDef_members_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::EnumDef; +- +- friend class _TAO_EnumDef_Remote_Proxy_Impl; +- friend class _TAO_EnumDef_ThruPOA_Proxy_Impl; +- friend class _TAO_EnumDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_EnumDef_members_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_EnumDef_members_get (const TAO_ClientRequestInfo_IR_EnumDef_members_get &); +- void operator= (const TAO_ClientRequestInfo_IR_EnumDef_members_get &); +- void result (IR::EnumMemberSeq * result); +- // update the result +- IR::EnumMemberSeq * result_; +- }; +- +- class TAO_ClientRequestInfo_IR_EnumDef_members_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::EnumDef; +- +- friend class _TAO_EnumDef_Remote_Proxy_Impl; +- friend class _TAO_EnumDef_ThruPOA_Proxy_Impl; +- friend class _TAO_EnumDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_EnumDef_members_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const IR::EnumMemberSeq & members, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); ++ ++ friend class _TAO_EnumDef_Remote_Proxy_Impl; ++ friend class _TAO_EnumDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_EnumDef_Direct_Proxy_Impl; + +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_EnumDef (void); + private: +- TAO_ClientRequestInfo_IR_EnumDef_members_set (const TAO_ClientRequestInfo_IR_EnumDef_members_set &); +- void operator= (const TAO_ClientRequestInfo_IR_EnumDef_members_set &); +- const IR::EnumMemberSeq & members_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_EnumDef (const IR_EnumDef &); ++ void operator= (const IR_EnumDef &); + }; + + +@@ -12442,12 +7806,12 @@ + // + + class TAO_Export _TAO_EnumDef_Proxy_Impl : +- public virtual IR::_TAO_TypedefDef_Proxy_Impl ++ public virtual _TAO_TypedefDef_Proxy_Impl + { + public: + virtual ~_TAO_EnumDef_Proxy_Impl (void) { } + +- virtual IR::EnumMemberSeq * members ( ++ virtual IR_EnumMemberSeq * members ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -12455,9 +7819,9 @@ + CORBA::SystemException + )) = 0; + +- virtual void members ( ++ virtual void members ( + CORBA_Object *_collocated_tao_target_, +- const IR::EnumMemberSeq & members, ++ const IR_EnumMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -12468,6 +7832,7 @@ + _TAO_EnumDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -12480,7 +7845,7 @@ + class TAO_Export _TAO_EnumDef_Remote_Proxy_Impl : + public virtual _TAO_EnumDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_TypedefDef_Remote_Proxy_Impl ++ public virtual _TAO_TypedefDef_Remote_Proxy_Impl + + { + public: +@@ -12488,7 +7853,7 @@ + + virtual ~_TAO_EnumDef_Remote_Proxy_Impl (void) { } + +- virtual IR::EnumMemberSeq * members ( ++ virtual IR_EnumMemberSeq * members ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -12498,7 +7863,7 @@ + + virtual void members ( + CORBA_Object *_collocated_tao_target_, +- const IR::EnumMemberSeq & members, ++ const IR_EnumMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -12527,8 +7892,9 @@ + { + public: + virtual ~_TAO_EnumDef_Proxy_Broker (void); ++ + virtual _TAO_EnumDef_Proxy_Impl &select_proxy ( +- EnumDef *object, ++ IR_EnumDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -12553,9 +7919,9 @@ + _TAO_EnumDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_EnumDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_EnumDef_Proxy_Impl &select_proxy ( +- EnumDef *object, ++ IR_EnumDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -12569,122 +7935,44 @@ + static _TAO_EnumDef_Remote_Proxy_Broker *the_TAO_EnumDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EnumDef; +- +- +-#if !defined (_TAO_IR_ALIASDEF___PTR_CH_) +-#define _TAO_IR_ALIASDEF___PTR_CH_ +- +-class AliasDef; +-typedef AliasDef *AliasDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ALIASDEF___VAR_CH_) +-#define _TAO_IR_ALIASDEF___VAR_CH_ +- +-class TAO_Export AliasDef_var : public TAO_Base_var +-{ +-public: +- AliasDef_var (void); // default constructor +- AliasDef_var (AliasDef_ptr p) : ptr_ (p) {} +- AliasDef_var (const AliasDef_var &); // copy constructor +- ~AliasDef_var (void); // destructor +- +- AliasDef_var &operator= (AliasDef_ptr); +- AliasDef_var &operator= (const AliasDef_var &); +- AliasDef_ptr operator-> (void) const; +- +- operator const AliasDef_ptr &() const; +- operator AliasDef_ptr &(); +- // in, inout, out, _retn +- AliasDef_ptr in (void) const; +- AliasDef_ptr &inout (void); +- AliasDef_ptr &out (void); +- AliasDef_ptr _retn (void); +- AliasDef_ptr ptr (void) const; +- +-private: +- AliasDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- AliasDef_var (const TAO_Base_var &rhs); +- AliasDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ALIASDEF___OUT_CH_) +-#define _TAO_IR_ALIASDEF___OUT_CH_ +- +-class TAO_Export AliasDef_out +-{ +-public: +- AliasDef_out (AliasDef_ptr &); +- AliasDef_out (AliasDef_var &); +- AliasDef_out (const AliasDef_out &); +- AliasDef_out &operator= (const AliasDef_out &); +- AliasDef_out &operator= (const AliasDef_var &); +- AliasDef_out &operator= (AliasDef_ptr); +- operator AliasDef_ptr &(); +- AliasDef_ptr &ptr (void); +- AliasDef_ptr operator-> (void); +- +-private: +- AliasDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ALIASDEF_CH_) +-#define _TAO_IR_ALIASDEF_CH_ +- + // Forward Classes Declaration + class _TAO_AliasDef_Proxy_Impl; + class _TAO_AliasDef_Remote_Proxy_Impl; + class _TAO_AliasDef_Proxy_Broker; + class _TAO_AliasDef_Remote_Proxy_Broker; + +-class TAO_Export AliasDef: public virtual TypedefDef ++class TAO_Export IR_AliasDef: public virtual IR_TypedefDef + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef AliasDef_ptr _ptr_type; +- typedef AliasDef_var _var_type; ++ typedef IR_AliasDef_ptr _ptr_type; ++ typedef IR_AliasDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static AliasDef_ptr _duplicate (AliasDef_ptr obj); +- static AliasDef_ptr _narrow ( ++ static IR_AliasDef_ptr _duplicate (IR_AliasDef_ptr obj); ++ static IR_AliasDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static AliasDef_ptr _unchecked_narrow ( ++ static IR_AliasDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static AliasDef_ptr _nil (void) ++ static IR_AliasDef_ptr _nil (void) + { +- return (AliasDef_ptr)0; ++ return (IR_AliasDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::IDLType_ptr original_type_def ( ++ virtual IR_IDLType_ptr original_type_def ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -12692,8 +7980,8 @@ + CORBA::SystemException + )); + +- virtual void original_type_def ( +- IR::IDLType_ptr original_type_def, ++ virtual void original_type_def ( ++ IR_IDLType_ptr original_type_def, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -12714,121 +8002,27 @@ + _TAO_AliasDef_Proxy_Broker *the_TAO_AliasDef_Proxy_Broker_; + + protected: +- AliasDef (int collocated = 0); ++ IR_AliasDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- AliasDef ( ++ IR_AliasDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_AliasDef_Remote_Proxy_Impl; +- friend class _TAO_AliasDef_ThruPOA_Proxy_Impl; +- friend class _TAO_AliasDef_Direct_Proxy_Impl; +- +- virtual ~AliasDef (void); +- private: +- AliasDef (const AliasDef &); +- void operator= (const AliasDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_AliasDef_original_type_def_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::AliasDef; +- +- friend class _TAO_AliasDef_Remote_Proxy_Impl; +- friend class _TAO_AliasDef_ThruPOA_Proxy_Impl; +- friend class _TAO_AliasDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_AliasDef_original_type_def_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_AliasDef_original_type_def_get (const TAO_ClientRequestInfo_IR_AliasDef_original_type_def_get &); +- void operator= (const TAO_ClientRequestInfo_IR_AliasDef_original_type_def_get &); +- void result (IR::IDLType_ptr result); +- // update the result +- IR::IDLType_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_AliasDef_original_type_def_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::AliasDef; +- +- friend class _TAO_AliasDef_Remote_Proxy_Impl; +- friend class _TAO_AliasDef_ThruPOA_Proxy_Impl; +- friend class _TAO_AliasDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_AliasDef_original_type_def_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::IDLType_ptr original_type_def, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); ++ ++ friend class _TAO_AliasDef_Remote_Proxy_Impl; ++ friend class _TAO_AliasDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_AliasDef_Direct_Proxy_Impl; + +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_AliasDef (void); + private: +- TAO_ClientRequestInfo_IR_AliasDef_original_type_def_set (const TAO_ClientRequestInfo_IR_AliasDef_original_type_def_set &); +- void operator= (const TAO_ClientRequestInfo_IR_AliasDef_original_type_def_set &); +- IR::IDLType_ptr original_type_def_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_AliasDef (const IR_AliasDef &); ++ void operator= (const IR_AliasDef &); + }; + + +@@ -12842,12 +8036,12 @@ + // + + class TAO_Export _TAO_AliasDef_Proxy_Impl : +- public virtual IR::_TAO_TypedefDef_Proxy_Impl ++ public virtual _TAO_TypedefDef_Proxy_Impl + { + public: + virtual ~_TAO_AliasDef_Proxy_Impl (void) { } + +- virtual IR::IDLType_ptr original_type_def ( ++ virtual IR_IDLType_ptr original_type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -12857,7 +8051,7 @@ + + virtual void original_type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr original_type_def, ++ IR_IDLType_ptr original_type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -12868,6 +8062,7 @@ + _TAO_AliasDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -12880,7 +8075,7 @@ + class TAO_Export _TAO_AliasDef_Remote_Proxy_Impl : + public virtual _TAO_AliasDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_TypedefDef_Remote_Proxy_Impl ++ public virtual _TAO_TypedefDef_Remote_Proxy_Impl + + { + public: +@@ -12888,7 +8083,7 @@ + + virtual ~_TAO_AliasDef_Remote_Proxy_Impl (void) { } + +- virtual IR::IDLType_ptr original_type_def ( ++ virtual IR_IDLType_ptr original_type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -12898,7 +8093,7 @@ + + virtual void original_type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr original_type_def, ++ IR_IDLType_ptr original_type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -12927,8 +8122,9 @@ + { + public: + virtual ~_TAO_AliasDef_Proxy_Broker (void); ++ + virtual _TAO_AliasDef_Proxy_Impl &select_proxy ( +- AliasDef *object, ++ IR_AliasDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -12953,9 +8149,9 @@ + _TAO_AliasDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_AliasDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_AliasDef_Proxy_Impl &select_proxy ( +- AliasDef *object, ++ IR_AliasDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -12969,117 +8165,39 @@ + static _TAO_AliasDef_Remote_Proxy_Broker *the_TAO_AliasDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AliasDef; +- +- +-#if !defined (_TAO_IR_NATIVEDEF___PTR_CH_) +-#define _TAO_IR_NATIVEDEF___PTR_CH_ +- +-class NativeDef; +-typedef NativeDef *NativeDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_NATIVEDEF___VAR_CH_) +-#define _TAO_IR_NATIVEDEF___VAR_CH_ +- +-class TAO_Export NativeDef_var : public TAO_Base_var +-{ +-public: +- NativeDef_var (void); // default constructor +- NativeDef_var (NativeDef_ptr p) : ptr_ (p) {} +- NativeDef_var (const NativeDef_var &); // copy constructor +- ~NativeDef_var (void); // destructor +- +- NativeDef_var &operator= (NativeDef_ptr); +- NativeDef_var &operator= (const NativeDef_var &); +- NativeDef_ptr operator-> (void) const; +- +- operator const NativeDef_ptr &() const; +- operator NativeDef_ptr &(); +- // in, inout, out, _retn +- NativeDef_ptr in (void) const; +- NativeDef_ptr &inout (void); +- NativeDef_ptr &out (void); +- NativeDef_ptr _retn (void); +- NativeDef_ptr ptr (void) const; +- +-private: +- NativeDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- NativeDef_var (const TAO_Base_var &rhs); +- NativeDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_NATIVEDEF___OUT_CH_) +-#define _TAO_IR_NATIVEDEF___OUT_CH_ +- +-class TAO_Export NativeDef_out +-{ +-public: +- NativeDef_out (NativeDef_ptr &); +- NativeDef_out (NativeDef_var &); +- NativeDef_out (const NativeDef_out &); +- NativeDef_out &operator= (const NativeDef_out &); +- NativeDef_out &operator= (const NativeDef_var &); +- NativeDef_out &operator= (NativeDef_ptr); +- operator NativeDef_ptr &(); +- NativeDef_ptr &ptr (void); +- NativeDef_ptr operator-> (void); +- +-private: +- NativeDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_NATIVEDEF_CH_) +-#define _TAO_IR_NATIVEDEF_CH_ +- + // Forward Classes Declaration + class _TAO_NativeDef_Proxy_Impl; + class _TAO_NativeDef_Remote_Proxy_Impl; + class _TAO_NativeDef_Proxy_Broker; + class _TAO_NativeDef_Remote_Proxy_Broker; + +-class TAO_Export NativeDef: public virtual TypedefDef ++class TAO_Export IR_NativeDef: public virtual IR_TypedefDef + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef NativeDef_ptr _ptr_type; +- typedef NativeDef_var _var_type; ++ typedef IR_NativeDef_ptr _ptr_type; ++ typedef IR_NativeDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static NativeDef_ptr _duplicate (NativeDef_ptr obj); +- static NativeDef_ptr _narrow ( ++ static IR_NativeDef_ptr _duplicate (IR_NativeDef_ptr obj); ++ static IR_NativeDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static NativeDef_ptr _unchecked_narrow ( ++ static IR_NativeDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static NativeDef_ptr _nil (void) ++ static IR_NativeDef_ptr _nil (void) + { +- return (NativeDef_ptr)0; ++ return (IR_NativeDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -13097,60 +8215,53 @@ + _TAO_NativeDef_Proxy_Broker *the_TAO_NativeDef_Proxy_Broker_; + + protected: +- NativeDef (int collocated = 0); ++ IR_NativeDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- NativeDef ( ++ IR_NativeDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); ++ ); + +- friend class _TAO_NativeDef_Remote_Proxy_Impl; +- friend class _TAO_NativeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_NativeDef_Direct_Proxy_Impl; ++ friend class _TAO_NativeDef_Remote_Proxy_Impl; ++ friend class _TAO_NativeDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_NativeDef_Direct_Proxy_Impl; + +- virtual ~NativeDef (void); +- private: +- NativeDef (const NativeDef &); +- void operator= (const NativeDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- #endif /* TAO_HAS_INTERCEPTORS */ +- +- }; ++ virtual ~IR_NativeDef (void); ++private: ++ IR_NativeDef (const IR_NativeDef &); ++ void operator= (const IR_NativeDef &); ++}; + + + // The Proxy Implementations are used by each interface to + // perform a call. Each different implementation encapsulate + // an invocation logics. + +- +- /////////////////////////////////////////////////////////////////////// +- // Base Impl. Declaration +- // + +- class TAO_Export _TAO_NativeDef_Proxy_Impl : +- public virtual IR::_TAO_TypedefDef_Proxy_Impl +- { +- public: +- virtual ~_TAO_NativeDef_Proxy_Impl (void) { } ++/////////////////////////////////////////////////////////////////////// ++// Base Impl. Declaration ++// ++ ++class TAO_Export _TAO_NativeDef_Proxy_Impl : ++ public virtual _TAO_TypedefDef_Proxy_Impl ++{ ++public: ++ virtual ~_TAO_NativeDef_Proxy_Impl (void) { } + +- protected: +- _TAO_NativeDef_Proxy_Impl (void); ++protected: ++ _TAO_NativeDef_Proxy_Impl (void); + +- }; +- // +- // Base Proxy Impl. Declaration +- /////////////////////////////////////////////////////////////////////// ++}; ++ ++// ++// Base Proxy Impl. Declaration ++/////////////////////////////////////////////////////////////////////// + + + /////////////////////////////////////////////////////////////////////// +@@ -13160,7 +8271,7 @@ + class TAO_Export _TAO_NativeDef_Remote_Proxy_Impl : + public virtual _TAO_NativeDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_TypedefDef_Remote_Proxy_Impl ++ public virtual _TAO_TypedefDef_Remote_Proxy_Impl + + { + public: +@@ -13168,7 +8279,7 @@ + + virtual ~_TAO_NativeDef_Remote_Proxy_Impl (void) { } + +- }; ++}; + + // + // Base Proxy Impl. Declaration +@@ -13190,8 +8301,9 @@ + { + public: + virtual ~_TAO_NativeDef_Proxy_Broker (void); ++ + virtual _TAO_NativeDef_Proxy_Impl &select_proxy ( +- NativeDef *object, ++ IR_NativeDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -13216,138 +8328,60 @@ + _TAO_NativeDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_NativeDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_NativeDef_Proxy_Impl &select_proxy ( +- NativeDef *object, ++ IR_NativeDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + + private: + _TAO_NativeDef_Remote_Proxy_Impl remote_proxy_impl_; +-// This member function is used to get an handle to the unique instance +-// of the Remote Proxy Broker that is available for a given +-// interface. +- +-public: +- static _TAO_NativeDef_Remote_Proxy_Broker *the_TAO_NativeDef_Remote_Proxy_Broker (void); + }; + ++// This funxtion is used to get an handle to the unique instance ++// of the Remote Proxy Broker that is available for a given ++// interface. ++ ++_TAO_NativeDef_Remote_Proxy_Broker *the_TAO_NativeDef_Remote_Proxy_Broker (void); + + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_NativeDef; +- +- +-#if !defined (_TAO_IR_PRIMITIVEDEF___PTR_CH_) +-#define _TAO_IR_PRIMITIVEDEF___PTR_CH_ +- +-class PrimitiveDef; +-typedef PrimitiveDef *PrimitiveDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PRIMITIVEDEF___VAR_CH_) +-#define _TAO_IR_PRIMITIVEDEF___VAR_CH_ +- +-class TAO_Export PrimitiveDef_var : public TAO_Base_var +-{ +-public: +- PrimitiveDef_var (void); // default constructor +- PrimitiveDef_var (PrimitiveDef_ptr p) : ptr_ (p) {} +- PrimitiveDef_var (const PrimitiveDef_var &); // copy constructor +- ~PrimitiveDef_var (void); // destructor +- +- PrimitiveDef_var &operator= (PrimitiveDef_ptr); +- PrimitiveDef_var &operator= (const PrimitiveDef_var &); +- PrimitiveDef_ptr operator-> (void) const; +- +- operator const PrimitiveDef_ptr &() const; +- operator PrimitiveDef_ptr &(); +- // in, inout, out, _retn +- PrimitiveDef_ptr in (void) const; +- PrimitiveDef_ptr &inout (void); +- PrimitiveDef_ptr &out (void); +- PrimitiveDef_ptr _retn (void); +- PrimitiveDef_ptr ptr (void) const; +- +-private: +- PrimitiveDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- PrimitiveDef_var (const TAO_Base_var &rhs); +- PrimitiveDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PRIMITIVEDEF___OUT_CH_) +-#define _TAO_IR_PRIMITIVEDEF___OUT_CH_ +- +-class TAO_Export PrimitiveDef_out +-{ +-public: +- PrimitiveDef_out (PrimitiveDef_ptr &); +- PrimitiveDef_out (PrimitiveDef_var &); +- PrimitiveDef_out (const PrimitiveDef_out &); +- PrimitiveDef_out &operator= (const PrimitiveDef_out &); +- PrimitiveDef_out &operator= (const PrimitiveDef_var &); +- PrimitiveDef_out &operator= (PrimitiveDef_ptr); +- operator PrimitiveDef_ptr &(); +- PrimitiveDef_ptr &ptr (void); +- PrimitiveDef_ptr operator-> (void); +- +-private: +- PrimitiveDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PRIMITIVEDEF_CH_) +-#define _TAO_IR_PRIMITIVEDEF_CH_ +- + // Forward Classes Declaration + class _TAO_PrimitiveDef_Proxy_Impl; + class _TAO_PrimitiveDef_Remote_Proxy_Impl; + class _TAO_PrimitiveDef_Proxy_Broker; + class _TAO_PrimitiveDef_Remote_Proxy_Broker; + +-class TAO_Export PrimitiveDef: public virtual IDLType ++class TAO_Export IR_PrimitiveDef: public virtual IR_IDLType + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef PrimitiveDef_ptr _ptr_type; +- typedef PrimitiveDef_var _var_type; ++ typedef IR_PrimitiveDef_ptr _ptr_type; ++ typedef IR_PrimitiveDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static PrimitiveDef_ptr _duplicate (PrimitiveDef_ptr obj); +- static PrimitiveDef_ptr _narrow ( ++ static IR_PrimitiveDef_ptr _duplicate (IR_PrimitiveDef_ptr obj); ++ static IR_PrimitiveDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static PrimitiveDef_ptr _unchecked_narrow ( ++ static IR_PrimitiveDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static PrimitiveDef_ptr _nil (void) ++ static IR_PrimitiveDef_ptr _nil (void) + { +- return (PrimitiveDef_ptr)0; ++ return (IR_PrimitiveDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::PrimitiveKind kind ( ++ virtual IR_PrimitiveKind kind ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -13368,78 +8402,27 @@ + _TAO_PrimitiveDef_Proxy_Broker *the_TAO_PrimitiveDef_Proxy_Broker_; + + protected: +- PrimitiveDef (int collocated = 0); ++ IR_PrimitiveDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- PrimitiveDef ( ++ IR_PrimitiveDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_PrimitiveDef_Remote_Proxy_Impl; +- friend class _TAO_PrimitiveDef_ThruPOA_Proxy_Impl; +- friend class _TAO_PrimitiveDef_Direct_Proxy_Impl; +- +- virtual ~PrimitiveDef (void); +- private: +- PrimitiveDef (const PrimitiveDef &); +- void operator= (const PrimitiveDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_PrimitiveDef_kind_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::PrimitiveDef; +- +- friend class _TAO_PrimitiveDef_Remote_Proxy_Impl; +- friend class _TAO_PrimitiveDef_ThruPOA_Proxy_Impl; +- friend class _TAO_PrimitiveDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_PrimitiveDef_kind_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ ); + +- private: +- TAO_ClientRequestInfo_IR_PrimitiveDef_kind_get (const TAO_ClientRequestInfo_IR_PrimitiveDef_kind_get &); +- void operator= (const TAO_ClientRequestInfo_IR_PrimitiveDef_kind_get &); +- void result (IR::PrimitiveKind result); +- // update the result +- IR::PrimitiveKind result_; +- }; ++ friend class _TAO_PrimitiveDef_Remote_Proxy_Impl; ++ friend class _TAO_PrimitiveDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_PrimitiveDef_Direct_Proxy_Impl; + +- #endif /* TAO_HAS_INTERCEPTORS */ +- ++ virtual ~IR_PrimitiveDef (void); ++private: ++ IR_PrimitiveDef (const IR_PrimitiveDef &); ++ void operator= (const IR_PrimitiveDef &); + }; + + +@@ -13453,12 +8436,12 @@ + // + + class TAO_Export _TAO_PrimitiveDef_Proxy_Impl : +- public virtual IR::_TAO_IDLType_Proxy_Impl ++ public virtual _TAO_IDLType_Proxy_Impl + { + public: + virtual ~_TAO_PrimitiveDef_Proxy_Impl (void) { } + +- virtual IR::PrimitiveKind kind ( ++ virtual IR_PrimitiveKind kind ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -13470,6 +8453,7 @@ + _TAO_PrimitiveDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -13482,7 +8466,7 @@ + class TAO_Export _TAO_PrimitiveDef_Remote_Proxy_Impl : + public virtual _TAO_PrimitiveDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_IDLType_Remote_Proxy_Impl ++ public virtual _TAO_IDLType_Remote_Proxy_Impl + + { + public: +@@ -13490,7 +8474,7 @@ + + virtual ~_TAO_PrimitiveDef_Remote_Proxy_Impl (void) { } + +- virtual IR::PrimitiveKind kind ( ++ virtual IR_PrimitiveKind kind ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -13520,8 +8504,9 @@ + { + public: + virtual ~_TAO_PrimitiveDef_Proxy_Broker (void); ++ + virtual _TAO_PrimitiveDef_Proxy_Impl &select_proxy ( +- PrimitiveDef *object, ++ IR_PrimitiveDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -13546,9 +8531,9 @@ + _TAO_PrimitiveDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_PrimitiveDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_PrimitiveDef_Proxy_Impl &select_proxy ( +- PrimitiveDef *object, ++ IR_PrimitiveDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -13562,117 +8547,39 @@ + static _TAO_PrimitiveDef_Remote_Proxy_Broker *the_TAO_PrimitiveDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimitiveDef; +- +- +-#if !defined (_TAO_IR_STRINGDEF___PTR_CH_) +-#define _TAO_IR_STRINGDEF___PTR_CH_ +- +-class StringDef; +-typedef StringDef *StringDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_STRINGDEF___VAR_CH_) +-#define _TAO_IR_STRINGDEF___VAR_CH_ +- +-class TAO_Export StringDef_var : public TAO_Base_var +-{ +-public: +- StringDef_var (void); // default constructor +- StringDef_var (StringDef_ptr p) : ptr_ (p) {} +- StringDef_var (const StringDef_var &); // copy constructor +- ~StringDef_var (void); // destructor +- +- StringDef_var &operator= (StringDef_ptr); +- StringDef_var &operator= (const StringDef_var &); +- StringDef_ptr operator-> (void) const; +- +- operator const StringDef_ptr &() const; +- operator StringDef_ptr &(); +- // in, inout, out, _retn +- StringDef_ptr in (void) const; +- StringDef_ptr &inout (void); +- StringDef_ptr &out (void); +- StringDef_ptr _retn (void); +- StringDef_ptr ptr (void) const; +- +-private: +- StringDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- StringDef_var (const TAO_Base_var &rhs); +- StringDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_STRINGDEF___OUT_CH_) +-#define _TAO_IR_STRINGDEF___OUT_CH_ +- +-class TAO_Export StringDef_out +-{ +-public: +- StringDef_out (StringDef_ptr &); +- StringDef_out (StringDef_var &); +- StringDef_out (const StringDef_out &); +- StringDef_out &operator= (const StringDef_out &); +- StringDef_out &operator= (const StringDef_var &); +- StringDef_out &operator= (StringDef_ptr); +- operator StringDef_ptr &(); +- StringDef_ptr &ptr (void); +- StringDef_ptr operator-> (void); +- +-private: +- StringDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_STRINGDEF_CH_) +-#define _TAO_IR_STRINGDEF_CH_ +- + // Forward Classes Declaration + class _TAO_StringDef_Proxy_Impl; + class _TAO_StringDef_Remote_Proxy_Impl; + class _TAO_StringDef_Proxy_Broker; + class _TAO_StringDef_Remote_Proxy_Broker; + +-class TAO_Export StringDef: public virtual IDLType ++class TAO_Export IR_StringDef: public virtual IR_IDLType + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef StringDef_ptr _ptr_type; +- typedef StringDef_var _var_type; ++ typedef IR_StringDef_ptr _ptr_type; ++ typedef IR_StringDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static StringDef_ptr _duplicate (StringDef_ptr obj); +- static StringDef_ptr _narrow ( ++ static IR_StringDef_ptr _duplicate (IR_StringDef_ptr obj); ++ static IR_StringDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static StringDef_ptr _unchecked_narrow ( ++ static IR_StringDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static StringDef_ptr _nil (void) ++ static IR_StringDef_ptr _nil (void) + { +- return (StringDef_ptr)0; ++ return (IR_StringDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -13707,121 +8614,27 @@ + _TAO_StringDef_Proxy_Broker *the_TAO_StringDef_Proxy_Broker_; + + protected: +- StringDef (int collocated = 0); ++ IR_StringDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- StringDef ( ++ IR_StringDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_StringDef_Remote_Proxy_Impl; +- friend class _TAO_StringDef_ThruPOA_Proxy_Impl; +- friend class _TAO_StringDef_Direct_Proxy_Impl; +- +- virtual ~StringDef (void); +- private: +- StringDef (const StringDef &); +- void operator= (const StringDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_StringDef_bound_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::StringDef; +- +- friend class _TAO_StringDef_Remote_Proxy_Impl; +- friend class _TAO_StringDef_ThruPOA_Proxy_Impl; +- friend class _TAO_StringDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_StringDef_bound_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_StringDef_bound_get (const TAO_ClientRequestInfo_IR_StringDef_bound_get &); +- void operator= (const TAO_ClientRequestInfo_IR_StringDef_bound_get &); +- void result (CORBA::ULong result); +- // update the result +- CORBA::ULong result_; +- }; +- +- class TAO_ClientRequestInfo_IR_StringDef_bound_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::StringDef; +- +- friend class _TAO_StringDef_Remote_Proxy_Impl; +- friend class _TAO_StringDef_ThruPOA_Proxy_Impl; +- friend class _TAO_StringDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_StringDef_bound_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::ULong & bound, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); ++ ++ friend class _TAO_StringDef_Remote_Proxy_Impl; ++ friend class _TAO_StringDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_StringDef_Direct_Proxy_Impl; + +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_StringDef (void); + private: +- TAO_ClientRequestInfo_IR_StringDef_bound_set (const TAO_ClientRequestInfo_IR_StringDef_bound_set &); +- void operator= (const TAO_ClientRequestInfo_IR_StringDef_bound_set &); +- const CORBA::ULong & bound_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_StringDef (const IR_StringDef &); ++ void operator= (const IR_StringDef &); + }; + + +@@ -13835,12 +8648,12 @@ + // + + class TAO_Export _TAO_StringDef_Proxy_Impl : +- public virtual IR::_TAO_IDLType_Proxy_Impl ++ public virtual _TAO_IDLType_Proxy_Impl + { + public: + virtual ~_TAO_StringDef_Proxy_Impl (void) { } + +- virtual CORBA::ULong bound ( ++ virtual CORBA::ULong bound ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -13861,6 +8674,7 @@ + _TAO_StringDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -13873,7 +8687,7 @@ + class TAO_Export _TAO_StringDef_Remote_Proxy_Impl : + public virtual _TAO_StringDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_IDLType_Remote_Proxy_Impl ++ public virtual _TAO_IDLType_Remote_Proxy_Impl + + { + public: +@@ -13881,7 +8695,7 @@ + + virtual ~_TAO_StringDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::ULong bound ( ++ virtual CORBA::ULong bound ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -13920,8 +8734,9 @@ + { + public: + virtual ~_TAO_StringDef_Proxy_Broker (void); ++ + virtual _TAO_StringDef_Proxy_Impl &select_proxy ( +- StringDef *object, ++ IR_StringDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -13946,9 +8761,9 @@ + _TAO_StringDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_StringDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_StringDef_Proxy_Impl &select_proxy ( +- StringDef *object, ++ IR_StringDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -13962,117 +8777,39 @@ + static _TAO_StringDef_Remote_Proxy_Broker *the_TAO_StringDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StringDef; +- +- +-#if !defined (_TAO_IR_WSTRINGDEF___PTR_CH_) +-#define _TAO_IR_WSTRINGDEF___PTR_CH_ +- +-class WstringDef; +-typedef WstringDef *WstringDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_WSTRINGDEF___VAR_CH_) +-#define _TAO_IR_WSTRINGDEF___VAR_CH_ +- +-class TAO_Export WstringDef_var : public TAO_Base_var +-{ +-public: +- WstringDef_var (void); // default constructor +- WstringDef_var (WstringDef_ptr p) : ptr_ (p) {} +- WstringDef_var (const WstringDef_var &); // copy constructor +- ~WstringDef_var (void); // destructor +- +- WstringDef_var &operator= (WstringDef_ptr); +- WstringDef_var &operator= (const WstringDef_var &); +- WstringDef_ptr operator-> (void) const; +- +- operator const WstringDef_ptr &() const; +- operator WstringDef_ptr &(); +- // in, inout, out, _retn +- WstringDef_ptr in (void) const; +- WstringDef_ptr &inout (void); +- WstringDef_ptr &out (void); +- WstringDef_ptr _retn (void); +- WstringDef_ptr ptr (void) const; +- +-private: +- WstringDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- WstringDef_var (const TAO_Base_var &rhs); +- WstringDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_WSTRINGDEF___OUT_CH_) +-#define _TAO_IR_WSTRINGDEF___OUT_CH_ +- +-class TAO_Export WstringDef_out +-{ +-public: +- WstringDef_out (WstringDef_ptr &); +- WstringDef_out (WstringDef_var &); +- WstringDef_out (const WstringDef_out &); +- WstringDef_out &operator= (const WstringDef_out &); +- WstringDef_out &operator= (const WstringDef_var &); +- WstringDef_out &operator= (WstringDef_ptr); +- operator WstringDef_ptr &(); +- WstringDef_ptr &ptr (void); +- WstringDef_ptr operator-> (void); +- +-private: +- WstringDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_WSTRINGDEF_CH_) +-#define _TAO_IR_WSTRINGDEF_CH_ +- + // Forward Classes Declaration + class _TAO_WstringDef_Proxy_Impl; + class _TAO_WstringDef_Remote_Proxy_Impl; + class _TAO_WstringDef_Proxy_Broker; + class _TAO_WstringDef_Remote_Proxy_Broker; + +-class TAO_Export WstringDef: public virtual IDLType ++class TAO_Export IR_WstringDef: public virtual IR_IDLType + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef WstringDef_ptr _ptr_type; +- typedef WstringDef_var _var_type; ++ typedef IR_WstringDef_ptr _ptr_type; ++ typedef IR_WstringDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static WstringDef_ptr _duplicate (WstringDef_ptr obj); +- static WstringDef_ptr _narrow ( ++ static IR_WstringDef_ptr _duplicate (IR_WstringDef_ptr obj); ++ static IR_WstringDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static WstringDef_ptr _unchecked_narrow ( ++ static IR_WstringDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static WstringDef_ptr _nil (void) ++ static IR_WstringDef_ptr _nil (void) + { +- return (WstringDef_ptr)0; ++ return (IR_WstringDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -14107,142 +8844,48 @@ + _TAO_WstringDef_Proxy_Broker *the_TAO_WstringDef_Proxy_Broker_; + + protected: +- WstringDef (int collocated = 0); ++ IR_WstringDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- WstringDef ( ++ IR_WstringDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); ++ ); + +- friend class _TAO_WstringDef_Remote_Proxy_Impl; +- friend class _TAO_WstringDef_ThruPOA_Proxy_Impl; +- friend class _TAO_WstringDef_Direct_Proxy_Impl; ++ friend class _TAO_WstringDef_Remote_Proxy_Impl; ++ friend class _TAO_WstringDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_WstringDef_Direct_Proxy_Impl; + +- virtual ~WstringDef (void); +- private: +- WstringDef (const WstringDef &); +- void operator= (const WstringDef &); ++ virtual ~IR_WstringDef (void); ++private: ++ IR_WstringDef (const IR_WstringDef &); ++ void operator= (const IR_WstringDef &); ++}; + +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_WstringDef_bound_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::WstringDef; +- +- friend class _TAO_WstringDef_Remote_Proxy_Impl; +- friend class _TAO_WstringDef_ThruPOA_Proxy_Impl; +- friend class _TAO_WstringDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_WstringDef_bound_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_WstringDef_bound_get (const TAO_ClientRequestInfo_IR_WstringDef_bound_get &); +- void operator= (const TAO_ClientRequestInfo_IR_WstringDef_bound_get &); +- void result (CORBA::ULong result); +- // update the result +- CORBA::ULong result_; +- }; +- +- class TAO_ClientRequestInfo_IR_WstringDef_bound_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::WstringDef; +- +- friend class _TAO_WstringDef_Remote_Proxy_Impl; +- friend class _TAO_WstringDef_ThruPOA_Proxy_Impl; +- friend class _TAO_WstringDef_Direct_Proxy_Impl; ++ ++// The Proxy Implementations are used by each interface to ++// perform a call. Each different implementation encapsulate ++// an invocation logics. ++ ++ ++/////////////////////////////////////////////////////////////////////// ++// Base Impl. Declaration ++// ++ ++class TAO_Export _TAO_WstringDef_Proxy_Impl : ++ public virtual _TAO_IDLType_Proxy_Impl ++{ ++public: ++ virtual ~_TAO_WstringDef_Proxy_Impl (void) { } + +- TAO_ClientRequestInfo_IR_WstringDef_bound_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::ULong & bound, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_WstringDef_bound_set (const TAO_ClientRequestInfo_IR_WstringDef_bound_set &); +- void operator= (const TAO_ClientRequestInfo_IR_WstringDef_bound_set &); +- const CORBA::ULong & bound_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- +-}; +- +- +-// The Proxy Implementations are used by each interface to +-// perform a call. Each different implementation encapsulate +-// an invocation logics. +- +- +-/////////////////////////////////////////////////////////////////////// +-// Base Impl. Declaration +-// +- +-class TAO_Export _TAO_WstringDef_Proxy_Impl : +- public virtual IR::_TAO_IDLType_Proxy_Impl +-{ +-public: +- virtual ~_TAO_WstringDef_Proxy_Impl (void) { } +- +- virtual CORBA::ULong bound ( ++ virtual CORBA::ULong bound ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException +@@ -14261,6 +8904,7 @@ + _TAO_WstringDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -14273,7 +8917,7 @@ + class TAO_Export _TAO_WstringDef_Remote_Proxy_Impl : + public virtual _TAO_WstringDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_IDLType_Remote_Proxy_Impl ++ public virtual _TAO_IDLType_Remote_Proxy_Impl + + { + public: +@@ -14281,7 +8925,7 @@ + + virtual ~_TAO_WstringDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::ULong bound ( ++ virtual CORBA::ULong bound ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -14320,8 +8964,9 @@ + { + public: + virtual ~_TAO_WstringDef_Proxy_Broker (void); ++ + virtual _TAO_WstringDef_Proxy_Impl &select_proxy ( +- WstringDef *object, ++ IR_WstringDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -14346,9 +8991,9 @@ + _TAO_WstringDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_WstringDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_WstringDef_Proxy_Impl &select_proxy ( +- WstringDef *object, ++ IR_WstringDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -14362,123 +9007,45 @@ + static _TAO_WstringDef_Remote_Proxy_Broker *the_TAO_WstringDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_WstringDef; +- +- +-#if !defined (_TAO_IR_FIXEDDEF___PTR_CH_) +-#define _TAO_IR_FIXEDDEF___PTR_CH_ +- +-class FixedDef; +-typedef FixedDef *FixedDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FIXEDDEF___VAR_CH_) +-#define _TAO_IR_FIXEDDEF___VAR_CH_ +- +-class TAO_Export FixedDef_var : public TAO_Base_var +-{ +-public: +- FixedDef_var (void); // default constructor +- FixedDef_var (FixedDef_ptr p) : ptr_ (p) {} +- FixedDef_var (const FixedDef_var &); // copy constructor +- ~FixedDef_var (void); // destructor +- +- FixedDef_var &operator= (FixedDef_ptr); +- FixedDef_var &operator= (const FixedDef_var &); +- FixedDef_ptr operator-> (void) const; +- +- operator const FixedDef_ptr &() const; +- operator FixedDef_ptr &(); +- // in, inout, out, _retn +- FixedDef_ptr in (void) const; +- FixedDef_ptr &inout (void); +- FixedDef_ptr &out (void); +- FixedDef_ptr _retn (void); +- FixedDef_ptr ptr (void) const; +- +-private: +- FixedDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- FixedDef_var (const TAO_Base_var &rhs); +- FixedDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FIXEDDEF___OUT_CH_) +-#define _TAO_IR_FIXEDDEF___OUT_CH_ +- +-class TAO_Export FixedDef_out +-{ +-public: +- FixedDef_out (FixedDef_ptr &); +- FixedDef_out (FixedDef_var &); +- FixedDef_out (const FixedDef_out &); +- FixedDef_out &operator= (const FixedDef_out &); +- FixedDef_out &operator= (const FixedDef_var &); +- FixedDef_out &operator= (FixedDef_ptr); +- operator FixedDef_ptr &(); +- FixedDef_ptr &ptr (void); +- FixedDef_ptr operator-> (void); +- +-private: +- FixedDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FIXEDDEF_CH_) +-#define _TAO_IR_FIXEDDEF_CH_ +- + // Forward Classes Declaration + class _TAO_FixedDef_Proxy_Impl; + class _TAO_FixedDef_Remote_Proxy_Impl; + class _TAO_FixedDef_Proxy_Broker; + class _TAO_FixedDef_Remote_Proxy_Broker; + +-class TAO_Export FixedDef: public virtual IDLType ++class TAO_Export IR_FixedDef: public virtual IR_IDLType + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef FixedDef_ptr _ptr_type; +- typedef FixedDef_var _var_type; ++ typedef IR_FixedDef_ptr _ptr_type; ++ typedef IR_FixedDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static FixedDef_ptr _duplicate (FixedDef_ptr obj); +- static FixedDef_ptr _narrow ( ++ static IR_FixedDef_ptr _duplicate (IR_FixedDef_ptr obj); ++ static IR_FixedDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static FixedDef_ptr _unchecked_narrow ( ++ static IR_FixedDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static FixedDef_ptr _nil (void) ++ static IR_FixedDef_ptr _nil (void) + { +- return (FixedDef_ptr)0; ++ return (IR_FixedDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual CORBA::UShort digits ( +- CORBA::Environment &ACE_TRY_ENV = ++ virtual CORBA::UShort digits ( ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -14524,207 +9091,27 @@ + _TAO_FixedDef_Proxy_Broker *the_TAO_FixedDef_Proxy_Broker_; + + protected: +- FixedDef (int collocated = 0); ++ IR_FixedDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- FixedDef ( ++ IR_FixedDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_FixedDef_Remote_Proxy_Impl; +- friend class _TAO_FixedDef_ThruPOA_Proxy_Impl; +- friend class _TAO_FixedDef_Direct_Proxy_Impl; +- +- virtual ~FixedDef (void); +- private: +- FixedDef (const FixedDef &); +- void operator= (const FixedDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_FixedDef_digits_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::FixedDef; +- +- friend class _TAO_FixedDef_Remote_Proxy_Impl; +- friend class _TAO_FixedDef_ThruPOA_Proxy_Impl; +- friend class _TAO_FixedDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_FixedDef_digits_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_FixedDef_digits_get (const TAO_ClientRequestInfo_IR_FixedDef_digits_get &); +- void operator= (const TAO_ClientRequestInfo_IR_FixedDef_digits_get &); +- void result (CORBA::UShort result); +- // update the result +- CORBA::UShort result_; +- }; +- +- class TAO_ClientRequestInfo_IR_FixedDef_digits_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::FixedDef; +- +- friend class _TAO_FixedDef_Remote_Proxy_Impl; +- friend class _TAO_FixedDef_ThruPOA_Proxy_Impl; +- friend class _TAO_FixedDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_FixedDef_digits_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::UShort & digits, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_FixedDef_digits_set (const TAO_ClientRequestInfo_IR_FixedDef_digits_set &); +- void operator= (const TAO_ClientRequestInfo_IR_FixedDef_digits_set &); +- const CORBA::UShort & digits_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_FixedDef_scale_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::FixedDef; +- ++ + friend class _TAO_FixedDef_Remote_Proxy_Impl; + friend class _TAO_FixedDef_ThruPOA_Proxy_Impl; + friend class _TAO_FixedDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_FixedDef_scale_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_FixedDef_scale_get (const TAO_ClientRequestInfo_IR_FixedDef_scale_get &); +- void operator= (const TAO_ClientRequestInfo_IR_FixedDef_scale_get &); +- void result (CORBA::Short result); +- // update the result +- CORBA::Short result_; +-}; +- +-class TAO_ClientRequestInfo_IR_FixedDef_scale_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::FixedDef; + +- friend class _TAO_FixedDef_Remote_Proxy_Impl; +- friend class _TAO_FixedDef_ThruPOA_Proxy_Impl; +- friend class _TAO_FixedDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_FixedDef_scale_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::Short & scale, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_FixedDef (void); + private: +- TAO_ClientRequestInfo_IR_FixedDef_scale_set (const TAO_ClientRequestInfo_IR_FixedDef_scale_set &); +- void operator= (const TAO_ClientRequestInfo_IR_FixedDef_scale_set &); +- const CORBA::Short & scale_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_FixedDef (const IR_FixedDef &); ++ void operator= (const IR_FixedDef &); + }; + + +@@ -14738,12 +9125,12 @@ + // + + class TAO_Export _TAO_FixedDef_Proxy_Impl : +- public virtual IR::_TAO_IDLType_Proxy_Impl ++ public virtual _TAO_IDLType_Proxy_Impl + { + public: + virtual ~_TAO_FixedDef_Proxy_Impl (void) { } + +- virtual CORBA::UShort digits ( ++ virtual CORBA::UShort digits ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -14781,6 +9168,7 @@ + _TAO_FixedDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -14793,7 +9181,7 @@ + class TAO_Export _TAO_FixedDef_Remote_Proxy_Impl : + public virtual _TAO_FixedDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_IDLType_Remote_Proxy_Impl ++ public virtual _TAO_IDLType_Remote_Proxy_Impl + + { + public: +@@ -14801,7 +9189,7 @@ + + virtual ~_TAO_FixedDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::UShort digits ( ++ virtual CORBA::UShort digits ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -14857,8 +9245,9 @@ + { + public: + virtual ~_TAO_FixedDef_Proxy_Broker (void); ++ + virtual _TAO_FixedDef_Proxy_Impl &select_proxy ( +- FixedDef *object, ++ IR_FixedDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -14883,9 +9272,9 @@ + _TAO_FixedDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_FixedDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_FixedDef_Proxy_Impl &select_proxy ( +- FixedDef *object, ++ IR_FixedDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -14899,117 +9288,39 @@ + static _TAO_FixedDef_Remote_Proxy_Broker *the_TAO_FixedDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FixedDef; +- +- +-#if !defined (_TAO_IR_SEQUENCEDEF___PTR_CH_) +-#define _TAO_IR_SEQUENCEDEF___PTR_CH_ +- +-class SequenceDef; +-typedef SequenceDef *SequenceDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_SEQUENCEDEF___VAR_CH_) +-#define _TAO_IR_SEQUENCEDEF___VAR_CH_ +- +-class TAO_Export SequenceDef_var : public TAO_Base_var +-{ +-public: +- SequenceDef_var (void); // default constructor +- SequenceDef_var (SequenceDef_ptr p) : ptr_ (p) {} +- SequenceDef_var (const SequenceDef_var &); // copy constructor +- ~SequenceDef_var (void); // destructor +- +- SequenceDef_var &operator= (SequenceDef_ptr); +- SequenceDef_var &operator= (const SequenceDef_var &); +- SequenceDef_ptr operator-> (void) const; +- +- operator const SequenceDef_ptr &() const; +- operator SequenceDef_ptr &(); +- // in, inout, out, _retn +- SequenceDef_ptr in (void) const; +- SequenceDef_ptr &inout (void); +- SequenceDef_ptr &out (void); +- SequenceDef_ptr _retn (void); +- SequenceDef_ptr ptr (void) const; +- +-private: +- SequenceDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- SequenceDef_var (const TAO_Base_var &rhs); +- SequenceDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_SEQUENCEDEF___OUT_CH_) +-#define _TAO_IR_SEQUENCEDEF___OUT_CH_ +- +-class TAO_Export SequenceDef_out +-{ +-public: +- SequenceDef_out (SequenceDef_ptr &); +- SequenceDef_out (SequenceDef_var &); +- SequenceDef_out (const SequenceDef_out &); +- SequenceDef_out &operator= (const SequenceDef_out &); +- SequenceDef_out &operator= (const SequenceDef_var &); +- SequenceDef_out &operator= (SequenceDef_ptr); +- operator SequenceDef_ptr &(); +- SequenceDef_ptr &ptr (void); +- SequenceDef_ptr operator-> (void); +- +-private: +- SequenceDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_SEQUENCEDEF_CH_) +-#define _TAO_IR_SEQUENCEDEF_CH_ +- + // Forward Classes Declaration + class _TAO_SequenceDef_Proxy_Impl; + class _TAO_SequenceDef_Remote_Proxy_Impl; + class _TAO_SequenceDef_Proxy_Broker; + class _TAO_SequenceDef_Remote_Proxy_Broker; + +-class TAO_Export SequenceDef: public virtual IDLType ++class TAO_Export IR_SequenceDef: public virtual IR_IDLType + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef SequenceDef_ptr _ptr_type; +- typedef SequenceDef_var _var_type; ++ typedef IR_SequenceDef_ptr _ptr_type; ++ typedef IR_SequenceDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static SequenceDef_ptr _duplicate (SequenceDef_ptr obj); +- static SequenceDef_ptr _narrow ( ++ static IR_SequenceDef_ptr _duplicate (IR_SequenceDef_ptr obj); ++ static IR_SequenceDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static SequenceDef_ptr _unchecked_narrow ( ++ static IR_SequenceDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static SequenceDef_ptr _nil (void) ++ static IR_SequenceDef_ptr _nil (void) + { +- return (SequenceDef_ptr)0; ++ return (IR_SequenceDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -15039,7 +9350,7 @@ + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr element_type_def ( ++ virtual IR_IDLType_ptr element_type_def ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -15048,7 +9359,7 @@ + )); + + virtual void element_type_def ( +- IR::IDLType_ptr element_type_def, ++ IR_IDLType_ptr element_type_def, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -15069,269 +9380,46 @@ + _TAO_SequenceDef_Proxy_Broker *the_TAO_SequenceDef_Proxy_Broker_; + + protected: +- SequenceDef (int collocated = 0); ++ IR_SequenceDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- SequenceDef ( ++ IR_SequenceDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); ++ ); + +- friend class _TAO_SequenceDef_Remote_Proxy_Impl; +- friend class _TAO_SequenceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_SequenceDef_Direct_Proxy_Impl; ++ friend class _TAO_SequenceDef_Remote_Proxy_Impl; ++ friend class _TAO_SequenceDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_SequenceDef_Direct_Proxy_Impl; + +- virtual ~SequenceDef (void); +- private: +- SequenceDef (const SequenceDef &); +- void operator= (const SequenceDef &); ++ virtual ~IR_SequenceDef (void); ++private: ++ IR_SequenceDef (const IR_SequenceDef &); ++ void operator= (const IR_SequenceDef &); ++}; + +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_SequenceDef_bound_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::SequenceDef; +- +- friend class _TAO_SequenceDef_Remote_Proxy_Impl; +- friend class _TAO_SequenceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_SequenceDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_SequenceDef_bound_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_SequenceDef_bound_get (const TAO_ClientRequestInfo_IR_SequenceDef_bound_get &); +- void operator= (const TAO_ClientRequestInfo_IR_SequenceDef_bound_get &); +- void result (CORBA::ULong result); +- // update the result +- CORBA::ULong result_; +- }; +- +- class TAO_ClientRequestInfo_IR_SequenceDef_bound_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::SequenceDef; +- +- friend class _TAO_SequenceDef_Remote_Proxy_Impl; +- friend class _TAO_SequenceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_SequenceDef_Direct_Proxy_Impl; ++ ++// The Proxy Implementations are used by each interface to ++// perform a call. Each different implementation encapsulate ++// an invocation logics. ++ ++ ++/////////////////////////////////////////////////////////////////////// ++// Base Impl. Declaration ++// ++ ++class TAO_Export _TAO_SequenceDef_Proxy_Impl : ++ public virtual _TAO_IDLType_Proxy_Impl ++{ ++public: ++ virtual ~_TAO_SequenceDef_Proxy_Impl (void) { } + +- TAO_ClientRequestInfo_IR_SequenceDef_bound_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::ULong & bound, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_SequenceDef_bound_set (const TAO_ClientRequestInfo_IR_SequenceDef_bound_set &); +- void operator= (const TAO_ClientRequestInfo_IR_SequenceDef_bound_set &); +- const CORBA::ULong & bound_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_SequenceDef_element_type_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::SequenceDef; +- +- friend class _TAO_SequenceDef_Remote_Proxy_Impl; +- friend class _TAO_SequenceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_SequenceDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_SequenceDef_element_type_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_SequenceDef_element_type_get (const TAO_ClientRequestInfo_IR_SequenceDef_element_type_get &); +- void operator= (const TAO_ClientRequestInfo_IR_SequenceDef_element_type_get &); +- void result (CORBA::TypeCode_ptr result); +- // update the result +- CORBA::TypeCode_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::SequenceDef; +- +- friend class _TAO_SequenceDef_Remote_Proxy_Impl; +- friend class _TAO_SequenceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_SequenceDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_get (const TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_get &); +- void operator= (const TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_get &); +- void result (IR::IDLType_ptr result); +- // update the result +- IR::IDLType_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::SequenceDef; +- +- friend class _TAO_SequenceDef_Remote_Proxy_Impl; +- friend class _TAO_SequenceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_SequenceDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::IDLType_ptr element_type_def, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_set (const TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_set &); +- void operator= (const TAO_ClientRequestInfo_IR_SequenceDef_element_type_def_set &); +- IR::IDLType_ptr element_type_def_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- +-}; +- +- +-// The Proxy Implementations are used by each interface to +-// perform a call. Each different implementation encapsulate +-// an invocation logics. +- +- +-/////////////////////////////////////////////////////////////////////// +-// Base Impl. Declaration +-// +- +-class TAO_Export _TAO_SequenceDef_Proxy_Impl : +- public virtual IR::_TAO_IDLType_Proxy_Impl +-{ +-public: +- virtual ~_TAO_SequenceDef_Proxy_Impl (void) { } +- +- virtual CORBA::ULong bound ( ++ virtual CORBA::ULong bound ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -15356,7 +9444,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::IDLType_ptr element_type_def ( ++ virtual IR_IDLType_ptr element_type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -15364,9 +9452,9 @@ + CORBA::SystemException + )) = 0; + +- virtual void element_type_def ( ++ virtual void element_type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr element_type_def, ++ IR_IDLType_ptr element_type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -15377,6 +9465,8 @@ + _TAO_SequenceDef_Proxy_Impl (void); + + }; ++ ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -15389,7 +9479,7 @@ + class TAO_Export _TAO_SequenceDef_Remote_Proxy_Impl : + public virtual _TAO_SequenceDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_IDLType_Remote_Proxy_Impl ++ public virtual _TAO_IDLType_Remote_Proxy_Impl + + { + public: +@@ -15397,7 +9487,7 @@ + + virtual ~_TAO_SequenceDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::ULong bound ( ++ virtual CORBA::ULong bound ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -15414,7 +9504,7 @@ + CORBA::SystemException + )); + +- virtual CORBA::TypeCode_ptr element_type ( ++ virtual CORBA::TypeCode_ptr element_type( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -15422,7 +9512,7 @@ + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr element_type_def ( ++ virtual IR_IDLType_ptr element_type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -15432,7 +9522,7 @@ + + virtual void element_type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr element_type_def, ++ IR_IDLType_ptr element_type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -15461,8 +9551,9 @@ + { + public: + virtual ~_TAO_SequenceDef_Proxy_Broker (void); ++ + virtual _TAO_SequenceDef_Proxy_Impl &select_proxy ( +- SequenceDef *object, ++ IR_SequenceDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -15487,9 +9578,9 @@ + _TAO_SequenceDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_SequenceDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_SequenceDef_Proxy_Impl &select_proxy ( +- SequenceDef *object, ++ IR_SequenceDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -15503,117 +9594,39 @@ + static _TAO_SequenceDef_Remote_Proxy_Broker *the_TAO_SequenceDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_SequenceDef; +- +- +-#if !defined (_TAO_IR_ARRAYDEF___PTR_CH_) +-#define _TAO_IR_ARRAYDEF___PTR_CH_ +- +-class ArrayDef; +-typedef ArrayDef *ArrayDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ARRAYDEF___VAR_CH_) +-#define _TAO_IR_ARRAYDEF___VAR_CH_ +- +-class TAO_Export ArrayDef_var : public TAO_Base_var +-{ +-public: +- ArrayDef_var (void); // default constructor +- ArrayDef_var (ArrayDef_ptr p) : ptr_ (p) {} +- ArrayDef_var (const ArrayDef_var &); // copy constructor +- ~ArrayDef_var (void); // destructor +- +- ArrayDef_var &operator= (ArrayDef_ptr); +- ArrayDef_var &operator= (const ArrayDef_var &); +- ArrayDef_ptr operator-> (void) const; +- +- operator const ArrayDef_ptr &() const; +- operator ArrayDef_ptr &(); +- // in, inout, out, _retn +- ArrayDef_ptr in (void) const; +- ArrayDef_ptr &inout (void); +- ArrayDef_ptr &out (void); +- ArrayDef_ptr _retn (void); +- ArrayDef_ptr ptr (void) const; +- +-private: +- ArrayDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- ArrayDef_var (const TAO_Base_var &rhs); +- ArrayDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ARRAYDEF___OUT_CH_) +-#define _TAO_IR_ARRAYDEF___OUT_CH_ +- +-class TAO_Export ArrayDef_out +-{ +-public: +- ArrayDef_out (ArrayDef_ptr &); +- ArrayDef_out (ArrayDef_var &); +- ArrayDef_out (const ArrayDef_out &); +- ArrayDef_out &operator= (const ArrayDef_out &); +- ArrayDef_out &operator= (const ArrayDef_var &); +- ArrayDef_out &operator= (ArrayDef_ptr); +- operator ArrayDef_ptr &(); +- ArrayDef_ptr &ptr (void); +- ArrayDef_ptr operator-> (void); +- +-private: +- ArrayDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ARRAYDEF_CH_) +-#define _TAO_IR_ARRAYDEF_CH_ +- + // Forward Classes Declaration + class _TAO_ArrayDef_Proxy_Impl; + class _TAO_ArrayDef_Remote_Proxy_Impl; + class _TAO_ArrayDef_Proxy_Broker; + class _TAO_ArrayDef_Remote_Proxy_Broker; + +-class TAO_Export ArrayDef: public virtual IDLType ++class TAO_Export IR_ArrayDef: public virtual IR_IDLType + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ArrayDef_ptr _ptr_type; +- typedef ArrayDef_var _var_type; ++ typedef IR_ArrayDef_ptr _ptr_type; ++ typedef IR_ArrayDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static ArrayDef_ptr _duplicate (ArrayDef_ptr obj); +- static ArrayDef_ptr _narrow ( ++ static IR_ArrayDef_ptr _duplicate (IR_ArrayDef_ptr obj); ++ static IR_ArrayDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ArrayDef_ptr _unchecked_narrow ( ++ static IR_ArrayDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ArrayDef_ptr _nil (void) ++ static IR_ArrayDef_ptr _nil (void) + { +- return (ArrayDef_ptr)0; ++ return (IR_ArrayDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -15643,7 +9656,7 @@ + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr element_type_def ( ++ virtual IR_IDLType_ptr element_type_def ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -15652,7 +9665,7 @@ + )); + + virtual void element_type_def ( +- IR::IDLType_ptr element_type_def, ++ IR_IDLType_ptr element_type_def, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -15673,250 +9686,27 @@ + _TAO_ArrayDef_Proxy_Broker *the_TAO_ArrayDef_Proxy_Broker_; + + protected: +- ArrayDef (int collocated = 0); ++ IR_ArrayDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- ArrayDef ( ++ IR_ArrayDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_ArrayDef_Remote_Proxy_Impl; +- friend class _TAO_ArrayDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ArrayDef_Direct_Proxy_Impl; +- +- virtual ~ArrayDef (void); +- private: +- ArrayDef (const ArrayDef &); +- void operator= (const ArrayDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_ArrayDef_length_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ArrayDef; +- +- friend class _TAO_ArrayDef_Remote_Proxy_Impl; +- friend class _TAO_ArrayDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ArrayDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ArrayDef_length_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_ArrayDef_length_get (const TAO_ClientRequestInfo_IR_ArrayDef_length_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ArrayDef_length_get &); +- void result (CORBA::ULong result); +- // update the result +- CORBA::ULong result_; +- }; +- +- class TAO_ClientRequestInfo_IR_ArrayDef_length_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ArrayDef; +- +- friend class _TAO_ArrayDef_Remote_Proxy_Impl; +- friend class _TAO_ArrayDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ArrayDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ArrayDef_length_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::ULong & length, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ArrayDef_length_set (const TAO_ClientRequestInfo_IR_ArrayDef_length_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ArrayDef_length_set &); +- const CORBA::ULong & length_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_ArrayDef_element_type_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ArrayDef; +- +- friend class _TAO_ArrayDef_Remote_Proxy_Impl; +- friend class _TAO_ArrayDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ArrayDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ArrayDef_element_type_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ArrayDef_element_type_get (const TAO_ClientRequestInfo_IR_ArrayDef_element_type_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ArrayDef_element_type_get &); +- void result (CORBA::TypeCode_ptr result); +- // update the result +- CORBA::TypeCode_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ArrayDef; +- ++ + friend class _TAO_ArrayDef_Remote_Proxy_Impl; + friend class _TAO_ArrayDef_ThruPOA_Proxy_Impl; + friend class _TAO_ArrayDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_get (const TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_get &); +- void result (IR::IDLType_ptr result); +- // update the result +- IR::IDLType_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ArrayDef; + +- friend class _TAO_ArrayDef_Remote_Proxy_Impl; +- friend class _TAO_ArrayDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ArrayDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::IDLType_ptr element_type_def, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_ArrayDef (void); + private: +- TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_set (const TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ArrayDef_element_type_def_set &); +- IR::IDLType_ptr element_type_def_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_ArrayDef (const IR_ArrayDef &); ++ void operator= (const IR_ArrayDef &); + }; + + +@@ -15930,12 +9720,12 @@ + // + + class TAO_Export _TAO_ArrayDef_Proxy_Impl : +- public virtual IR::_TAO_IDLType_Proxy_Impl ++ public virtual _TAO_IDLType_Proxy_Impl + { + public: + virtual ~_TAO_ArrayDef_Proxy_Impl (void) { } + +- virtual CORBA::ULong length ( ++ virtual CORBA::ULong length ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -15960,9 +9750,9 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::IDLType_ptr element_type_def ( ++ virtual IR_IDLType_ptr element_type_def ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException +@@ -15970,7 +9760,7 @@ + + virtual void element_type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr element_type_def, ++ IR_IDLType_ptr element_type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -15981,6 +9771,7 @@ + _TAO_ArrayDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -15993,7 +9784,7 @@ + class TAO_Export _TAO_ArrayDef_Remote_Proxy_Impl : + public virtual _TAO_ArrayDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_IDLType_Remote_Proxy_Impl ++ public virtual _TAO_IDLType_Remote_Proxy_Impl + + { + public: +@@ -16001,7 +9792,7 @@ + + virtual ~_TAO_ArrayDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::ULong length ( ++ virtual CORBA::ULong length ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -16018,25 +9809,25 @@ + CORBA::SystemException + )); + +- virtual CORBA::TypeCode_ptr element_type ( ++ virtual CORBA::TypeCode_ptr element_type ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr element_type_def ( ++ virtual IR_IDLType_ptr element_type_def ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual void element_type_def ( ++ virtual void element_type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr element_type_def, ++ IR_IDLType_ptr element_type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -16065,8 +9856,9 @@ + { + public: + virtual ~_TAO_ArrayDef_Proxy_Broker (void); ++ + virtual _TAO_ArrayDef_Proxy_Impl &select_proxy ( +- ArrayDef *object, ++ IR_ArrayDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -16091,9 +9883,9 @@ + _TAO_ArrayDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_ArrayDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_ArrayDef_Proxy_Impl &select_proxy ( +- ArrayDef *object, ++ IR_ArrayDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -16107,117 +9899,41 @@ + static _TAO_ArrayDef_Remote_Proxy_Broker *the_TAO_ArrayDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + ++// Forward Classes Declaration ++class _TAO_ExceptionDef_Proxy_Impl; ++class _TAO_ExceptionDef_Remote_Proxy_Impl; ++class _TAO_ExceptionDef_Proxy_Broker; ++class _TAO_ExceptionDef_Remote_Proxy_Broker; + +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ArrayDef; +- +- +-#if !defined (_TAO_IR_EXCEPTIONDEF___PTR_CH_) +-#define _TAO_IR_EXCEPTIONDEF___PTR_CH_ +- +-class ExceptionDef; +-typedef ExceptionDef *ExceptionDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EXCEPTIONDEF___VAR_CH_) +-#define _TAO_IR_EXCEPTIONDEF___VAR_CH_ +- +-class TAO_Export ExceptionDef_var : public TAO_Base_var ++class TAO_Export IR_ExceptionDef ++ : public virtual IR_Contained, ++ public virtual IR_Container + { + public: +- ExceptionDef_var (void); // default constructor +- ExceptionDef_var (ExceptionDef_ptr p) : ptr_ (p) {} +- ExceptionDef_var (const ExceptionDef_var &); // copy constructor +- ~ExceptionDef_var (void); // destructor +- +- ExceptionDef_var &operator= (ExceptionDef_ptr); +- ExceptionDef_var &operator= (const ExceptionDef_var &); +- ExceptionDef_ptr operator-> (void) const; +- +- operator const ExceptionDef_ptr &() const; +- operator ExceptionDef_ptr &(); +- // in, inout, out, _retn +- ExceptionDef_ptr in (void) const; +- ExceptionDef_ptr &inout (void); +- ExceptionDef_ptr &out (void); +- ExceptionDef_ptr _retn (void); +- ExceptionDef_ptr ptr (void) const; +- +-private: +- ExceptionDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- ExceptionDef_var (const TAO_Base_var &rhs); +- ExceptionDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EXCEPTIONDEF___OUT_CH_) +-#define _TAO_IR_EXCEPTIONDEF___OUT_CH_ +- +-class TAO_Export ExceptionDef_out +-{ +-public: +- ExceptionDef_out (ExceptionDef_ptr &); +- ExceptionDef_out (ExceptionDef_var &); +- ExceptionDef_out (const ExceptionDef_out &); +- ExceptionDef_out &operator= (const ExceptionDef_out &); +- ExceptionDef_out &operator= (const ExceptionDef_var &); +- ExceptionDef_out &operator= (ExceptionDef_ptr); +- operator ExceptionDef_ptr &(); +- ExceptionDef_ptr &ptr (void); +- ExceptionDef_ptr operator-> (void); +- +-private: +- ExceptionDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EXCEPTIONDEF_CH_) +-#define _TAO_IR_EXCEPTIONDEF_CH_ +- +-// Forward Classes Declaration +-class _TAO_ExceptionDef_Proxy_Impl; +-class _TAO_ExceptionDef_Remote_Proxy_Impl; +-class _TAO_ExceptionDef_Proxy_Broker; +-class _TAO_ExceptionDef_Remote_Proxy_Broker; +- +-class TAO_Export ExceptionDef: public virtual Contained, public virtual Container +-{ +-public: +-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ExceptionDef_ptr _ptr_type; +- typedef ExceptionDef_var _var_type; +-#endif /* ! __GNUC__ || g++ >= 2.8 */ ++#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) ++ typedef IR_ExceptionDef_ptr _ptr_type; ++ typedef IR_ExceptionDef_var _var_type; ++#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static ExceptionDef_ptr _duplicate (ExceptionDef_ptr obj); +- static ExceptionDef_ptr _narrow ( ++ static IR_ExceptionDef_ptr _duplicate (IR_ExceptionDef_ptr obj); ++ static IR_ExceptionDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ExceptionDef_ptr _unchecked_narrow ( ++ static IR_ExceptionDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ExceptionDef_ptr _nil (void) ++ static IR_ExceptionDef_ptr _nil (void) + { +- return (ExceptionDef_ptr)0; ++ return (IR_ExceptionDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -16230,7 +9946,7 @@ + CORBA::SystemException + )); + +- virtual IR::StructMemberSeq * members ( ++ virtual IR_StructMemberSeq * members ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -16239,7 +9955,7 @@ + )); + + virtual void members ( +- const IR::StructMemberSeq & members, ++ const IR_StructMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -16260,164 +9976,27 @@ + _TAO_ExceptionDef_Proxy_Broker *the_TAO_ExceptionDef_Proxy_Broker_; + + protected: +- ExceptionDef (int collocated = 0); ++ IR_ExceptionDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- ExceptionDef ( ++ IR_ExceptionDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_ExceptionDef_Remote_Proxy_Impl; +- friend class _TAO_ExceptionDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ExceptionDef_Direct_Proxy_Impl; +- +- virtual ~ExceptionDef (void); +- private: +- ExceptionDef (const ExceptionDef &); +- void operator= (const ExceptionDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_ExceptionDef_type_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ExceptionDef; +- +- friend class _TAO_ExceptionDef_Remote_Proxy_Impl; +- friend class _TAO_ExceptionDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ExceptionDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ExceptionDef_type_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_ExceptionDef_type_get (const TAO_ClientRequestInfo_IR_ExceptionDef_type_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ExceptionDef_type_get &); +- void result (CORBA::TypeCode_ptr result); +- // update the result +- CORBA::TypeCode_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_ExceptionDef_members_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ExceptionDef; +- +- friend class _TAO_ExceptionDef_Remote_Proxy_Impl; +- friend class _TAO_ExceptionDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ExceptionDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ExceptionDef_members_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ExceptionDef_members_get (const TAO_ClientRequestInfo_IR_ExceptionDef_members_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ExceptionDef_members_get &); +- void result (IR::StructMemberSeq * result); +- // update the result +- IR::StructMemberSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ExceptionDef_members_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ExceptionDef; +- ++ + friend class _TAO_ExceptionDef_Remote_Proxy_Impl; + friend class _TAO_ExceptionDef_ThruPOA_Proxy_Impl; + friend class _TAO_ExceptionDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ExceptionDef_members_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const IR::StructMemberSeq & members, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ExceptionDef_members_set (const TAO_ClientRequestInfo_IR_ExceptionDef_members_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ExceptionDef_members_set &); +- const IR::StructMemberSeq & members_; + +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ virtual ~IR_ExceptionDef (void); ++private: ++ IR_ExceptionDef (const IR_ExceptionDef &); ++ void operator= (const IR_ExceptionDef &); + }; + + +@@ -16431,13 +10010,13 @@ + // + + class TAO_Export _TAO_ExceptionDef_Proxy_Impl : +- public virtual IR::_TAO_Contained_Proxy_Impl, +- public virtual IR::_TAO_Container_Proxy_Impl ++ public virtual _TAO_Contained_Proxy_Impl, ++ public virtual _TAO_Container_Proxy_Impl + { + public: + virtual ~_TAO_ExceptionDef_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr type ( ++ virtual CORBA::TypeCode_ptr type ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -16445,17 +10024,17 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::StructMemberSeq * members ( ++ virtual IR_StructMemberSeq * members ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual void members ( ++ virtual void members ( + CORBA_Object *_collocated_tao_target_, +- const IR::StructMemberSeq & members, ++ const IR_StructMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -16466,6 +10045,7 @@ + _TAO_ExceptionDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -16478,8 +10058,8 @@ + class TAO_Export _TAO_ExceptionDef_Remote_Proxy_Impl : + public virtual _TAO_ExceptionDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl, +- public virtual IR::_TAO_Container_Remote_Proxy_Impl ++ public virtual _TAO_Contained_Remote_Proxy_Impl, ++ public virtual _TAO_Container_Remote_Proxy_Impl + + { + public: +@@ -16487,7 +10067,7 @@ + + virtual ~_TAO_ExceptionDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr type ( ++ virtual CORBA::TypeCode_ptr type ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -16495,7 +10075,7 @@ + CORBA::SystemException + )); + +- virtual IR::StructMemberSeq * members ( ++ virtual IR_StructMemberSeq * members ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -16505,7 +10085,7 @@ + + virtual void members ( + CORBA_Object *_collocated_tao_target_, +- const IR::StructMemberSeq & members, ++ const IR_StructMemberSeq & members, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -16534,8 +10114,9 @@ + { + public: + virtual ~_TAO_ExceptionDef_Proxy_Broker (void); ++ + virtual _TAO_ExceptionDef_Proxy_Impl &select_proxy ( +- ExceptionDef *object, ++ IR_ExceptionDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -16560,9 +10141,9 @@ + _TAO_ExceptionDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_ExceptionDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_ExceptionDef_Proxy_Impl &select_proxy ( +- ExceptionDef *object, ++ IR_ExceptionDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -16576,24 +10157,15 @@ + static _TAO_ExceptionDef_Remote_Proxy_Broker *the_TAO_ExceptionDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDef; +- +-struct ExceptionDescription; +-class ExceptionDescription_var; +- +-struct TAO_Export ExceptionDescription ++struct TAO_Export IR_ExceptionDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ExceptionDescription_var _var_type; ++ typedef IR_ExceptionDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -16605,61 +10177,55 @@ + CORBA::TypeCode_var type; + }; + +-class TAO_Export ExceptionDescription_var ++class TAO_Export IR_ExceptionDescription_var + { + public: +- ExceptionDescription_var (void); // default constructor +- ExceptionDescription_var (ExceptionDescription *); +- ExceptionDescription_var (const ExceptionDescription_var &); // copy constructor +- ~ExceptionDescription_var (void); // destructor +- +- ExceptionDescription_var &operator= (ExceptionDescription *); +- ExceptionDescription_var &operator= (const ExceptionDescription_var &); +- ExceptionDescription *operator-> (void); +- const ExceptionDescription *operator-> (void) const; +- +- operator const ExceptionDescription &() const; +- operator ExceptionDescription &(); +- operator ExceptionDescription &() const; +- operator ExceptionDescription *&(); // variable-size types only ++ IR_ExceptionDescription_var (void); // default constructor ++ IR_ExceptionDescription_var (IR_ExceptionDescription *); ++ IR_ExceptionDescription_var (const IR_ExceptionDescription_var &); // copy constructor ++ ~IR_ExceptionDescription_var (void); // destructor ++ ++ IR_ExceptionDescription_var &operator= (IR_ExceptionDescription *); ++ IR_ExceptionDescription_var &operator= (const IR_ExceptionDescription_var &); ++ IR_ExceptionDescription *operator-> (void); ++ const IR_ExceptionDescription *operator-> (void) const; ++ ++ operator const IR_ExceptionDescription &() const; ++ operator IR_ExceptionDescription &(); ++ operator IR_ExceptionDescription &() const; ++ operator IR_ExceptionDescription *&(); // variable-size types only + + // in, inout, out, _retn +- const ExceptionDescription &in (void) const; +- ExceptionDescription &inout (void); +- ExceptionDescription *&out (void); +- ExceptionDescription *_retn (void); +- ExceptionDescription *ptr (void) const; ++ const IR_ExceptionDescription &in (void) const; ++ IR_ExceptionDescription &inout (void); ++ IR_ExceptionDescription *&out (void); ++ IR_ExceptionDescription *_retn (void); ++ IR_ExceptionDescription *ptr (void) const; + + private: +- ExceptionDescription *ptr_; ++ IR_ExceptionDescription *ptr_; + }; + +-class TAO_Export ExceptionDescription_out ++class TAO_Export IR_ExceptionDescription_out + { + public: +- ExceptionDescription_out (ExceptionDescription *&); +- ExceptionDescription_out (ExceptionDescription_var &); +- ExceptionDescription_out (const ExceptionDescription_out &); +- ExceptionDescription_out &operator= (const ExceptionDescription_out &); +- ExceptionDescription_out &operator= (ExceptionDescription *); +- operator ExceptionDescription *&(); +- ExceptionDescription *&ptr (void); +- ExceptionDescription *operator-> (void); ++ IR_ExceptionDescription_out (IR_ExceptionDescription *&); ++ IR_ExceptionDescription_out (IR_ExceptionDescription_var &); ++ IR_ExceptionDescription_out (const IR_ExceptionDescription_out &); ++ IR_ExceptionDescription_out &operator= (const IR_ExceptionDescription_out &); ++ IR_ExceptionDescription_out &operator= (IR_ExceptionDescription *); ++ operator IR_ExceptionDescription *&(); ++ IR_ExceptionDescription *&ptr (void); ++ IR_ExceptionDescription *operator-> (void); + + private: +- ExceptionDescription *&ptr_; ++ IR_ExceptionDescription *&ptr_; + // assignment from T_var not allowed +- void operator= (const ExceptionDescription_var &); ++ void operator= (const IR_ExceptionDescription_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDescription; +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EXCEPTIONDEFSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EXCEPTIONDEFSEQ_CH_ +- + class _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -16669,19 +10235,19 @@ + _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (CORBA::ULong maximum, + CORBA::ULong length, +- ExceptionDef* *value, ++ IR_ExceptionDef* *value, + CORBA::Boolean release = 0); + _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq &rhs); + virtual ~_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (void); + _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq &rhs); +- TAO_Object_Manager<IR::ExceptionDef,IR::ExceptionDef_var> operator[] (CORBA::ULong index) const; +- static ExceptionDef **allocbuf (CORBA::ULong nelems); +- static void freebuf (ExceptionDef **buffer); ++ TAO_Object_Manager<IR_ExceptionDef,IR_ExceptionDef_var> operator[] (CORBA::ULong index) const; ++ static IR_ExceptionDef **allocbuf (CORBA::ULong nelems); ++ static void freebuf (IR_ExceptionDef **buffer); + // The Base_Sequence functions, please see tao/Sequence.h + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); +- ExceptionDef* *get_buffer (CORBA::Boolean orphan = 0); +- const ExceptionDef* *get_buffer (void) const; ++ IR_ExceptionDef* *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_ExceptionDef* *get_buffer (void) const; + virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol); + virtual void _downcast ( + void* target, +@@ -16693,125 +10259,94 @@ + + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_EXCEPTIONDEFSEQ_CH_) +-#define _TAO_IR_EXCEPTIONDEFSEQ_CH_ +- +-class ExceptionDefSeq; +-class ExceptionDefSeq_var; +- + // ************************************************************* +-// ExceptionDefSeq ++// IR_ExceptionDefSeq + // ************************************************************* + +-class TAO_Export ExceptionDefSeq : public ++class TAO_Export IR_ExceptionDefSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Object_Sequence<ExceptionDef,ExceptionDef_var> ++ TAO_Unbounded_Object_Sequence<IR_ExceptionDef,IR_ExceptionDef_var> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- ExceptionDefSeq (void); // default ctor +- ExceptionDefSeq (CORBA::ULong max); // uses max size +- ExceptionDefSeq ( ++ IR_ExceptionDefSeq (void); // default ctor ++ IR_ExceptionDefSeq (CORBA::ULong max); // uses max size ++ IR_ExceptionDefSeq ( + CORBA::ULong max, + CORBA::ULong length, +- ExceptionDef_ptr *buffer, ++ IR_ExceptionDef_ptr *buffer, + CORBA::Boolean release = 0 + ); +- ExceptionDefSeq (const ExceptionDefSeq &); // copy ctor +- ~ExceptionDefSeq (void); ++ IR_ExceptionDefSeq (const IR_ExceptionDefSeq &); // copy ctor ++ ~IR_ExceptionDefSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ExceptionDefSeq_var _var_type; ++ typedef IR_ExceptionDefSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EXCEPTIONDEFSEQ___VAR_CH_) +-#define _TAO_IR_EXCEPTIONDEFSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::ExceptionDefSeq_var ++// class IR_ExceptionDefSeq_var + // ************************************************************* + +-class TAO_Export ExceptionDefSeq_var ++class TAO_Export IR_ExceptionDefSeq_var + { + public: +- ExceptionDefSeq_var (void); // default constructor +- ExceptionDefSeq_var (ExceptionDefSeq *); +- ExceptionDefSeq_var (const ExceptionDefSeq_var &); // copy constructor +- ~ExceptionDefSeq_var (void); // destructor ++ IR_ExceptionDefSeq_var (void); // default constructor ++ IR_ExceptionDefSeq_var (IR_ExceptionDefSeq *); ++ IR_ExceptionDefSeq_var (const IR_ExceptionDefSeq_var &); // copy constructor ++ ~IR_ExceptionDefSeq_var (void); // destructor + +- ExceptionDefSeq_var &operator= (ExceptionDefSeq *); +- ExceptionDefSeq_var &operator= (const ExceptionDefSeq_var &); +- ExceptionDefSeq *operator-> (void); +- const ExceptionDefSeq *operator-> (void) const; ++ IR_ExceptionDefSeq_var &operator= (IR_ExceptionDefSeq *); ++ IR_ExceptionDefSeq_var &operator= (const IR_ExceptionDefSeq_var &); ++ IR_ExceptionDefSeq *operator-> (void); ++ const IR_ExceptionDefSeq *operator-> (void) const; + +- operator const ExceptionDefSeq &() const; +- operator ExceptionDefSeq &(); +- operator ExceptionDefSeq &() const; +- operator ExceptionDefSeq *&(); // variable-size base types only ++ operator const IR_ExceptionDefSeq &() const; ++ operator IR_ExceptionDefSeq &(); ++ operator IR_ExceptionDefSeq &() const; ++ operator IR_ExceptionDefSeq *&(); // variable-size base types only + +- TAO_Object_Manager<ExceptionDef, ExceptionDef_var> operator[] (CORBA::ULong index); ++ TAO_Object_Manager<IR_ExceptionDef, IR_ExceptionDef_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const ExceptionDefSeq &in (void) const; +- ExceptionDefSeq &inout (void); +- ExceptionDefSeq *&out (void); +- ExceptionDefSeq *_retn (void); +- ExceptionDefSeq *ptr (void) const; ++ const IR_ExceptionDefSeq &in (void) const; ++ IR_ExceptionDefSeq &inout (void); ++ IR_ExceptionDefSeq *&out (void); ++ IR_ExceptionDefSeq *_retn (void); ++ IR_ExceptionDefSeq *ptr (void) const; + + private: +- ExceptionDefSeq *ptr_; ++ IR_ExceptionDefSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EXCEPTIONDEFSEQ___OUT_CH_) +-#define _TAO_IR_EXCEPTIONDEFSEQ___OUT_CH_ +- +-class TAO_Export ExceptionDefSeq_out ++class TAO_Export IR_ExceptionDefSeq_out + { + public: +- ExceptionDefSeq_out (ExceptionDefSeq *&); +- ExceptionDefSeq_out (ExceptionDefSeq_var &); +- ExceptionDefSeq_out (const ExceptionDefSeq_out &); +- ExceptionDefSeq_out &operator= (const ExceptionDefSeq_out &); +- ExceptionDefSeq_out &operator= (ExceptionDefSeq *); +- operator ExceptionDefSeq *&(); +- ExceptionDefSeq *&ptr (void); +- ExceptionDefSeq *operator-> (void); +- TAO_Object_Manager<ExceptionDef, ExceptionDef_var> operator[] (CORBA::ULong index); ++ IR_ExceptionDefSeq_out (IR_ExceptionDefSeq *&); ++ IR_ExceptionDefSeq_out (IR_ExceptionDefSeq_var &); ++ IR_ExceptionDefSeq_out (const IR_ExceptionDefSeq_out &); ++ IR_ExceptionDefSeq_out &operator= (const IR_ExceptionDefSeq_out &); ++ IR_ExceptionDefSeq_out &operator= (IR_ExceptionDefSeq *); ++ operator IR_ExceptionDefSeq *&(); ++ IR_ExceptionDefSeq *&ptr (void); ++ IR_ExceptionDefSeq *operator-> (void); ++ TAO_Object_Manager<IR_ExceptionDef, IR_ExceptionDef_var> operator[] (CORBA::ULong index); + + private: +- ExceptionDefSeq *&ptr_; ++ IR_ExceptionDefSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const ExceptionDefSeq_var &); ++ void operator= (const IR_ExceptionDefSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDefSeq; +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_SEQUENCE_IR_EXCDESCRIPTIONSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_SEQUENCE_IR_EXCDESCRIPTIONSEQ_CH_ +- + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -16821,252 +10356,196 @@ + _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (CORBA::ULong maximum, + CORBA::ULong length, +- ExceptionDescription *data, ++ IR_ExceptionDescription *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq &rhs); + _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq &rhs); + virtual ~_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (void); // Dtor. + // = Accessors. +- ExceptionDescription &operator[] (CORBA::ULong i); +- const ExceptionDescription &operator[] (CORBA::ULong i) const; ++ IR_ExceptionDescription &operator[] (CORBA::ULong i); ++ const IR_ExceptionDescription &operator[] (CORBA::ULong i) const; + // = Static operations. +- static ExceptionDescription *allocbuf (CORBA::ULong size); +- static void freebuf (ExceptionDescription *buffer); ++ static IR_ExceptionDescription *allocbuf (CORBA::ULong size); ++ static void freebuf (IR_ExceptionDescription *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + +- ExceptionDescription *get_buffer (CORBA::Boolean orphan = 0); +- const ExceptionDescription *get_buffer (void) const; ++ IR_ExceptionDescription *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_ExceptionDescription *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, +- ExceptionDescription *data, ++ IR_ExceptionDescription *data, + CORBA::Boolean release); + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_EXCDESCRIPTIONSEQ_CH_) +-#define _TAO_IR_EXCDESCRIPTIONSEQ_CH_ +- +-class ExcDescriptionSeq; +-class ExcDescriptionSeq_var; +- + // ************************************************************* +-// ExcDescriptionSeq ++// IR_ExcDescriptionSeq + // ************************************************************* + +-class TAO_Export ExcDescriptionSeq : public ++class TAO_Export IR_ExcDescriptionSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Sequence<ExceptionDescription> ++ TAO_Unbounded_Sequence<IR_ExceptionDescription> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- ExcDescriptionSeq (void); // default ctor +- ExcDescriptionSeq (CORBA::ULong max); // uses max size +- ExcDescriptionSeq ( ++ IR_ExcDescriptionSeq (void); // default ctor ++ IR_ExcDescriptionSeq (CORBA::ULong max); // uses max size ++ IR_ExcDescriptionSeq ( + CORBA::ULong max, + CORBA::ULong length, +- ExceptionDescription *buffer, ++ IR_ExceptionDescription *buffer, + CORBA::Boolean release = 0 + ); +- ExcDescriptionSeq (const ExcDescriptionSeq &); // copy ctor +- ~ExcDescriptionSeq (void); ++ IR_ExcDescriptionSeq (const IR_ExcDescriptionSeq &); // copy ctor ++ ~IR_ExcDescriptionSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ExcDescriptionSeq_var _var_type; ++ typedef IR_ExcDescriptionSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EXCDESCRIPTIONSEQ___VAR_CH_) +-#define _TAO_IR_EXCDESCRIPTIONSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::ExcDescriptionSeq_var ++// class IR_ExcDescriptionSeq_var + // ************************************************************* + +-class TAO_Export ExcDescriptionSeq_var ++class TAO_Export IR_ExcDescriptionSeq_var + { + public: +- ExcDescriptionSeq_var (void); // default constructor +- ExcDescriptionSeq_var (ExcDescriptionSeq *); +- ExcDescriptionSeq_var (const ExcDescriptionSeq_var &); // copy constructor +- ~ExcDescriptionSeq_var (void); // destructor ++ IR_ExcDescriptionSeq_var (void); // default constructor ++ IR_ExcDescriptionSeq_var (IR_ExcDescriptionSeq *); ++ IR_ExcDescriptionSeq_var (const IR_ExcDescriptionSeq_var &); // copy constructor ++ ~IR_ExcDescriptionSeq_var (void); // destructor + +- ExcDescriptionSeq_var &operator= (ExcDescriptionSeq *); +- ExcDescriptionSeq_var &operator= (const ExcDescriptionSeq_var &); +- ExcDescriptionSeq *operator-> (void); +- const ExcDescriptionSeq *operator-> (void) const; ++ IR_ExcDescriptionSeq_var &operator= (IR_ExcDescriptionSeq *); ++ IR_ExcDescriptionSeq_var &operator= (const IR_ExcDescriptionSeq_var &); ++ IR_ExcDescriptionSeq *operator-> (void); ++ const IR_ExcDescriptionSeq *operator-> (void) const; + +- operator const ExcDescriptionSeq &() const; +- operator ExcDescriptionSeq &(); +- operator ExcDescriptionSeq &() const; +- operator ExcDescriptionSeq *&(); // variable-size base types only ++ operator const IR_ExcDescriptionSeq &() const; ++ operator IR_ExcDescriptionSeq &(); ++ operator IR_ExcDescriptionSeq &() const; ++ operator IR_ExcDescriptionSeq *&(); // variable-size base types only + +- ExceptionDescription & operator[] (CORBA::ULong index); +- const ExceptionDescription & operator[] (CORBA::ULong index) const; ++ IR_ExceptionDescription & operator[] (CORBA::ULong index); ++ const IR_ExceptionDescription & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn +- const ExcDescriptionSeq &in (void) const; +- ExcDescriptionSeq &inout (void); +- ExcDescriptionSeq *&out (void); +- ExcDescriptionSeq *_retn (void); +- ExcDescriptionSeq *ptr (void) const; ++ const IR_ExcDescriptionSeq &in (void) const; ++ IR_ExcDescriptionSeq &inout (void); ++ IR_ExcDescriptionSeq *&out (void); ++ IR_ExcDescriptionSeq *_retn (void); ++ IR_ExcDescriptionSeq *ptr (void) const; + + private: +- ExcDescriptionSeq *ptr_; ++ IR_ExcDescriptionSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EXCDESCRIPTIONSEQ___OUT_CH_) +-#define _TAO_IR_EXCDESCRIPTIONSEQ___OUT_CH_ +- +-class TAO_Export ExcDescriptionSeq_out ++class TAO_Export IR_ExcDescriptionSeq_out + { + public: +- ExcDescriptionSeq_out (ExcDescriptionSeq *&); +- ExcDescriptionSeq_out (ExcDescriptionSeq_var &); +- ExcDescriptionSeq_out (const ExcDescriptionSeq_out &); +- ExcDescriptionSeq_out &operator= (const ExcDescriptionSeq_out &); +- ExcDescriptionSeq_out &operator= (ExcDescriptionSeq *); +- operator ExcDescriptionSeq *&(); +- ExcDescriptionSeq *&ptr (void); +- ExcDescriptionSeq *operator-> (void); +- ExceptionDescription & operator[] (CORBA::ULong index); ++ IR_ExcDescriptionSeq_out (IR_ExcDescriptionSeq *&); ++ IR_ExcDescriptionSeq_out (IR_ExcDescriptionSeq_var &); ++ IR_ExcDescriptionSeq_out (const IR_ExcDescriptionSeq_out &); ++ IR_ExcDescriptionSeq_out &operator= (const IR_ExcDescriptionSeq_out &); ++ IR_ExcDescriptionSeq_out &operator= (IR_ExcDescriptionSeq *); ++ operator IR_ExcDescriptionSeq *&(); ++ IR_ExcDescriptionSeq *&ptr (void); ++ IR_ExcDescriptionSeq *operator-> (void); ++ IR_ExceptionDescription & operator[] (CORBA::ULong index); + + private: +- ExcDescriptionSeq *&ptr_; ++ IR_ExcDescriptionSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const ExcDescriptionSeq_var &); ++ void operator= (const IR_ExcDescriptionSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExcDescriptionSeq; +- +-enum AttributeMode ++enum IR_AttributeMode + { +- ATTR_NORMAL, +- ATTR_READONLY ++ ATTR_NORMAL, ++ ATTR_READONLY + }; +-typedef AttributeMode &AttributeMode_out; +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeMode; +- + +-#if !defined (_TAO_IR_ATTRIBUTEDEF___PTR_CH_) +-#define _TAO_IR_ATTRIBUTEDEF___PTR_CH_ +- +-class AttributeDef; +-typedef AttributeDef *AttributeDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ATTRIBUTEDEF___VAR_CH_) +-#define _TAO_IR_ATTRIBUTEDEF___VAR_CH_ +- +-class TAO_Export AttributeDef_var : public TAO_Base_var ++class TAO_Export IR_AttributeDef_var : public TAO_Base_var + { + public: +- AttributeDef_var (void); // default constructor +- AttributeDef_var (AttributeDef_ptr p) : ptr_ (p) {} +- AttributeDef_var (const AttributeDef_var &); // copy constructor +- ~AttributeDef_var (void); // destructor ++ IR_AttributeDef_var (void); // default constructor ++ IR_AttributeDef_var (IR_AttributeDef_ptr p) : ptr_ (p) {} ++ IR_AttributeDef_var (const IR_AttributeDef_var &); // copy constructor ++ ~IR_AttributeDef_var (void); // destructor + +- AttributeDef_var &operator= (AttributeDef_ptr); +- AttributeDef_var &operator= (const AttributeDef_var &); +- AttributeDef_ptr operator-> (void) const; ++ IR_AttributeDef_var &operator= (IR_AttributeDef_ptr); ++ IR_AttributeDef_var &operator= (const IR_AttributeDef_var &); ++ IR_AttributeDef_ptr operator-> (void) const; + +- operator const AttributeDef_ptr &() const; +- operator AttributeDef_ptr &(); ++ operator const IR_AttributeDef_ptr &() const; ++ operator IR_AttributeDef_ptr &(); + // in, inout, out, _retn +- AttributeDef_ptr in (void) const; +- AttributeDef_ptr &inout (void); +- AttributeDef_ptr &out (void); +- AttributeDef_ptr _retn (void); +- AttributeDef_ptr ptr (void) const; ++ IR_AttributeDef_ptr in (void) const; ++ IR_AttributeDef_ptr &inout (void); ++ IR_AttributeDef_ptr &out (void); ++ IR_AttributeDef_ptr _retn (void); ++ IR_AttributeDef_ptr ptr (void) const; + + private: +- AttributeDef_ptr ptr_; ++ IR_AttributeDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- AttributeDef_var (const TAO_Base_var &rhs); +- AttributeDef_var &operator= (const TAO_Base_var &rhs); ++ IR_AttributeDef_var (const TAO_Base_var &rhs); ++ IR_AttributeDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ATTRIBUTEDEF___OUT_CH_) +-#define _TAO_IR_ATTRIBUTEDEF___OUT_CH_ +- +-class TAO_Export AttributeDef_out ++class TAO_Export IR_AttributeDef_out + { + public: +- AttributeDef_out (AttributeDef_ptr &); +- AttributeDef_out (AttributeDef_var &); +- AttributeDef_out (const AttributeDef_out &); +- AttributeDef_out &operator= (const AttributeDef_out &); +- AttributeDef_out &operator= (const AttributeDef_var &); +- AttributeDef_out &operator= (AttributeDef_ptr); +- operator AttributeDef_ptr &(); +- AttributeDef_ptr &ptr (void); +- AttributeDef_ptr operator-> (void); ++ IR_AttributeDef_out (IR_AttributeDef_ptr &); ++ IR_AttributeDef_out (IR_AttributeDef_var &); ++ IR_AttributeDef_out (const IR_AttributeDef_out &); ++ IR_AttributeDef_out &operator= (const IR_AttributeDef_out &); ++ IR_AttributeDef_out &operator= (const IR_AttributeDef_var &); ++ IR_AttributeDef_out &operator= (IR_AttributeDef_ptr); ++ operator IR_AttributeDef_ptr &(); ++ IR_AttributeDef_ptr &ptr (void); ++ IR_AttributeDef_ptr operator-> (void); + + private: +- AttributeDef_ptr &ptr_; ++ IR_AttributeDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ATTRIBUTEDEF_CH_) +-#define _TAO_IR_ATTRIBUTEDEF_CH_ +- + // Forward Classes Declaration + class _TAO_AttributeDef_Proxy_Impl; + class _TAO_AttributeDef_Remote_Proxy_Impl; + class _TAO_AttributeDef_Proxy_Broker; + class _TAO_AttributeDef_Remote_Proxy_Broker; + +-class TAO_Export AttributeDef: public virtual Contained ++class TAO_Export IR_AttributeDef: public virtual IR_Contained + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef AttributeDef_ptr _ptr_type; +- typedef AttributeDef_var _var_type; ++ typedef IR_AttributeDef_ptr _ptr_type; ++ typedef IR_AttributeDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static AttributeDef_ptr _duplicate (AttributeDef_ptr obj); +- static AttributeDef_ptr _narrow ( ++ static IR_AttributeDef_ptr _duplicate (IR_AttributeDef_ptr obj); ++ static IR_AttributeDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static AttributeDef_ptr _unchecked_narrow ( ++ static IR_AttributeDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static AttributeDef_ptr _nil (void) ++ static IR_AttributeDef_ptr _nil (void) + { +- return (AttributeDef_ptr)0; ++ return (IR_AttributeDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -17079,7 +10558,7 @@ + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr type_def ( ++ virtual IR_IDLType_ptr type_def ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -17088,7 +10567,7 @@ + )); + + virtual void type_def ( +- IR::IDLType_ptr type_def, ++ IR_IDLType_ptr type_def, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -17096,7 +10575,7 @@ + CORBA::SystemException + )); + +- virtual IR::AttributeMode mode ( ++ virtual IR_AttributeMode mode ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -17105,7 +10584,7 @@ + )); + + virtual void mode ( +- IR::AttributeMode mode, ++ IR_AttributeMode mode, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -17126,250 +10605,27 @@ + _TAO_AttributeDef_Proxy_Broker *the_TAO_AttributeDef_Proxy_Broker_; + + protected: +- AttributeDef (int collocated = 0); ++ IR_AttributeDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- AttributeDef ( ++ IR_AttributeDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_AttributeDef_Remote_Proxy_Impl; +- friend class _TAO_AttributeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_AttributeDef_Direct_Proxy_Impl; +- +- virtual ~AttributeDef (void); +- private: +- AttributeDef (const AttributeDef &); +- void operator= (const AttributeDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_AttributeDef_type_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::AttributeDef; +- +- friend class _TAO_AttributeDef_Remote_Proxy_Impl; +- friend class _TAO_AttributeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_AttributeDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_AttributeDef_type_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_AttributeDef_type_get (const TAO_ClientRequestInfo_IR_AttributeDef_type_get &); +- void operator= (const TAO_ClientRequestInfo_IR_AttributeDef_type_get &); +- void result (CORBA::TypeCode_ptr result); +- // update the result +- CORBA::TypeCode_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_AttributeDef_type_def_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::AttributeDef; +- +- friend class _TAO_AttributeDef_Remote_Proxy_Impl; +- friend class _TAO_AttributeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_AttributeDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_AttributeDef_type_def_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_AttributeDef_type_def_get (const TAO_ClientRequestInfo_IR_AttributeDef_type_def_get &); +- void operator= (const TAO_ClientRequestInfo_IR_AttributeDef_type_def_get &); +- void result (IR::IDLType_ptr result); +- // update the result +- IR::IDLType_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_AttributeDef_type_def_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::AttributeDef; +- +- friend class _TAO_AttributeDef_Remote_Proxy_Impl; +- friend class _TAO_AttributeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_AttributeDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_AttributeDef_type_def_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::IDLType_ptr type_def, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_AttributeDef_type_def_set (const TAO_ClientRequestInfo_IR_AttributeDef_type_def_set &); +- void operator= (const TAO_ClientRequestInfo_IR_AttributeDef_type_def_set &); +- IR::IDLType_ptr type_def_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_AttributeDef_mode_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::AttributeDef; +- ++ + friend class _TAO_AttributeDef_Remote_Proxy_Impl; + friend class _TAO_AttributeDef_ThruPOA_Proxy_Impl; + friend class _TAO_AttributeDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_AttributeDef_mode_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_AttributeDef_mode_get (const TAO_ClientRequestInfo_IR_AttributeDef_mode_get &); +- void operator= (const TAO_ClientRequestInfo_IR_AttributeDef_mode_get &); +- void result (IR::AttributeMode result); +- // update the result +- IR::AttributeMode result_; +-}; +- +-class TAO_ClientRequestInfo_IR_AttributeDef_mode_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::AttributeDef; + +- friend class _TAO_AttributeDef_Remote_Proxy_Impl; +- friend class _TAO_AttributeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_AttributeDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_AttributeDef_mode_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::AttributeMode & mode, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_AttributeDef (void); + private: +- TAO_ClientRequestInfo_IR_AttributeDef_mode_set (const TAO_ClientRequestInfo_IR_AttributeDef_mode_set &); +- void operator= (const TAO_ClientRequestInfo_IR_AttributeDef_mode_set &); +- const IR::AttributeMode & mode_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_AttributeDef (const IR_AttributeDef &); ++ void operator= (const IR_AttributeDef &); + }; + + +@@ -17383,12 +10639,12 @@ + // + + class TAO_Export _TAO_AttributeDef_Proxy_Impl : +- public virtual IR::_TAO_Contained_Proxy_Impl ++ public virtual _TAO_Contained_Proxy_Impl + { + public: + virtual ~_TAO_AttributeDef_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr type ( ++ virtual CORBA::TypeCode_ptr type ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -17396,7 +10652,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::IDLType_ptr type_def ( ++ virtual IR_IDLType_ptr type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -17406,14 +10662,14 @@ + + virtual void type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr type_def, ++ IR_IDLType_ptr type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::AttributeMode mode ( ++ virtual IR_AttributeMode mode ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -17423,7 +10679,7 @@ + + virtual void mode ( + CORBA_Object *_collocated_tao_target_, +- IR::AttributeMode mode, ++ IR_AttributeMode mode, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -17434,6 +10690,7 @@ + _TAO_AttributeDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -17446,7 +10703,7 @@ + class TAO_Export _TAO_AttributeDef_Remote_Proxy_Impl : + public virtual _TAO_AttributeDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl ++ public virtual _TAO_Contained_Remote_Proxy_Impl + + { + public: +@@ -17454,7 +10711,7 @@ + + virtual ~_TAO_AttributeDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr type ( ++ virtual CORBA::TypeCode_ptr type ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -17462,7 +10719,7 @@ + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr type_def ( ++ virtual IR_IDLType_ptr type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -17472,14 +10729,14 @@ + + virtual void type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr type_def, ++ IR_IDLType_ptr type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::AttributeMode mode ( ++ virtual IR_AttributeMode mode ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -17489,7 +10746,7 @@ + + virtual void mode ( + CORBA_Object *_collocated_tao_target_, +- IR::AttributeMode mode, ++ IR_AttributeMode mode, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -17518,8 +10775,9 @@ + { + public: + virtual ~_TAO_AttributeDef_Proxy_Broker (void); ++ + virtual _TAO_AttributeDef_Proxy_Impl &select_proxy ( +- AttributeDef *object, ++ IR_AttributeDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -17544,9 +10802,9 @@ + _TAO_AttributeDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_AttributeDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_AttributeDef_Proxy_Impl &select_proxy ( +- AttributeDef *object, ++ IR_AttributeDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -17560,24 +10818,15 @@ + static _TAO_AttributeDef_Remote_Proxy_Broker *the_TAO_AttributeDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeDef; +- +-struct AttributeDescription; +-class AttributeDescription_var; +- +-struct TAO_Export AttributeDescription ++struct TAO_Export IR_AttributeDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef AttributeDescription_var _var_type; ++ typedef IR_AttributeDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -17587,150 +10836,135 @@ + TAO_String_Manager defined_in; + TAO_String_Manager version; + CORBA::TypeCode_var type; +- ACE_NESTED_CLASS (IR, AttributeMode) mode; +- ACE_NESTED_CLASS (IR, ExcDescriptionSeq) get_exceptions; +- ACE_NESTED_CLASS (IR, ExcDescriptionSeq) put_exceptions; ++ IR_AttributeMode mode; ++ IR_ExcDescriptionSeq get_exceptions; ++ IR_ExcDescriptionSeq put_exceptions; + }; + +-class TAO_Export AttributeDescription_var ++class TAO_Export IR_AttributeDescription_var + { + public: +- AttributeDescription_var (void); // default constructor +- AttributeDescription_var (AttributeDescription *); +- AttributeDescription_var (const AttributeDescription_var &); // copy constructor +- ~AttributeDescription_var (void); // destructor ++ IR_AttributeDescription_var (void); // default constructor ++ IR_AttributeDescription_var (IR_AttributeDescription *); ++ IR_AttributeDescription_var (const IR_AttributeDescription_var &); // copy constructor ++ ~IR_AttributeDescription_var (void); // destructor + +- AttributeDescription_var &operator= (AttributeDescription *); +- AttributeDescription_var &operator= (const AttributeDescription_var &); +- AttributeDescription *operator-> (void); +- const AttributeDescription *operator-> (void) const; ++ IR_AttributeDescription_var &operator= (IR_AttributeDescription *); ++ IR_AttributeDescription_var &operator= (const IR_AttributeDescription_var &); ++ IR_AttributeDescription *operator-> (void); ++ const IR_AttributeDescription *operator-> (void) const; + +- operator const AttributeDescription &() const; +- operator AttributeDescription &(); +- operator AttributeDescription &() const; +- operator AttributeDescription *&(); // variable-size types only ++ operator const IR_AttributeDescription &() const; ++ operator IR_AttributeDescription &(); ++ operator IR_AttributeDescription &() const; ++ operator IR_AttributeDescription *&(); // variable-size types only + + // in, inout, out, _retn +- const AttributeDescription &in (void) const; +- AttributeDescription &inout (void); +- AttributeDescription *&out (void); +- AttributeDescription *_retn (void); +- AttributeDescription *ptr (void) const; ++ const IR_AttributeDescription &in (void) const; ++ IR_AttributeDescription &inout (void); ++ IR_AttributeDescription *&out (void); ++ IR_AttributeDescription *_retn (void); ++ IR_AttributeDescription *ptr (void) const; + + private: +- AttributeDescription *ptr_; ++ IR_AttributeDescription *ptr_; + }; + +-class TAO_Export AttributeDescription_out ++class TAO_Export IR_AttributeDescription_out + { + public: +- AttributeDescription_out (AttributeDescription *&); +- AttributeDescription_out (AttributeDescription_var &); +- AttributeDescription_out (const AttributeDescription_out &); +- AttributeDescription_out &operator= (const AttributeDescription_out &); +- AttributeDescription_out &operator= (AttributeDescription *); +- operator AttributeDescription *&(); +- AttributeDescription *&ptr (void); +- AttributeDescription *operator-> (void); ++ IR_AttributeDescription_out (IR_AttributeDescription *&); ++ IR_AttributeDescription_out (IR_AttributeDescription_var &); ++ IR_AttributeDescription_out (const IR_AttributeDescription_out &); ++ IR_AttributeDescription_out &operator= (const IR_AttributeDescription_out &); ++ IR_AttributeDescription_out &operator= (IR_AttributeDescription *); ++ operator IR_AttributeDescription *&(); ++ IR_AttributeDescription *&ptr (void); ++ IR_AttributeDescription *operator-> (void); + + private: +- AttributeDescription *&ptr_; ++ IR_AttributeDescription *&ptr_; + // assignment from T_var not allowed +- void operator= (const AttributeDescription_var &); ++ void operator= (const IR_AttributeDescription_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeDescription; +- +-enum OperationMode +-{ ++enum IR_OperationMode ++ { + OP_NORMAL, +- OP_ONEWAY +-}; +-typedef OperationMode &OperationMode_out; +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationMode; ++ OP_ONEWAY ++ }; + +-enum ParameterMode +-{ ++enum IR_ParameterMode ++ { + PARAM_IN, + PARAM_OUT, +- PARAM_INOUT +-}; +-typedef ParameterMode &ParameterMode_out; +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParameterMode; +- +-struct ParameterDescription; +-class ParameterDescription_var; ++ PARAM_INOUT ++ }; + +-struct TAO_Export ParameterDescription ++struct TAO_Export IR_ParameterDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ParameterDescription_var _var_type; ++ typedef IR_ParameterDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + TAO_String_Manager name; + CORBA::TypeCode_var type; +- ACE_NESTED_CLASS (IR, IDLType_var) type_def; +- ACE_NESTED_CLASS (IR, ParameterMode) mode; ++ IR_IDLType_var type_def; ++ IR_ParameterMode mode; + }; + +-class TAO_Export ParameterDescription_var ++class TAO_Export IR_ParameterDescription_var + { + public: +- ParameterDescription_var (void); // default constructor +- ParameterDescription_var (ParameterDescription *); +- ParameterDescription_var (const ParameterDescription_var &); // copy constructor +- ~ParameterDescription_var (void); // destructor ++ IR_ParameterDescription_var (void); // default constructor ++ IR_ParameterDescription_var (IR_ParameterDescription *); ++ IR_ParameterDescription_var (const IR_ParameterDescription_var &); // copy constructor ++ ~IR_ParameterDescription_var (void); // destructor + +- ParameterDescription_var &operator= (ParameterDescription *); +- ParameterDescription_var &operator= (const ParameterDescription_var &); +- ParameterDescription *operator-> (void); +- const ParameterDescription *operator-> (void) const; ++ IR_ParameterDescription_var &operator= (IR_ParameterDescription *); ++ IR_ParameterDescription_var &operator= (const IR_ParameterDescription_var &); ++ IR_ParameterDescription *operator-> (void); ++ const IR_ParameterDescription *operator-> (void) const; + +- operator const ParameterDescription &() const; +- operator ParameterDescription &(); +- operator ParameterDescription &() const; +- operator ParameterDescription *&(); // variable-size types only ++ operator const IR_ParameterDescription &() const; ++ operator IR_ParameterDescription &(); ++ operator IR_ParameterDescription &() const; ++ operator IR_ParameterDescription *&(); // variable-size types only + + // in, inout, out, _retn +- const ParameterDescription &in (void) const; +- ParameterDescription &inout (void); +- ParameterDescription *&out (void); +- ParameterDescription *_retn (void); +- ParameterDescription *ptr (void) const; ++ const IR_ParameterDescription &in (void) const; ++ IR_ParameterDescription &inout (void); ++ IR_ParameterDescription *&out (void); ++ IR_ParameterDescription *_retn (void); ++ IR_ParameterDescription *ptr (void) const; + + private: +- ParameterDescription *ptr_; ++ IR_ParameterDescription *ptr_; + }; + +-class TAO_Export ParameterDescription_out ++class TAO_Export IR_ParameterDescription_out + { + public: +- ParameterDescription_out (ParameterDescription *&); +- ParameterDescription_out (ParameterDescription_var &); +- ParameterDescription_out (const ParameterDescription_out &); +- ParameterDescription_out &operator= (const ParameterDescription_out &); +- ParameterDescription_out &operator= (ParameterDescription *); +- operator ParameterDescription *&(); +- ParameterDescription *&ptr (void); +- ParameterDescription *operator-> (void); ++ IR_ParameterDescription_out (IR_ParameterDescription *&); ++ IR_ParameterDescription_out (IR_ParameterDescription_var &); ++ IR_ParameterDescription_out (const IR_ParameterDescription_out &); ++ IR_ParameterDescription_out &operator= (const IR_ParameterDescription_out &); ++ IR_ParameterDescription_out &operator= (IR_ParameterDescription *); ++ operator IR_ParameterDescription *&(); ++ IR_ParameterDescription *&ptr (void); ++ IR_ParameterDescription *operator-> (void); + + private: +- ParameterDescription *&ptr_; ++ IR_ParameterDescription *&ptr_; + // assignment from T_var not allowed +- void operator= (const ParameterDescription_var &); ++ void operator= (const IR_ParameterDescription_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParameterDescription; +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_SEQUENCE_IR_PARDESCRIPTIONSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_SEQUENCE_IR_PARDESCRIPTIONSEQ_CH_ +- + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ParDescriptionSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -17740,160 +10974,121 @@ + _TAO_Unbounded_Sequence_IR_ParDescriptionSeq (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_IR_ParDescriptionSeq (CORBA::ULong maximum, + CORBA::ULong length, +- ParameterDescription *data, ++ IR_ParameterDescription *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_IR_ParDescriptionSeq (const _TAO_Unbounded_Sequence_IR_ParDescriptionSeq &rhs); + _TAO_Unbounded_Sequence_IR_ParDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_IR_ParDescriptionSeq &rhs); + virtual ~_TAO_Unbounded_Sequence_IR_ParDescriptionSeq (void); // Dtor. + // = Accessors. +- ParameterDescription &operator[] (CORBA::ULong i); +- const ParameterDescription &operator[] (CORBA::ULong i) const; ++ IR_ParameterDescription &operator[] (CORBA::ULong i); ++ const IR_ParameterDescription &operator[] (CORBA::ULong i) const; + // = Static operations. +- static ParameterDescription *allocbuf (CORBA::ULong size); +- static void freebuf (ParameterDescription *buffer); ++ static IR_ParameterDescription *allocbuf (CORBA::ULong size); ++ static void freebuf (IR_ParameterDescription *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + +- ParameterDescription *get_buffer (CORBA::Boolean orphan = 0); +- const ParameterDescription *get_buffer (void) const; ++ IR_ParameterDescription *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_ParameterDescription *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, +- ParameterDescription *data, ++ IR_ParameterDescription *data, + CORBA::Boolean release); + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_PARDESCRIPTIONSEQ_CH_) +-#define _TAO_IR_PARDESCRIPTIONSEQ_CH_ +- +-class ParDescriptionSeq; +-class ParDescriptionSeq_var; +- + // ************************************************************* +-// ParDescriptionSeq ++// IR_ParDescriptionSeq + // ************************************************************* + +-class TAO_Export ParDescriptionSeq : public ++class TAO_Export IR_ParDescriptionSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IR_ParDescriptionSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Sequence<ParameterDescription> ++ TAO_Unbounded_Sequence<IR_ParameterDescription> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- ParDescriptionSeq (void); // default ctor +- ParDescriptionSeq (CORBA::ULong max); // uses max size +- ParDescriptionSeq ( ++ IR_ParDescriptionSeq (void); // default ctor ++ IR_ParDescriptionSeq (CORBA::ULong max); // uses max size ++ IR_ParDescriptionSeq ( + CORBA::ULong max, + CORBA::ULong length, +- ParameterDescription *buffer, ++ IR_ParameterDescription *buffer, + CORBA::Boolean release = 0 + ); +- ParDescriptionSeq (const ParDescriptionSeq &); // copy ctor +- ~ParDescriptionSeq (void); ++ IR_ParDescriptionSeq (const IR_ParDescriptionSeq &); // copy ctor ++ ~IR_ParDescriptionSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ParDescriptionSeq_var _var_type; ++ typedef IR_ParDescriptionSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PARDESCRIPTIONSEQ___VAR_CH_) +-#define _TAO_IR_PARDESCRIPTIONSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::ParDescriptionSeq_var ++// class IR_ParDescriptionSeq_var + // ************************************************************* + +-class TAO_Export ParDescriptionSeq_var ++class TAO_Export IR_ParDescriptionSeq_var + { + public: +- ParDescriptionSeq_var (void); // default constructor +- ParDescriptionSeq_var (ParDescriptionSeq *); +- ParDescriptionSeq_var (const ParDescriptionSeq_var &); // copy constructor +- ~ParDescriptionSeq_var (void); // destructor ++ IR_ParDescriptionSeq_var (void); // default constructor ++ IR_ParDescriptionSeq_var (IR_ParDescriptionSeq *); ++ IR_ParDescriptionSeq_var (const IR_ParDescriptionSeq_var &); // copy constructor ++ ~IR_ParDescriptionSeq_var (void); // destructor + +- ParDescriptionSeq_var &operator= (ParDescriptionSeq *); +- ParDescriptionSeq_var &operator= (const ParDescriptionSeq_var &); +- ParDescriptionSeq *operator-> (void); +- const ParDescriptionSeq *operator-> (void) const; ++ IR_ParDescriptionSeq_var &operator= (IR_ParDescriptionSeq *); ++ IR_ParDescriptionSeq_var &operator= (const IR_ParDescriptionSeq_var &); ++ IR_ParDescriptionSeq *operator-> (void); ++ const IR_ParDescriptionSeq *operator-> (void) const; + +- operator const ParDescriptionSeq &() const; +- operator ParDescriptionSeq &(); +- operator ParDescriptionSeq &() const; +- operator ParDescriptionSeq *&(); // variable-size base types only ++ operator const IR_ParDescriptionSeq &() const; ++ operator IR_ParDescriptionSeq &(); ++ operator IR_ParDescriptionSeq &() const; ++ operator IR_ParDescriptionSeq *&(); // variable-size base types only + +- ParameterDescription & operator[] (CORBA::ULong index); +- const ParameterDescription & operator[] (CORBA::ULong index) const; ++ IR_ParameterDescription & operator[] (CORBA::ULong index); ++ const IR_ParameterDescription & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn +- const ParDescriptionSeq &in (void) const; +- ParDescriptionSeq &inout (void); +- ParDescriptionSeq *&out (void); +- ParDescriptionSeq *_retn (void); +- ParDescriptionSeq *ptr (void) const; ++ const IR_ParDescriptionSeq &in (void) const; ++ IR_ParDescriptionSeq &inout (void); ++ IR_ParDescriptionSeq *&out (void); ++ IR_ParDescriptionSeq *_retn (void); ++ IR_ParDescriptionSeq *ptr (void) const; + + private: +- ParDescriptionSeq *ptr_; ++ IR_ParDescriptionSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PARDESCRIPTIONSEQ___OUT_CH_) +-#define _TAO_IR_PARDESCRIPTIONSEQ___OUT_CH_ +- +-class TAO_Export ParDescriptionSeq_out ++class TAO_Export IR_ParDescriptionSeq_out + { + public: +- ParDescriptionSeq_out (ParDescriptionSeq *&); +- ParDescriptionSeq_out (ParDescriptionSeq_var &); +- ParDescriptionSeq_out (const ParDescriptionSeq_out &); +- ParDescriptionSeq_out &operator= (const ParDescriptionSeq_out &); +- ParDescriptionSeq_out &operator= (ParDescriptionSeq *); +- operator ParDescriptionSeq *&(); +- ParDescriptionSeq *&ptr (void); +- ParDescriptionSeq *operator-> (void); +- ParameterDescription & operator[] (CORBA::ULong index); ++ IR_ParDescriptionSeq_out (IR_ParDescriptionSeq *&); ++ IR_ParDescriptionSeq_out (IR_ParDescriptionSeq_var &); ++ IR_ParDescriptionSeq_out (const IR_ParDescriptionSeq_out &); ++ IR_ParDescriptionSeq_out &operator= (const IR_ParDescriptionSeq_out &); ++ IR_ParDescriptionSeq_out &operator= (IR_ParDescriptionSeq *); ++ operator IR_ParDescriptionSeq *&(); ++ IR_ParDescriptionSeq *&ptr (void); ++ IR_ParDescriptionSeq *operator-> (void); ++ IR_ParameterDescription & operator[] (CORBA::ULong index); + + private: +- ParDescriptionSeq *&ptr_; ++ IR_ParDescriptionSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const ParDescriptionSeq_var &); ++ void operator= (const IR_ParDescriptionSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParDescriptionSeq; +- +-typedef char * ContextIdentifier; +-typedef CORBA::String_var ContextIdentifier_var; +-typedef CORBA::String_out ContextIdentifier_out; +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContextIdentifier; +- +- +-#if !defined (_TAO_IR_CONTEXTIDSEQ_CH_) +-#define _TAO_IR_CONTEXTIDSEQ_CH_ +- +-class ContextIdSeq; +-class ContextIdSeq_var; +- + // ************************************************************* +-// ContextIdSeq ++// IR_ContextIdSeq + // ************************************************************* + +-class TAO_Export ContextIdSeq : public ++class TAO_Export IR_ContextIdSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_String_Sequence + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +@@ -17901,210 +11096,165 @@ + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- ContextIdSeq (void); // default ctor +- ContextIdSeq (CORBA::ULong max); // uses max size +- ContextIdSeq ( ++ IR_ContextIdSeq (void); // default ctor ++ IR_ContextIdSeq (CORBA::ULong max); // uses max size ++ IR_ContextIdSeq ( + CORBA::ULong max, + CORBA::ULong length, + char * *buffer, + CORBA::Boolean release = 0 + ); +- ContextIdSeq (const ContextIdSeq &); // copy ctor +- ~ContextIdSeq (void); ++ IR_ContextIdSeq (const IR_ContextIdSeq &); // copy ctor ++ ~IR_ContextIdSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ContextIdSeq_var _var_type; ++ typedef IR_ContextIdSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTEXTIDSEQ___VAR_CH_) +-#define _TAO_IR_CONTEXTIDSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::ContextIdSeq_var ++// class IR_ContextIdSeq_var + // ************************************************************* + +-class TAO_Export ContextIdSeq_var ++class TAO_Export IR_ContextIdSeq_var + { + public: +- ContextIdSeq_var (void); // default constructor +- ContextIdSeq_var (ContextIdSeq *); +- ContextIdSeq_var (const ContextIdSeq_var &); // copy constructor +- ~ContextIdSeq_var (void); // destructor ++ IR_ContextIdSeq_var (void); // default constructor ++ IR_ContextIdSeq_var (IR_ContextIdSeq *); ++ IR_ContextIdSeq_var (const IR_ContextIdSeq_var &); // copy constructor ++ ~IR_ContextIdSeq_var (void); // destructor + +- ContextIdSeq_var &operator= (ContextIdSeq *); +- ContextIdSeq_var &operator= (const ContextIdSeq_var &); +- ContextIdSeq *operator-> (void); +- const ContextIdSeq *operator-> (void) const; ++ IR_ContextIdSeq_var &operator= (IR_ContextIdSeq *); ++ IR_ContextIdSeq_var &operator= (const IR_ContextIdSeq_var &); ++ IR_ContextIdSeq *operator-> (void); ++ const IR_ContextIdSeq *operator-> (void) const; + +- operator const ContextIdSeq &() const; +- operator ContextIdSeq &(); +- operator ContextIdSeq &() const; +- operator ContextIdSeq *&(); // variable-size base types only ++ operator const IR_ContextIdSeq &() const; ++ operator IR_ContextIdSeq &(); ++ operator IR_ContextIdSeq &() const; ++ operator IR_ContextIdSeq *&(); // variable-size base types only + + TAO_SeqElem_String_Manager operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const ContextIdSeq &in (void) const; +- ContextIdSeq &inout (void); +- ContextIdSeq *&out (void); +- ContextIdSeq *_retn (void); +- ContextIdSeq *ptr (void) const; ++ const IR_ContextIdSeq &in (void) const; ++ IR_ContextIdSeq &inout (void); ++ IR_ContextIdSeq *&out (void); ++ IR_ContextIdSeq *_retn (void); ++ IR_ContextIdSeq *ptr (void) const; + + private: +- ContextIdSeq *ptr_; ++ IR_ContextIdSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONTEXTIDSEQ___OUT_CH_) +-#define _TAO_IR_CONTEXTIDSEQ___OUT_CH_ +- +-class TAO_Export ContextIdSeq_out ++class TAO_Export IR_ContextIdSeq_out + { + public: +- ContextIdSeq_out (ContextIdSeq *&); +- ContextIdSeq_out (ContextIdSeq_var &); +- ContextIdSeq_out (const ContextIdSeq_out &); +- ContextIdSeq_out &operator= (const ContextIdSeq_out &); +- ContextIdSeq_out &operator= (ContextIdSeq *); +- operator ContextIdSeq *&(); +- ContextIdSeq *&ptr (void); +- ContextIdSeq *operator-> (void); ++ IR_ContextIdSeq_out (IR_ContextIdSeq *&); ++ IR_ContextIdSeq_out (IR_ContextIdSeq_var &); ++ IR_ContextIdSeq_out (const IR_ContextIdSeq_out &); ++ IR_ContextIdSeq_out &operator= (const IR_ContextIdSeq_out &); ++ IR_ContextIdSeq_out &operator= (IR_ContextIdSeq *); ++ operator IR_ContextIdSeq *&(); ++ IR_ContextIdSeq *&ptr (void); ++ IR_ContextIdSeq *operator-> (void); + TAO_SeqElem_String_Manager operator[] (CORBA::ULong index); + + private: +- ContextIdSeq *&ptr_; ++ IR_ContextIdSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const ContextIdSeq_var &); ++ void operator= (const IR_ContextIdSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContextIdSeq; +- +- +-#if !defined (_TAO_IR_OPERATIONDEF___PTR_CH_) +-#define _TAO_IR_OPERATIONDEF___PTR_CH_ +- +-class OperationDef; +-typedef OperationDef *OperationDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_OPERATIONDEF___VAR_CH_) +-#define _TAO_IR_OPERATIONDEF___VAR_CH_ +- +-class TAO_Export OperationDef_var : public TAO_Base_var ++class TAO_Export IR_OperationDef_var : public TAO_Base_var + { + public: +- OperationDef_var (void); // default constructor +- OperationDef_var (OperationDef_ptr p) : ptr_ (p) {} +- OperationDef_var (const OperationDef_var &); // copy constructor +- ~OperationDef_var (void); // destructor ++ IR_OperationDef_var (void); // default constructor ++ IR_OperationDef_var (IR_OperationDef_ptr p) : ptr_ (p) {} ++ IR_OperationDef_var (const IR_OperationDef_var &); // copy constructor ++ ~IR_OperationDef_var (void); // destructor + +- OperationDef_var &operator= (OperationDef_ptr); +- OperationDef_var &operator= (const OperationDef_var &); +- OperationDef_ptr operator-> (void) const; ++ IR_OperationDef_var &operator= (IR_OperationDef_ptr); ++ IR_OperationDef_var &operator= (const IR_OperationDef_var &); ++ IR_OperationDef_ptr operator-> (void) const; + +- operator const OperationDef_ptr &() const; +- operator OperationDef_ptr &(); ++ operator const IR_OperationDef_ptr &() const; ++ operator IR_OperationDef_ptr &(); + // in, inout, out, _retn +- OperationDef_ptr in (void) const; +- OperationDef_ptr &inout (void); +- OperationDef_ptr &out (void); +- OperationDef_ptr _retn (void); +- OperationDef_ptr ptr (void) const; ++ IR_OperationDef_ptr in (void) const; ++ IR_OperationDef_ptr &inout (void); ++ IR_OperationDef_ptr &out (void); ++ IR_OperationDef_ptr _retn (void); ++ IR_OperationDef_ptr ptr (void) const; + + private: +- OperationDef_ptr ptr_; ++ IR_OperationDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- OperationDef_var (const TAO_Base_var &rhs); +- OperationDef_var &operator= (const TAO_Base_var &rhs); ++ IR_OperationDef_var (const TAO_Base_var &rhs); ++ IR_OperationDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_OPERATIONDEF___OUT_CH_) +-#define _TAO_IR_OPERATIONDEF___OUT_CH_ +- +-class TAO_Export OperationDef_out ++class TAO_Export IR_OperationDef_out + { + public: +- OperationDef_out (OperationDef_ptr &); +- OperationDef_out (OperationDef_var &); +- OperationDef_out (const OperationDef_out &); +- OperationDef_out &operator= (const OperationDef_out &); +- OperationDef_out &operator= (const OperationDef_var &); +- OperationDef_out &operator= (OperationDef_ptr); +- operator OperationDef_ptr &(); +- OperationDef_ptr &ptr (void); +- OperationDef_ptr operator-> (void); ++ IR_OperationDef_out (IR_OperationDef_ptr &); ++ IR_OperationDef_out (IR_OperationDef_var &); ++ IR_OperationDef_out (const IR_OperationDef_out &); ++ IR_OperationDef_out &operator= (const IR_OperationDef_out &); ++ IR_OperationDef_out &operator= (const IR_OperationDef_var &); ++ IR_OperationDef_out &operator= (IR_OperationDef_ptr); ++ operator IR_OperationDef_ptr &(); ++ IR_OperationDef_ptr &ptr (void); ++ IR_OperationDef_ptr operator-> (void); + + private: +- OperationDef_ptr &ptr_; ++ IR_OperationDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_OPERATIONDEF_CH_) +-#define _TAO_IR_OPERATIONDEF_CH_ +- + // Forward Classes Declaration + class _TAO_OperationDef_Proxy_Impl; + class _TAO_OperationDef_Remote_Proxy_Impl; + class _TAO_OperationDef_Proxy_Broker; + class _TAO_OperationDef_Remote_Proxy_Broker; + +-class TAO_Export OperationDef: public virtual Contained ++class TAO_Export IR_OperationDef: public virtual IR_Contained + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef OperationDef_ptr _ptr_type; +- typedef OperationDef_var _var_type; ++ typedef IR_OperationDef_ptr _ptr_type; ++ typedef IR_OperationDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static OperationDef_ptr _duplicate (OperationDef_ptr obj); +- static OperationDef_ptr _narrow ( ++ static IR_OperationDef_ptr _duplicate (IR_OperationDef_ptr obj); ++ static IR_OperationDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static OperationDef_ptr _unchecked_narrow ( ++ static IR_OperationDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static OperationDef_ptr _nil (void) ++ static IR_OperationDef_ptr _nil (void) + { +- return (OperationDef_ptr)0; ++ return (IR_OperationDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual CORBA::TypeCode_ptr result ( +- CORBA::Environment &ACE_TRY_ENV = ++ virtual CORBA::TypeCode_ptr result ( ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr result_def ( ++ virtual IR_IDLType_ptr result_def ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -18113,7 +11263,7 @@ + )); + + virtual void result_def ( +- IR::IDLType_ptr result_def, ++ IR_IDLType_ptr result_def, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -18121,7 +11271,7 @@ + CORBA::SystemException + )); + +- virtual IR::ParDescriptionSeq * params ( ++ virtual IR_ParDescriptionSeq * params ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -18130,7 +11280,7 @@ + )); + + virtual void params ( +- const IR::ParDescriptionSeq & params, ++ const IR_ParDescriptionSeq & params, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -18138,7 +11288,7 @@ + CORBA::SystemException + )); + +- virtual IR::OperationMode mode ( ++ virtual IR_OperationMode mode ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -18147,7 +11297,7 @@ + )); + + virtual void mode ( +- IR::OperationMode mode, ++ IR_OperationMode mode, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -18155,7 +11305,7 @@ + CORBA::SystemException + )); + +- virtual IR::ContextIdSeq * contexts ( ++ virtual IR_ContextIdSeq * contexts ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -18164,7 +11314,7 @@ + )); + + virtual void contexts ( +- const IR::ContextIdSeq & contexts, ++ const IR_ContextIdSeq & contexts, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -18172,7 +11322,7 @@ + CORBA::SystemException + )); + +- virtual IR::ExceptionDefSeq * exceptions ( ++ virtual IR_ExceptionDefSeq * exceptions ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -18181,7 +11331,7 @@ + )); + + virtual void exceptions ( +- const IR::ExceptionDefSeq & exceptions, ++ const IR_ExceptionDefSeq & exceptions, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -18202,652 +11352,172 @@ + _TAO_OperationDef_Proxy_Broker *the_TAO_OperationDef_Proxy_Broker_; + + protected: +- OperationDef (int collocated = 0); ++ IR_OperationDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- OperationDef ( ++ IR_OperationDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_OperationDef_Remote_Proxy_Impl; +- friend class _TAO_OperationDef_ThruPOA_Proxy_Impl; +- friend class _TAO_OperationDef_Direct_Proxy_Impl; +- +- virtual ~OperationDef (void); +- private: +- OperationDef (const OperationDef &); +- void operator= (const OperationDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_OperationDef_result_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::OperationDef; +- +- friend class _TAO_OperationDef_Remote_Proxy_Impl; +- friend class _TAO_OperationDef_ThruPOA_Proxy_Impl; +- friend class _TAO_OperationDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_OperationDef_result_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_OperationDef_result_get (const TAO_ClientRequestInfo_IR_OperationDef_result_get &); +- void operator= (const TAO_ClientRequestInfo_IR_OperationDef_result_get &); +- void result (CORBA::TypeCode_ptr result); +- // update the result +- CORBA::TypeCode_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_OperationDef_result_def_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::OperationDef; +- +- friend class _TAO_OperationDef_Remote_Proxy_Impl; +- friend class _TAO_OperationDef_ThruPOA_Proxy_Impl; +- friend class _TAO_OperationDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_OperationDef_result_def_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_OperationDef_result_def_get (const TAO_ClientRequestInfo_IR_OperationDef_result_def_get &); +- void operator= (const TAO_ClientRequestInfo_IR_OperationDef_result_def_get &); +- void result (IR::IDLType_ptr result); +- // update the result +- IR::IDLType_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_OperationDef_result_def_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::OperationDef; +- ++ + friend class _TAO_OperationDef_Remote_Proxy_Impl; + friend class _TAO_OperationDef_ThruPOA_Proxy_Impl; + friend class _TAO_OperationDef_Direct_Proxy_Impl; ++ ++ virtual ~IR_OperationDef (void); ++private: ++ IR_OperationDef (const IR_OperationDef &); ++ void operator= (const IR_OperationDef &); ++}; + +-TAO_ClientRequestInfo_IR_OperationDef_result_def_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::IDLType_ptr result_def, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); + +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++// The Proxy Implementations are used by each interface to ++// perform a call. Each different implementation encapsulate ++// an invocation logics. + +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); + +-private: +- TAO_ClientRequestInfo_IR_OperationDef_result_def_set (const TAO_ClientRequestInfo_IR_OperationDef_result_def_set &); +- void operator= (const TAO_ClientRequestInfo_IR_OperationDef_result_def_set &); +- IR::IDLType_ptr result_def_; +- +-}; ++/////////////////////////////////////////////////////////////////////// ++// Base Impl. Declaration ++// + +-class TAO_ClientRequestInfo_IR_OperationDef_params_get : public TAO_ClientRequestInfo ++class TAO_Export _TAO_OperationDef_Proxy_Impl : ++ public virtual _TAO_Contained_Proxy_Impl + { + public: +- friend class IR::OperationDef; ++ virtual ~_TAO_OperationDef_Proxy_Impl (void) { } + +- friend class _TAO_OperationDef_Remote_Proxy_Impl; +- friend class _TAO_OperationDef_ThruPOA_Proxy_Impl; +- friend class _TAO_OperationDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_OperationDef_params_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual CORBA::TypeCode_ptr result ( ++ CORBA_Object *_collocated_tao_target_, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual IR_IDLType_ptr result_def ( ++ CORBA_Object *_collocated_tao_target_, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual void result_def ( ++ CORBA_Object *_collocated_tao_target_, ++ IR_IDLType_ptr result_def, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-private: +- TAO_ClientRequestInfo_IR_OperationDef_params_get (const TAO_ClientRequestInfo_IR_OperationDef_params_get &); +- void operator= (const TAO_ClientRequestInfo_IR_OperationDef_params_get &); +- void result (IR::ParDescriptionSeq * result); +- // update the result +- IR::ParDescriptionSeq * result_; +-}; ++ virtual IR_ParDescriptionSeq * params ( ++ CORBA_Object *_collocated_tao_target_, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-class TAO_ClientRequestInfo_IR_OperationDef_params_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::OperationDef; +- +- friend class _TAO_OperationDef_Remote_Proxy_Impl; +- friend class _TAO_OperationDef_ThruPOA_Proxy_Impl; +- friend class _TAO_OperationDef_Direct_Proxy_Impl; ++ virtual void params ( ++ CORBA_Object *_collocated_tao_target_, ++ const IR_ParDescriptionSeq & params, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-TAO_ClientRequestInfo_IR_OperationDef_params_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const IR::ParDescriptionSeq & params, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); ++ virtual IR_OperationMode mode ( ++ CORBA_Object *_collocated_tao_target_, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual void mode ( ++ CORBA_Object *_collocated_tao_target_, ++ IR_OperationMode mode, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual IR_ContextIdSeq * contexts ( ++ CORBA_Object *_collocated_tao_target_, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual void contexts ( ++ CORBA_Object *_collocated_tao_target_, ++ const IR_ContextIdSeq & contexts, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-private: +- TAO_ClientRequestInfo_IR_OperationDef_params_set (const TAO_ClientRequestInfo_IR_OperationDef_params_set &); +- void operator= (const TAO_ClientRequestInfo_IR_OperationDef_params_set &); +- const IR::ParDescriptionSeq & params_; +- +-}; ++ virtual IR_ExceptionDefSeq * exceptions ( ++ CORBA_Object *_collocated_tao_target_, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-class TAO_ClientRequestInfo_IR_OperationDef_mode_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::OperationDef; +- +- friend class _TAO_OperationDef_Remote_Proxy_Impl; +- friend class _TAO_OperationDef_ThruPOA_Proxy_Impl; +- friend class _TAO_OperationDef_Direct_Proxy_Impl; ++ virtual void exceptions ( ++ CORBA_Object *_collocated_tao_target_, ++ const IR_ExceptionDefSeq & exceptions, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-TAO_ClientRequestInfo_IR_OperationDef_mode_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); ++protected: ++ _TAO_OperationDef_Proxy_Impl (void); + +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++}; + +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++// ++// Base Proxy Impl. Declaration ++/////////////////////////////////////////////////////////////////////// + +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); + +-private: +- TAO_ClientRequestInfo_IR_OperationDef_mode_get (const TAO_ClientRequestInfo_IR_OperationDef_mode_get &); +- void operator= (const TAO_ClientRequestInfo_IR_OperationDef_mode_get &); +- void result (IR::OperationMode result); +- // update the result +- IR::OperationMode result_; +-}; ++/////////////////////////////////////////////////////////////////////// ++// Remote Impl. Declaration ++// + +-class TAO_ClientRequestInfo_IR_OperationDef_mode_set : public TAO_ClientRequestInfo ++class TAO_Export _TAO_OperationDef_Remote_Proxy_Impl : ++ public virtual _TAO_OperationDef_Proxy_Impl, ++ public virtual TAO_Remote_Object_Proxy_Impl, ++ public virtual _TAO_Contained_Remote_Proxy_Impl ++ + { + public: +- friend class IR::OperationDef; +- +- friend class _TAO_OperationDef_Remote_Proxy_Impl; +- friend class _TAO_OperationDef_ThruPOA_Proxy_Impl; +- friend class _TAO_OperationDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_OperationDef_mode_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::OperationMode & mode, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_OperationDef_mode_set (const TAO_ClientRequestInfo_IR_OperationDef_mode_set &); +- void operator= (const TAO_ClientRequestInfo_IR_OperationDef_mode_set &); +- const IR::OperationMode & mode_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_OperationDef_contexts_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::OperationDef; +- +- friend class _TAO_OperationDef_Remote_Proxy_Impl; +- friend class _TAO_OperationDef_ThruPOA_Proxy_Impl; +- friend class _TAO_OperationDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_OperationDef_contexts_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_OperationDef_contexts_get (const TAO_ClientRequestInfo_IR_OperationDef_contexts_get &); +- void operator= (const TAO_ClientRequestInfo_IR_OperationDef_contexts_get &); +- void result (IR::ContextIdSeq * result); +- // update the result +- IR::ContextIdSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_OperationDef_contexts_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::OperationDef; +- +- friend class _TAO_OperationDef_Remote_Proxy_Impl; +- friend class _TAO_OperationDef_ThruPOA_Proxy_Impl; +- friend class _TAO_OperationDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_OperationDef_contexts_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const IR::ContextIdSeq & contexts, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_OperationDef_contexts_set (const TAO_ClientRequestInfo_IR_OperationDef_contexts_set &); +- void operator= (const TAO_ClientRequestInfo_IR_OperationDef_contexts_set &); +- const IR::ContextIdSeq & contexts_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_OperationDef_exceptions_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::OperationDef; +- +- friend class _TAO_OperationDef_Remote_Proxy_Impl; +- friend class _TAO_OperationDef_ThruPOA_Proxy_Impl; +- friend class _TAO_OperationDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_OperationDef_exceptions_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_OperationDef_exceptions_get (const TAO_ClientRequestInfo_IR_OperationDef_exceptions_get &); +- void operator= (const TAO_ClientRequestInfo_IR_OperationDef_exceptions_get &); +- void result (IR::ExceptionDefSeq * result); +- // update the result +- IR::ExceptionDefSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_OperationDef_exceptions_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::OperationDef; +- +- friend class _TAO_OperationDef_Remote_Proxy_Impl; +- friend class _TAO_OperationDef_ThruPOA_Proxy_Impl; +- friend class _TAO_OperationDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_OperationDef_exceptions_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const IR::ExceptionDefSeq & exceptions, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_OperationDef_exceptions_set (const TAO_ClientRequestInfo_IR_OperationDef_exceptions_set &); +- void operator= (const TAO_ClientRequestInfo_IR_OperationDef_exceptions_set &); +- const IR::ExceptionDefSeq & exceptions_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- +-}; +- +- +-// The Proxy Implementations are used by each interface to +-// perform a call. Each different implementation encapsulate +-// an invocation logics. +- +- +-/////////////////////////////////////////////////////////////////////// +-// Base Impl. Declaration +-// +- +-class TAO_Export _TAO_OperationDef_Proxy_Impl : +- public virtual IR::_TAO_Contained_Proxy_Impl +-{ +-public: +- virtual ~_TAO_OperationDef_Proxy_Impl (void) { } +- +- virtual CORBA::TypeCode_ptr result ( +- CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual IR::IDLType_ptr result_def ( +- CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual void result_def ( +- CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr result_def, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual IR::ParDescriptionSeq * params ( +- CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual void params ( +- CORBA_Object *_collocated_tao_target_, +- const IR::ParDescriptionSeq & params, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual IR::OperationMode mode ( +- CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual void mode ( +- CORBA_Object *_collocated_tao_target_, +- IR::OperationMode mode, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual IR::ContextIdSeq * contexts ( +- CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual void contexts ( +- CORBA_Object *_collocated_tao_target_, +- const IR::ContextIdSeq & contexts, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual IR::ExceptionDefSeq * exceptions ( +- CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual void exceptions ( +- CORBA_Object *_collocated_tao_target_, +- const IR::ExceptionDefSeq & exceptions, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +-protected: +- _TAO_OperationDef_Proxy_Impl (void); +- +-}; +-// +-// Base Proxy Impl. Declaration +-/////////////////////////////////////////////////////////////////////// +- +- +-/////////////////////////////////////////////////////////////////////// +-// Remote Impl. Declaration +-// +- +-class TAO_Export _TAO_OperationDef_Remote_Proxy_Impl : +- public virtual _TAO_OperationDef_Proxy_Impl, +- public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl +- +-{ +-public: +- _TAO_OperationDef_Remote_Proxy_Impl (void); ++ _TAO_OperationDef_Remote_Proxy_Impl (void); + + virtual ~_TAO_OperationDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr result ( ++ virtual CORBA::TypeCode_ptr result ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr result_def ( ++ virtual IR_IDLType_ptr result_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -18857,14 +11527,14 @@ + + virtual void result_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr result_def, ++ IR_IDLType_ptr result_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::ParDescriptionSeq * params ( ++ virtual IR_ParDescriptionSeq * params ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -18874,14 +11544,14 @@ + + virtual void params ( + CORBA_Object *_collocated_tao_target_, +- const IR::ParDescriptionSeq & params, ++ const IR_ParDescriptionSeq & params, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::OperationMode mode ( ++ virtual IR_OperationMode mode ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -18891,14 +11561,14 @@ + + virtual void mode ( + CORBA_Object *_collocated_tao_target_, +- IR::OperationMode mode, ++ IR_OperationMode mode, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::ContextIdSeq * contexts ( ++ virtual IR_ContextIdSeq * contexts ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -18908,14 +11578,14 @@ + + virtual void contexts ( + CORBA_Object *_collocated_tao_target_, +- const IR::ContextIdSeq & contexts, ++ const IR_ContextIdSeq & contexts, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::ExceptionDefSeq * exceptions ( ++ virtual IR_ExceptionDefSeq * exceptions ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -18925,7 +11595,7 @@ + + virtual void exceptions ( + CORBA_Object *_collocated_tao_target_, +- const IR::ExceptionDefSeq & exceptions, ++ const IR_ExceptionDefSeq & exceptions, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -18954,8 +11624,9 @@ + { + public: + virtual ~_TAO_OperationDef_Proxy_Broker (void); ++ + virtual _TAO_OperationDef_Proxy_Impl &select_proxy ( +- OperationDef *object, ++ IR_OperationDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -18980,9 +11651,9 @@ + _TAO_OperationDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_OperationDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_OperationDef_Proxy_Impl &select_proxy ( +- OperationDef *object, ++ IR_OperationDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -18996,24 +11667,15 @@ + static _TAO_OperationDef_Remote_Proxy_Broker *the_TAO_OperationDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationDef; +- +-struct OperationDescription; +-class OperationDescription_var; +- +-struct TAO_Export OperationDescription ++struct TAO_Export IR_OperationDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef OperationDescription_var _var_type; ++ typedef IR_OperationDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -19023,73 +11685,64 @@ + TAO_String_Manager defined_in; + TAO_String_Manager version; + CORBA::TypeCode_var result; +- ACE_NESTED_CLASS (IR, OperationMode) mode; +- ACE_NESTED_CLASS (IR, ContextIdSeq) contexts; +- ACE_NESTED_CLASS (IR, ParDescriptionSeq) parameters; +- ACE_NESTED_CLASS (IR, ExcDescriptionSeq) exceptions; ++ IR_OperationMode mode; ++ IR_ContextIdSeq contexts; ++ IR_ParDescriptionSeq parameters; ++ IR_ExcDescriptionSeq exceptions; + }; + +-class TAO_Export OperationDescription_var ++class TAO_Export IR_OperationDescription_var + { + public: +- OperationDescription_var (void); // default constructor +- OperationDescription_var (OperationDescription *); +- OperationDescription_var (const OperationDescription_var &); // copy constructor +- ~OperationDescription_var (void); // destructor ++ IR_OperationDescription_var (void); // default constructor ++ IR_OperationDescription_var (IR_OperationDescription *); ++ IR_OperationDescription_var (const IR_OperationDescription_var &); // copy constructor ++ ~IR_OperationDescription_var (void); // destructor + +- OperationDescription_var &operator= (OperationDescription *); +- OperationDescription_var &operator= (const OperationDescription_var &); +- OperationDescription *operator-> (void); +- const OperationDescription *operator-> (void) const; ++ IR_OperationDescription_var &operator= (IR_OperationDescription *); ++ IR_OperationDescription_var &operator= (const IR_OperationDescription_var &); ++ IR_OperationDescription *operator-> (void); ++ const IR_OperationDescription *operator-> (void) const; + +- operator const OperationDescription &() const; +- operator OperationDescription &(); +- operator OperationDescription &() const; +- operator OperationDescription *&(); // variable-size types only ++ operator const IR_OperationDescription &() const; ++ operator IR_OperationDescription &(); ++ operator IR_OperationDescription &() const; ++ operator IR_OperationDescription *&(); // variable-size types only + + // in, inout, out, _retn +- const OperationDescription &in (void) const; +- OperationDescription &inout (void); +- OperationDescription *&out (void); +- OperationDescription *_retn (void); +- OperationDescription *ptr (void) const; ++ const IR_OperationDescription &in (void) const; ++ IR_OperationDescription &inout (void); ++ IR_OperationDescription *&out (void); ++ IR_OperationDescription *_retn (void); ++ IR_OperationDescription *ptr (void) const; + + private: +- OperationDescription *ptr_; ++ IR_OperationDescription *ptr_; + }; + +-class TAO_Export OperationDescription_out ++class TAO_Export IR_OperationDescription_out + { + public: +- OperationDescription_out (OperationDescription *&); +- OperationDescription_out (OperationDescription_var &); +- OperationDescription_out (const OperationDescription_out &); +- OperationDescription_out &operator= (const OperationDescription_out &); +- OperationDescription_out &operator= (OperationDescription *); +- operator OperationDescription *&(); +- OperationDescription *&ptr (void); +- OperationDescription *operator-> (void); ++ IR_OperationDescription_out (IR_OperationDescription *&); ++ IR_OperationDescription_out (IR_OperationDescription_var &); ++ IR_OperationDescription_out (const IR_OperationDescription_out &); ++ IR_OperationDescription_out &operator= (const IR_OperationDescription_out &); ++ IR_OperationDescription_out &operator= (IR_OperationDescription *); ++ operator IR_OperationDescription *&(); ++ IR_OperationDescription *&ptr (void); ++ IR_OperationDescription *operator-> (void); + + private: +- OperationDescription *&ptr_; ++ IR_OperationDescription *&ptr_; + // assignment from T_var not allowed +- void operator= (const OperationDescription_var &); ++ void operator= (const IR_OperationDescription_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationDescription; +- +- +-#if !defined (_TAO_IR_REPOSITORYIDSEQ_CH_) +-#define _TAO_IR_REPOSITORYIDSEQ_CH_ +- +-class RepositoryIdSeq; +-class RepositoryIdSeq_var; +- + // ************************************************************* +-// RepositoryIdSeq ++// IR_RepositoryIdSeq + // ************************************************************* + +-class TAO_Export RepositoryIdSeq : public ++class TAO_Export IR_RepositoryIdSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + TAO_Unbounded_String_Sequence + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +@@ -19097,102 +11750,80 @@ + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- RepositoryIdSeq (void); // default ctor +- RepositoryIdSeq (CORBA::ULong max); // uses max size +- RepositoryIdSeq ( ++ IR_RepositoryIdSeq (void); // default ctor ++ IR_RepositoryIdSeq (CORBA::ULong max); // uses max size ++ IR_RepositoryIdSeq ( + CORBA::ULong max, + CORBA::ULong length, + char * *buffer, + CORBA::Boolean release = 0 + ); +- RepositoryIdSeq (const RepositoryIdSeq &); // copy ctor +- ~RepositoryIdSeq (void); ++ IR_RepositoryIdSeq (const IR_RepositoryIdSeq &); // copy ctor ++ ~IR_RepositoryIdSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef RepositoryIdSeq_var _var_type; ++ typedef IR_RepositoryIdSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_REPOSITORYIDSEQ___VAR_CH_) +-#define _TAO_IR_REPOSITORYIDSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::RepositoryIdSeq_var ++// class IR_RepositoryIdSeq_var + // ************************************************************* + +-class TAO_Export RepositoryIdSeq_var ++class TAO_Export IR_RepositoryIdSeq_var + { + public: +- RepositoryIdSeq_var (void); // default constructor +- RepositoryIdSeq_var (RepositoryIdSeq *); +- RepositoryIdSeq_var (const RepositoryIdSeq_var &); // copy constructor +- ~RepositoryIdSeq_var (void); // destructor ++ IR_RepositoryIdSeq_var (void); // default constructor ++ IR_RepositoryIdSeq_var (IR_RepositoryIdSeq *); ++ IR_RepositoryIdSeq_var (const IR_RepositoryIdSeq_var &); // copy constructor ++ ~IR_RepositoryIdSeq_var (void); // destructor + +- RepositoryIdSeq_var &operator= (RepositoryIdSeq *); +- RepositoryIdSeq_var &operator= (const RepositoryIdSeq_var &); +- RepositoryIdSeq *operator-> (void); +- const RepositoryIdSeq *operator-> (void) const; ++ IR_RepositoryIdSeq_var &operator= (IR_RepositoryIdSeq *); ++ IR_RepositoryIdSeq_var &operator= (const IR_RepositoryIdSeq_var &); ++ IR_RepositoryIdSeq *operator-> (void); ++ const IR_RepositoryIdSeq *operator-> (void) const; + +- operator const RepositoryIdSeq &() const; +- operator RepositoryIdSeq &(); +- operator RepositoryIdSeq &() const; +- operator RepositoryIdSeq *&(); // variable-size base types only ++ operator const IR_RepositoryIdSeq &() const; ++ operator IR_RepositoryIdSeq &(); ++ operator IR_RepositoryIdSeq &() const; ++ operator IR_RepositoryIdSeq *&(); // variable-size base types only + + TAO_SeqElem_String_Manager operator[] (CORBA::ULong index); + + // in, inout, out, _retn +- const RepositoryIdSeq &in (void) const; +- RepositoryIdSeq &inout (void); +- RepositoryIdSeq *&out (void); +- RepositoryIdSeq *_retn (void); +- RepositoryIdSeq *ptr (void) const; ++ const IR_RepositoryIdSeq &in (void) const; ++ IR_RepositoryIdSeq &inout (void); ++ IR_RepositoryIdSeq *&out (void); ++ IR_RepositoryIdSeq *_retn (void); ++ IR_RepositoryIdSeq *ptr (void) const; + + private: +- RepositoryIdSeq *ptr_; ++ IR_RepositoryIdSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_REPOSITORYIDSEQ___OUT_CH_) +-#define _TAO_IR_REPOSITORYIDSEQ___OUT_CH_ +- +-class TAO_Export RepositoryIdSeq_out ++class TAO_Export IR_RepositoryIdSeq_out + { + public: +- RepositoryIdSeq_out (RepositoryIdSeq *&); +- RepositoryIdSeq_out (RepositoryIdSeq_var &); +- RepositoryIdSeq_out (const RepositoryIdSeq_out &); +- RepositoryIdSeq_out &operator= (const RepositoryIdSeq_out &); +- RepositoryIdSeq_out &operator= (RepositoryIdSeq *); +- operator RepositoryIdSeq *&(); +- RepositoryIdSeq *&ptr (void); +- RepositoryIdSeq *operator-> (void); ++ IR_RepositoryIdSeq_out (IR_RepositoryIdSeq *&); ++ IR_RepositoryIdSeq_out (IR_RepositoryIdSeq_var &); ++ IR_RepositoryIdSeq_out (const IR_RepositoryIdSeq_out &); ++ IR_RepositoryIdSeq_out &operator= (const IR_RepositoryIdSeq_out &); ++ IR_RepositoryIdSeq_out &operator= (IR_RepositoryIdSeq *); ++ operator IR_RepositoryIdSeq *&(); ++ IR_RepositoryIdSeq *&ptr (void); ++ IR_RepositoryIdSeq *operator-> (void); + TAO_SeqElem_String_Manager operator[] (CORBA::ULong index); + + private: +- RepositoryIdSeq *&ptr_; ++ IR_RepositoryIdSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const RepositoryIdSeq_var &); ++ void operator= (const IR_RepositoryIdSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RepositoryIdSeq; +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_SEQUENCE_IR_OPDESCRIPTIONSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_SEQUENCE_IR_OPDESCRIPTIONSEQ_CH_ +- + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_OpDescriptionSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -19202,149 +11833,118 @@ + _TAO_Unbounded_Sequence_IR_OpDescriptionSeq (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_IR_OpDescriptionSeq (CORBA::ULong maximum, + CORBA::ULong length, +- OperationDescription *data, ++ IR_OperationDescription *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_IR_OpDescriptionSeq (const _TAO_Unbounded_Sequence_IR_OpDescriptionSeq &rhs); + _TAO_Unbounded_Sequence_IR_OpDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_IR_OpDescriptionSeq &rhs); + virtual ~_TAO_Unbounded_Sequence_IR_OpDescriptionSeq (void); // Dtor. + // = Accessors. +- OperationDescription &operator[] (CORBA::ULong i); +- const OperationDescription &operator[] (CORBA::ULong i) const; ++ IR_OperationDescription &operator[] (CORBA::ULong i); ++ const IR_OperationDescription &operator[] (CORBA::ULong i) const; + // = Static operations. +- static OperationDescription *allocbuf (CORBA::ULong size); +- static void freebuf (OperationDescription *buffer); ++ static IR_OperationDescription *allocbuf (CORBA::ULong size); ++ static void freebuf (IR_OperationDescription *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + +- OperationDescription *get_buffer (CORBA::Boolean orphan = 0); +- const OperationDescription *get_buffer (void) const; ++ IR_OperationDescription *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_OperationDescription *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, +- OperationDescription *data, ++ IR_OperationDescription *data, + CORBA::Boolean release); + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_OPDESCRIPTIONSEQ_CH_) +-#define _TAO_IR_OPDESCRIPTIONSEQ_CH_ +- +-class OpDescriptionSeq; +-class OpDescriptionSeq_var; +- + // ************************************************************* +-// OpDescriptionSeq ++// IR_OpDescriptionSeq + // ************************************************************* + +-class TAO_Export OpDescriptionSeq : public ++class TAO_Export IR_OpDescriptionSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IR_OpDescriptionSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Sequence<OperationDescription> ++ TAO_Unbounded_Sequence<IR_OperationDescription> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- OpDescriptionSeq (void); // default ctor +- OpDescriptionSeq (CORBA::ULong max); // uses max size +- OpDescriptionSeq ( ++ IR_OpDescriptionSeq (void); // default ctor ++ IR_OpDescriptionSeq (CORBA::ULong max); // uses max size ++ IR_OpDescriptionSeq ( + CORBA::ULong max, + CORBA::ULong length, +- OperationDescription *buffer, ++ IR_OperationDescription *buffer, + CORBA::Boolean release = 0 + ); +- OpDescriptionSeq (const OpDescriptionSeq &); // copy ctor +- ~OpDescriptionSeq (void); ++ IR_OpDescriptionSeq (const IR_OpDescriptionSeq &); // copy ctor ++ ~IR_OpDescriptionSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef OpDescriptionSeq_var _var_type; ++ typedef IR_OpDescriptionSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_OPDESCRIPTIONSEQ___VAR_CH_) +-#define _TAO_IR_OPDESCRIPTIONSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::OpDescriptionSeq_var ++// class IR_OpDescriptionSeq_var + // ************************************************************* + +-class TAO_Export OpDescriptionSeq_var ++class TAO_Export IR_OpDescriptionSeq_var + { + public: +- OpDescriptionSeq_var (void); // default constructor +- OpDescriptionSeq_var (OpDescriptionSeq *); +- OpDescriptionSeq_var (const OpDescriptionSeq_var &); // copy constructor +- ~OpDescriptionSeq_var (void); // destructor ++ IR_OpDescriptionSeq_var (void); // default constructor ++ IR_OpDescriptionSeq_var (IR_OpDescriptionSeq *); ++ IR_OpDescriptionSeq_var (const IR_OpDescriptionSeq_var &); // copy constructor ++ ~IR_OpDescriptionSeq_var (void); // destructor + +- OpDescriptionSeq_var &operator= (OpDescriptionSeq *); +- OpDescriptionSeq_var &operator= (const OpDescriptionSeq_var &); +- OpDescriptionSeq *operator-> (void); +- const OpDescriptionSeq *operator-> (void) const; ++ IR_OpDescriptionSeq_var &operator= (IR_OpDescriptionSeq *); ++ IR_OpDescriptionSeq_var &operator= (const IR_OpDescriptionSeq_var &); ++ IR_OpDescriptionSeq *operator-> (void); ++ const IR_OpDescriptionSeq *operator-> (void) const; + +- operator const OpDescriptionSeq &() const; +- operator OpDescriptionSeq &(); +- operator OpDescriptionSeq &() const; +- operator OpDescriptionSeq *&(); // variable-size base types only ++ operator const IR_OpDescriptionSeq &() const; ++ operator IR_OpDescriptionSeq &(); ++ operator IR_OpDescriptionSeq &() const; ++ operator IR_OpDescriptionSeq *&(); // variable-size base types only + +- OperationDescription & operator[] (CORBA::ULong index); +- const OperationDescription & operator[] (CORBA::ULong index) const; ++ IR_OperationDescription & operator[] (CORBA::ULong index); ++ const IR_OperationDescription & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn +- const OpDescriptionSeq &in (void) const; +- OpDescriptionSeq &inout (void); +- OpDescriptionSeq *&out (void); +- OpDescriptionSeq *_retn (void); +- OpDescriptionSeq *ptr (void) const; ++ const IR_OpDescriptionSeq &in (void) const; ++ IR_OpDescriptionSeq &inout (void); ++ IR_OpDescriptionSeq *&out (void); ++ IR_OpDescriptionSeq *_retn (void); ++ IR_OpDescriptionSeq *ptr (void) const; + + private: +- OpDescriptionSeq *ptr_; ++ IR_OpDescriptionSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_OPDESCRIPTIONSEQ___OUT_CH_) +-#define _TAO_IR_OPDESCRIPTIONSEQ___OUT_CH_ +- +-class TAO_Export OpDescriptionSeq_out ++class TAO_Export IR_OpDescriptionSeq_out + { + public: +- OpDescriptionSeq_out (OpDescriptionSeq *&); +- OpDescriptionSeq_out (OpDescriptionSeq_var &); +- OpDescriptionSeq_out (const OpDescriptionSeq_out &); +- OpDescriptionSeq_out &operator= (const OpDescriptionSeq_out &); +- OpDescriptionSeq_out &operator= (OpDescriptionSeq *); +- operator OpDescriptionSeq *&(); +- OpDescriptionSeq *&ptr (void); +- OpDescriptionSeq *operator-> (void); +- OperationDescription & operator[] (CORBA::ULong index); ++ IR_OpDescriptionSeq_out (IR_OpDescriptionSeq *&); ++ IR_OpDescriptionSeq_out (IR_OpDescriptionSeq_var &); ++ IR_OpDescriptionSeq_out (const IR_OpDescriptionSeq_out &); ++ IR_OpDescriptionSeq_out &operator= (const IR_OpDescriptionSeq_out &); ++ IR_OpDescriptionSeq_out &operator= (IR_OpDescriptionSeq *); ++ operator IR_OpDescriptionSeq *&(); ++ IR_OpDescriptionSeq *&ptr (void); ++ IR_OpDescriptionSeq *operator-> (void); ++ IR_OperationDescription & operator[] (CORBA::ULong index); + + private: +- OpDescriptionSeq *&ptr_; ++ IR_OpDescriptionSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const OpDescriptionSeq_var &); ++ void operator= (const IR_OpDescriptionSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OpDescriptionSeq; +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_SEQUENCE_IR_ATTRDESCRIPTIONSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_SEQUENCE_IR_ATTRDESCRIPTIONSEQ_CH_ +- + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -19354,249 +11954,151 @@ + _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (CORBA::ULong maximum, + CORBA::ULong length, +- AttributeDescription *data, ++ IR_AttributeDescription *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq &rhs); + _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq &rhs); + virtual ~_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (void); // Dtor. + // = Accessors. +- AttributeDescription &operator[] (CORBA::ULong i); +- const AttributeDescription &operator[] (CORBA::ULong i) const; ++ IR_AttributeDescription &operator[] (CORBA::ULong i); ++ const IR_AttributeDescription &operator[] (CORBA::ULong i) const; + // = Static operations. +- static AttributeDescription *allocbuf (CORBA::ULong size); +- static void freebuf (AttributeDescription *buffer); ++ static IR_AttributeDescription *allocbuf (CORBA::ULong size); ++ static void freebuf (IR_AttributeDescription *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + +- AttributeDescription *get_buffer (CORBA::Boolean orphan = 0); +- const AttributeDescription *get_buffer (void) const; ++ IR_AttributeDescription *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_AttributeDescription *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, +- AttributeDescription *data, ++ IR_AttributeDescription *data, + CORBA::Boolean release); + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_ATTRDESCRIPTIONSEQ_CH_) +-#define _TAO_IR_ATTRDESCRIPTIONSEQ_CH_ +- +-class AttrDescriptionSeq; +-class AttrDescriptionSeq_var; +- + // ************************************************************* +-// AttrDescriptionSeq ++// IR_AttrDescriptionSeq + // ************************************************************* + +-class TAO_Export AttrDescriptionSeq : public ++class TAO_Export IR_AttrDescriptionSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Sequence<AttributeDescription> ++ TAO_Unbounded_Sequence<IR_AttributeDescription> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- AttrDescriptionSeq (void); // default ctor +- AttrDescriptionSeq (CORBA::ULong max); // uses max size +- AttrDescriptionSeq ( ++ IR_AttrDescriptionSeq (void); // default ctor ++ IR_AttrDescriptionSeq (CORBA::ULong max); // uses max size ++ IR_AttrDescriptionSeq ( + CORBA::ULong max, + CORBA::ULong length, +- AttributeDescription *buffer, ++ IR_AttributeDescription *buffer, + CORBA::Boolean release = 0 + ); +- AttrDescriptionSeq (const AttrDescriptionSeq &); // copy ctor +- ~AttrDescriptionSeq (void); ++ IR_AttrDescriptionSeq (const IR_AttrDescriptionSeq &); // copy ctor ++ ~IR_AttrDescriptionSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef AttrDescriptionSeq_var _var_type; ++ typedef IR_AttrDescriptionSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ATTRDESCRIPTIONSEQ___VAR_CH_) +-#define _TAO_IR_ATTRDESCRIPTIONSEQ___VAR_CH_ + + // ************************************************************* +-// class IR::AttrDescriptionSeq_var ++// class IR_AttrDescriptionSeq_var + // ************************************************************* + +-class TAO_Export AttrDescriptionSeq_var ++class TAO_Export IR_AttrDescriptionSeq_var + { + public: +- AttrDescriptionSeq_var (void); // default constructor +- AttrDescriptionSeq_var (AttrDescriptionSeq *); +- AttrDescriptionSeq_var (const AttrDescriptionSeq_var &); // copy constructor +- ~AttrDescriptionSeq_var (void); // destructor ++ IR_AttrDescriptionSeq_var (void); // default constructor ++ IR_AttrDescriptionSeq_var (IR_AttrDescriptionSeq *); ++ IR_AttrDescriptionSeq_var (const IR_AttrDescriptionSeq_var &); // copy constructor ++ ~IR_AttrDescriptionSeq_var (void); // destructor + +- AttrDescriptionSeq_var &operator= (AttrDescriptionSeq *); +- AttrDescriptionSeq_var &operator= (const AttrDescriptionSeq_var &); +- AttrDescriptionSeq *operator-> (void); +- const AttrDescriptionSeq *operator-> (void) const; ++ IR_AttrDescriptionSeq_var &operator= (IR_AttrDescriptionSeq *); ++ IR_AttrDescriptionSeq_var &operator= (const IR_AttrDescriptionSeq_var &); ++ IR_AttrDescriptionSeq *operator-> (void); ++ const IR_AttrDescriptionSeq *operator-> (void) const; + +- operator const AttrDescriptionSeq &() const; +- operator AttrDescriptionSeq &(); +- operator AttrDescriptionSeq &() const; +- operator AttrDescriptionSeq *&(); // variable-size base types only ++ operator const IR_AttrDescriptionSeq &() const; ++ operator IR_AttrDescriptionSeq &(); ++ operator IR_AttrDescriptionSeq &() const; ++ operator IR_AttrDescriptionSeq *&(); // variable-size base types only + +- AttributeDescription & operator[] (CORBA::ULong index); +- const AttributeDescription & operator[] (CORBA::ULong index) const; ++ IR_AttributeDescription & operator[] (CORBA::ULong index); ++ const IR_AttributeDescription & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn +- const AttrDescriptionSeq &in (void) const; +- AttrDescriptionSeq &inout (void); +- AttrDescriptionSeq *&out (void); +- AttrDescriptionSeq *_retn (void); +- AttrDescriptionSeq *ptr (void) const; ++ const IR_AttrDescriptionSeq &in (void) const; ++ IR_AttrDescriptionSeq &inout (void); ++ IR_AttrDescriptionSeq *&out (void); ++ IR_AttrDescriptionSeq *_retn (void); ++ IR_AttrDescriptionSeq *ptr (void) const; + + private: +- AttrDescriptionSeq *ptr_; ++ IR_AttrDescriptionSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_ATTRDESCRIPTIONSEQ___OUT_CH_) +-#define _TAO_IR_ATTRDESCRIPTIONSEQ___OUT_CH_ +- +-class TAO_Export AttrDescriptionSeq_out ++class TAO_Export IR_AttrDescriptionSeq_out + { + public: +- AttrDescriptionSeq_out (AttrDescriptionSeq *&); +- AttrDescriptionSeq_out (AttrDescriptionSeq_var &); +- AttrDescriptionSeq_out (const AttrDescriptionSeq_out &); +- AttrDescriptionSeq_out &operator= (const AttrDescriptionSeq_out &); +- AttrDescriptionSeq_out &operator= (AttrDescriptionSeq *); +- operator AttrDescriptionSeq *&(); +- AttrDescriptionSeq *&ptr (void); +- AttrDescriptionSeq *operator-> (void); +- AttributeDescription & operator[] (CORBA::ULong index); ++ IR_AttrDescriptionSeq_out (IR_AttrDescriptionSeq *&); ++ IR_AttrDescriptionSeq_out (IR_AttrDescriptionSeq_var &); ++ IR_AttrDescriptionSeq_out (const IR_AttrDescriptionSeq_out &); ++ IR_AttrDescriptionSeq_out &operator= (const IR_AttrDescriptionSeq_out &); ++ IR_AttrDescriptionSeq_out &operator= (IR_AttrDescriptionSeq *); ++ operator IR_AttrDescriptionSeq *&(); ++ IR_AttrDescriptionSeq *&ptr (void); ++ IR_AttrDescriptionSeq *operator-> (void); ++ IR_AttributeDescription & operator[] (CORBA::ULong index); + + private: +- AttrDescriptionSeq *&ptr_; ++ IR_AttrDescriptionSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const AttrDescriptionSeq_var &); ++ void operator= (const IR_AttrDescriptionSeq_var &); + }; + ++// Forward Classes Declaration ++class _TAO_InterfaceDef_Proxy_Impl; ++class _TAO_InterfaceDef_Remote_Proxy_Impl; ++class _TAO_InterfaceDef_Proxy_Broker; ++class _TAO_InterfaceDef_Remote_Proxy_Broker; + +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttrDescriptionSeq; +- +- +-#if !defined (_TAO_IR_INTERFACEDEF___PTR_CH_) +-#define _TAO_IR_INTERFACEDEF___PTR_CH_ +- +-class InterfaceDef; +-typedef InterfaceDef *InterfaceDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_INTERFACEDEF___VAR_CH_) +-#define _TAO_IR_INTERFACEDEF___VAR_CH_ +- +-class TAO_Export InterfaceDef_var : public TAO_Base_var +-{ +-public: +- InterfaceDef_var (void); // default constructor +- InterfaceDef_var (InterfaceDef_ptr p) : ptr_ (p) {} +- InterfaceDef_var (const InterfaceDef_var &); // copy constructor +- ~InterfaceDef_var (void); // destructor +- +- InterfaceDef_var &operator= (InterfaceDef_ptr); +- InterfaceDef_var &operator= (const InterfaceDef_var &); +- InterfaceDef_ptr operator-> (void) const; +- +- operator const InterfaceDef_ptr &() const; +- operator InterfaceDef_ptr &(); +- // in, inout, out, _retn +- InterfaceDef_ptr in (void) const; +- InterfaceDef_ptr &inout (void); +- InterfaceDef_ptr &out (void); +- InterfaceDef_ptr _retn (void); +- InterfaceDef_ptr ptr (void) const; +- +-private: +- InterfaceDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- InterfaceDef_var (const TAO_Base_var &rhs); +- InterfaceDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_INTERFACEDEF___OUT_CH_) +-#define _TAO_IR_INTERFACEDEF___OUT_CH_ +- +-class TAO_Export InterfaceDef_out +-{ +-public: +- InterfaceDef_out (InterfaceDef_ptr &); +- InterfaceDef_out (InterfaceDef_var &); +- InterfaceDef_out (const InterfaceDef_out &); +- InterfaceDef_out &operator= (const InterfaceDef_out &); +- InterfaceDef_out &operator= (const InterfaceDef_var &); +- InterfaceDef_out &operator= (InterfaceDef_ptr); +- operator InterfaceDef_ptr &(); +- InterfaceDef_ptr &ptr (void); +- InterfaceDef_ptr operator-> (void); +- +-private: +- InterfaceDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_INTERFACEDEF_CH_) +-#define _TAO_IR_INTERFACEDEF_CH_ +- +-// Forward Classes Declaration +-class _TAO_InterfaceDef_Proxy_Impl; +-class _TAO_InterfaceDef_Remote_Proxy_Impl; +-class _TAO_InterfaceDef_Proxy_Broker; +-class _TAO_InterfaceDef_Remote_Proxy_Broker; +- +-class TAO_Export InterfaceDef: public virtual Container, public virtual Contained, public virtual IDLType +-{ +-public: +-#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef InterfaceDef_ptr _ptr_type; +- typedef InterfaceDef_var _var_type; +-#endif /* ! __GNUC__ || g++ >= 2.8 */ ++class TAO_Export IR_InterfaceDef: public virtual IR_Container, public virtual IR_Contained, public virtual IR_IDLType ++{ ++public: ++#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) ++ typedef IR_InterfaceDef_ptr _ptr_type; ++ typedef IR_InterfaceDef_var _var_type; ++#endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static InterfaceDef_ptr _duplicate (InterfaceDef_ptr obj); +- static InterfaceDef_ptr _narrow ( ++ static IR_InterfaceDef_ptr _duplicate (IR_InterfaceDef_ptr obj); ++ static IR_InterfaceDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static InterfaceDef_ptr _unchecked_narrow ( ++ static IR_InterfaceDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static InterfaceDef_ptr _nil (void) ++ static IR_InterfaceDef_ptr _nil (void) + { +- return (InterfaceDef_ptr)0; ++ return (IR_InterfaceDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::InterfaceDefSeq * base_interfaces ( ++ virtual IR_InterfaceDefSeq * base_interfaces ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -19605,7 +12107,7 @@ + )); + + virtual void base_interfaces ( +- const IR::InterfaceDefSeq & base_interfaces, ++ const IR_InterfaceDefSeq & base_interfaces, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -19656,14 +12158,14 @@ + CORBA::SystemException + )); + +- virtual IR::AttributeDef_ptr create_attribute ( ++ virtual IR_AttributeDef_ptr create_attribute ( + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr type, +- IR::AttributeMode mode, +- const IR::ExceptionDefSeq & get_exceptions, +- const IR::ExceptionDefSeq & put_exceptions, ++ IR_IDLType_ptr type, ++ IR_AttributeMode mode, ++ const IR_ExceptionDefSeq & get_exceptions, ++ const IR_ExceptionDefSeq & put_exceptions, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -19671,15 +12173,15 @@ + CORBA::SystemException + )); + +- virtual IR::OperationDef_ptr create_operation ( ++ virtual IR_OperationDef_ptr create_operation ( + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr result, +- IR::OperationMode mode, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, +- const IR::ContextIdSeq & contexts, ++ IR_IDLType_ptr result, ++ IR_OperationMode mode, ++ const IR_ParDescriptionSeq & params, ++ const IR_ExceptionDefSeq & exceptions, ++ const IR_ContextIdSeq & contexts, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -19700,454 +12202,27 @@ + _TAO_InterfaceDef_Proxy_Broker *the_TAO_InterfaceDef_Proxy_Broker_; + + protected: +- InterfaceDef (int collocated = 0); ++ IR_InterfaceDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- InterfaceDef ( ++ IR_InterfaceDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_InterfaceDef_Remote_Proxy_Impl; +- friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_InterfaceDef_Direct_Proxy_Impl; +- +- virtual ~InterfaceDef (void); +- private: +- InterfaceDef (const InterfaceDef &); +- void operator= (const InterfaceDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::InterfaceDef; +- +- friend class _TAO_InterfaceDef_Remote_Proxy_Impl; +- friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_InterfaceDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_get (const TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_get &); +- void operator= (const TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_get &); +- void result (IR::InterfaceDefSeq * result); +- // update the result +- IR::InterfaceDefSeq * result_; +- }; +- +- class TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::InterfaceDef; +- +- friend class _TAO_InterfaceDef_Remote_Proxy_Impl; +- friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_InterfaceDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const IR::InterfaceDefSeq & base_interfaces, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_set (const TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_set &); +- void operator= (const TAO_ClientRequestInfo_IR_InterfaceDef_base_interfaces_set &); +- const IR::InterfaceDefSeq & base_interfaces_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::InterfaceDef; +- +- friend class _TAO_InterfaceDef_Remote_Proxy_Impl; +- friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_InterfaceDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_get (const TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_get &); +- void operator= (const TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_get &); +- void result (CORBA::Boolean result); +- // update the result +- CORBA::Boolean result_; +-}; +- +-class TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::InterfaceDef; +- +- friend class _TAO_InterfaceDef_Remote_Proxy_Impl; +- friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_InterfaceDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::Boolean & is_abstract, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_set (const TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_set &); +- void operator= (const TAO_ClientRequestInfo_IR_InterfaceDef_is_abstract_set &); +- const CORBA::Boolean & is_abstract_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_InterfaceDef_is_local_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::InterfaceDef; +- ++ + friend class _TAO_InterfaceDef_Remote_Proxy_Impl; + friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl; + friend class _TAO_InterfaceDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_InterfaceDef_is_local_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_InterfaceDef_is_local_get (const TAO_ClientRequestInfo_IR_InterfaceDef_is_local_get &); +- void operator= (const TAO_ClientRequestInfo_IR_InterfaceDef_is_local_get &); +- void result (CORBA::Boolean result); +- // update the result +- CORBA::Boolean result_; +-}; +- +-class TAO_ClientRequestInfo_IR_InterfaceDef_is_local_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::InterfaceDef; + +- friend class _TAO_InterfaceDef_Remote_Proxy_Impl; +- friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_InterfaceDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_InterfaceDef_is_local_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::Boolean & is_local, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_InterfaceDef (void); + private: +- TAO_ClientRequestInfo_IR_InterfaceDef_is_local_set (const TAO_ClientRequestInfo_IR_InterfaceDef_is_local_set &); +- void operator= (const TAO_ClientRequestInfo_IR_InterfaceDef_is_local_set &); +- const CORBA::Boolean & is_local_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_InterfaceDef_is_a : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::InterfaceDef; +- +- friend class _TAO_InterfaceDef_Remote_Proxy_Impl; +- friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_InterfaceDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_InterfaceDef_is_a ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * interface_id, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_InterfaceDef_is_a (const TAO_ClientRequestInfo_IR_InterfaceDef_is_a &); +- void operator= (const TAO_ClientRequestInfo_IR_InterfaceDef_is_a &); +- const char * interface_id_; +- void result (CORBA::Boolean result); +- // update the result +- CORBA::Boolean result_; +-}; +- +-class TAO_ClientRequestInfo_IR_InterfaceDef_create_attribute : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::InterfaceDef; +- +- friend class _TAO_InterfaceDef_Remote_Proxy_Impl; +- friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_InterfaceDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_InterfaceDef_create_attribute ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::IDLType_ptr type, +- IR::AttributeMode & mode, +- const IR::ExceptionDefSeq & get_exceptions, +- const IR::ExceptionDefSeq & put_exceptions, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_InterfaceDef_create_attribute (const TAO_ClientRequestInfo_IR_InterfaceDef_create_attribute &); +- void operator= (const TAO_ClientRequestInfo_IR_InterfaceDef_create_attribute &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::IDLType_ptr type_; +- const IR::AttributeMode & mode_; +- const IR::ExceptionDefSeq & get_exceptions_; +- const IR::ExceptionDefSeq & put_exceptions_; +- void result (IR::AttributeDef_ptr result); +- // update the result +- IR::AttributeDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_InterfaceDef_create_operation : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::InterfaceDef; +- +- friend class _TAO_InterfaceDef_Remote_Proxy_Impl; +- friend class _TAO_InterfaceDef_ThruPOA_Proxy_Impl; +- friend class _TAO_InterfaceDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_InterfaceDef_create_operation ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::IDLType_ptr result, +- IR::OperationMode & mode, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, +- const IR::ContextIdSeq & contexts, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_InterfaceDef_create_operation (const TAO_ClientRequestInfo_IR_InterfaceDef_create_operation &); +- void operator= (const TAO_ClientRequestInfo_IR_InterfaceDef_create_operation &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::IDLType_ptr result_; +- const IR::OperationMode & mode_; +- const IR::ParDescriptionSeq & params_; +- const IR::ExceptionDefSeq & exceptions_; +- const IR::ContextIdSeq & contexts_; +- void result (IR::OperationDef_ptr result); +- // update the result +- IR::OperationDef_ptr result_; +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_InterfaceDef (const IR_InterfaceDef &); ++ void operator= (const IR_InterfaceDef &); + }; + + +@@ -20161,14 +12236,14 @@ + // + + class TAO_Export _TAO_InterfaceDef_Proxy_Impl : +- public virtual IR::_TAO_Container_Proxy_Impl, +- public virtual IR::_TAO_Contained_Proxy_Impl, +- public virtual IR::_TAO_IDLType_Proxy_Impl ++ public virtual _TAO_Container_Proxy_Impl, ++ public virtual _TAO_Contained_Proxy_Impl, ++ public virtual _TAO_IDLType_Proxy_Impl + { + public: + virtual ~_TAO_InterfaceDef_Proxy_Impl (void) { } + +- virtual IR::InterfaceDefSeq * base_interfaces ( ++ virtual IR_InterfaceDefSeq * base_interfaces ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -20178,7 +12253,7 @@ + + virtual void base_interfaces ( + CORBA_Object *_collocated_tao_target_, +- const IR::InterfaceDefSeq & base_interfaces, ++ const IR_InterfaceDefSeq & base_interfaces, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -20228,31 +12303,31 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::AttributeDef_ptr create_attribute ( ++ virtual IR_AttributeDef_ptr create_attribute ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr type, +- IR::AttributeMode mode, +- const IR::ExceptionDefSeq & get_exceptions, +- const IR::ExceptionDefSeq & put_exceptions, ++ IR_IDLType_ptr type, ++ IR_AttributeMode mode, ++ const IR_ExceptionDefSeq & get_exceptions, ++ const IR_ExceptionDefSeq & put_exceptions, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::OperationDef_ptr create_operation ( ++ virtual IR_OperationDef_ptr create_operation ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr result, +- IR::OperationMode mode, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, +- const IR::ContextIdSeq & contexts, ++ IR_IDLType_ptr result, ++ IR_OperationMode mode, ++ const IR_ParDescriptionSeq & params, ++ const IR_ExceptionDefSeq & exceptions, ++ const IR_ContextIdSeq & contexts, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -20263,6 +12338,7 @@ + _TAO_InterfaceDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -20275,9 +12351,9 @@ + class TAO_Export _TAO_InterfaceDef_Remote_Proxy_Impl : + public virtual _TAO_InterfaceDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Container_Remote_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl, +- public virtual IR::_TAO_IDLType_Remote_Proxy_Impl ++ public virtual _TAO_Container_Remote_Proxy_Impl, ++ public virtual _TAO_Contained_Remote_Proxy_Impl, ++ public virtual _TAO_IDLType_Remote_Proxy_Impl + + { + public: +@@ -20285,7 +12361,7 @@ + + virtual ~_TAO_InterfaceDef_Remote_Proxy_Impl (void) { } + +- virtual IR::InterfaceDefSeq * base_interfaces ( ++ virtual IR_InterfaceDefSeq * base_interfaces ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -20295,7 +12371,7 @@ + + virtual void base_interfaces ( + CORBA_Object *_collocated_tao_target_, +- const IR::InterfaceDefSeq & base_interfaces, ++ const IR_InterfaceDefSeq & base_interfaces, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -20345,31 +12421,31 @@ + CORBA::SystemException + )); + +- virtual IR::AttributeDef_ptr create_attribute ( ++ virtual IR_AttributeDef_ptr create_attribute ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr type, +- IR::AttributeMode mode, +- const IR::ExceptionDefSeq & get_exceptions, +- const IR::ExceptionDefSeq & put_exceptions, ++ IR_IDLType_ptr type, ++ IR_AttributeMode mode, ++ const IR_ExceptionDefSeq & get_exceptions, ++ const IR_ExceptionDefSeq & put_exceptions, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::OperationDef_ptr create_operation ( ++ virtual IR_OperationDef_ptr create_operation ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr result, +- IR::OperationMode mode, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, +- const IR::ContextIdSeq & contexts, ++ IR_IDLType_ptr result, ++ IR_OperationMode mode, ++ const IR_ParDescriptionSeq & params, ++ const IR_ExceptionDefSeq & exceptions, ++ const IR_ContextIdSeq & contexts, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -20398,8 +12474,9 @@ + { + public: + virtual ~_TAO_InterfaceDef_Proxy_Broker (void); ++ + virtual _TAO_InterfaceDef_Proxy_Impl &select_proxy ( +- InterfaceDef *object, ++ IR_InterfaceDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -20424,9 +12501,9 @@ + _TAO_InterfaceDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_InterfaceDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_InterfaceDef_Proxy_Impl &select_proxy ( +- InterfaceDef *object, ++ IR_InterfaceDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -20440,24 +12517,15 @@ + static _TAO_InterfaceDef_Remote_Proxy_Broker *the_TAO_InterfaceDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDef; +- +-struct InterfaceDescription; +-class InterfaceDescription_var; +- +-struct TAO_Export InterfaceDescription ++struct TAO_Export IR_InterfaceDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef InterfaceDescription_var _var_type; ++ typedef IR_InterfaceDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -20466,71 +12534,66 @@ + TAO_String_Manager id; + TAO_String_Manager defined_in; + TAO_String_Manager version; +- ACE_NESTED_CLASS (IR, OpDescriptionSeq) operations; +- ACE_NESTED_CLASS (IR, AttrDescriptionSeq) attributes; +- ACE_NESTED_CLASS (IR, RepositoryIdSeq) base_interfaces; ++ IR_OpDescriptionSeq operations; ++ IR_AttrDescriptionSeq attributes; ++ IR_RepositoryIdSeq base_interfaces; + CORBA::TypeCode_var type; + CORBA::Boolean is_abstract; + CORBA::Boolean is_local; + }; + +-class TAO_Export InterfaceDescription_var ++class TAO_Export IR_InterfaceDescription_var + { + public: +- InterfaceDescription_var (void); // default constructor +- InterfaceDescription_var (InterfaceDescription *); +- InterfaceDescription_var (const InterfaceDescription_var &); // copy constructor +- ~InterfaceDescription_var (void); // destructor +- +- InterfaceDescription_var &operator= (InterfaceDescription *); +- InterfaceDescription_var &operator= (const InterfaceDescription_var &); +- InterfaceDescription *operator-> (void); +- const InterfaceDescription *operator-> (void) const; +- +- operator const InterfaceDescription &() const; +- operator InterfaceDescription &(); +- operator InterfaceDescription &() const; +- operator InterfaceDescription *&(); // variable-size types only ++ IR_InterfaceDescription_var (void); // default constructor ++ IR_InterfaceDescription_var (IR_InterfaceDescription *); ++ IR_InterfaceDescription_var (const IR_InterfaceDescription_var &); // copy constructor ++ ~IR_InterfaceDescription_var (void); // destructor ++ ++ IR_InterfaceDescription_var &operator= (IR_InterfaceDescription *); ++ IR_InterfaceDescription_var &operator= (const IR_InterfaceDescription_var &); ++ IR_InterfaceDescription *operator-> (void); ++ const IR_InterfaceDescription *operator-> (void) const; ++ ++ operator const IR_InterfaceDescription &() const; ++ operator IR_InterfaceDescription &(); ++ operator IR_InterfaceDescription &() const; ++ operator IR_InterfaceDescription *&(); // variable-size types only + + // in, inout, out, _retn +- const InterfaceDescription &in (void) const; +- InterfaceDescription &inout (void); +- InterfaceDescription *&out (void); +- InterfaceDescription *_retn (void); +- InterfaceDescription *ptr (void) const; ++ const IR_InterfaceDescription &in (void) const; ++ IR_InterfaceDescription &inout (void); ++ IR_InterfaceDescription *&out (void); ++ IR_InterfaceDescription *_retn (void); ++ IR_InterfaceDescription *ptr (void) const; + + private: +- InterfaceDescription *ptr_; ++ IR_InterfaceDescription *ptr_; + }; + +-class TAO_Export InterfaceDescription_out ++class TAO_Export IR_InterfaceDescription_out + { + public: +- InterfaceDescription_out (InterfaceDescription *&); +- InterfaceDescription_out (InterfaceDescription_var &); +- InterfaceDescription_out (const InterfaceDescription_out &); +- InterfaceDescription_out &operator= (const InterfaceDescription_out &); +- InterfaceDescription_out &operator= (InterfaceDescription *); +- operator InterfaceDescription *&(); +- InterfaceDescription *&ptr (void); +- InterfaceDescription *operator-> (void); ++ IR_InterfaceDescription_out (IR_InterfaceDescription *&); ++ IR_InterfaceDescription_out (IR_InterfaceDescription_var &); ++ IR_InterfaceDescription_out (const IR_InterfaceDescription_out &); ++ IR_InterfaceDescription_out &operator= (const IR_InterfaceDescription_out &); ++ IR_InterfaceDescription_out &operator= (IR_InterfaceDescription *); ++ operator IR_InterfaceDescription *&(); ++ IR_InterfaceDescription *&ptr (void); ++ IR_InterfaceDescription *operator-> (void); + + private: +- InterfaceDescription *&ptr_; ++ IR_InterfaceDescription *&ptr_; + // assignment from T_var not allowed +- void operator= (const InterfaceDescription_var &); ++ void operator= (const IR_InterfaceDescription_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDescription; +- +-struct ValueMember; +-class ValueMember_var; +- +-struct TAO_Export ValueMember ++struct TAO_Export IR_ValueMember + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ValueMember_var _var_type; ++ typedef IR_ValueMember_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -20540,65 +12603,59 @@ + TAO_String_Manager defined_in; + TAO_String_Manager version; + CORBA::TypeCode_var type; +- ACE_NESTED_CLASS (IR, IDLType_var) type_def; ++ IR_IDLType_var type_def; + CORBA::Visibility access; + }; + +-class TAO_Export ValueMember_var ++class TAO_Export IR_ValueMember_var + { + public: +- ValueMember_var (void); // default constructor +- ValueMember_var (ValueMember *); +- ValueMember_var (const ValueMember_var &); // copy constructor +- ~ValueMember_var (void); // destructor +- +- ValueMember_var &operator= (ValueMember *); +- ValueMember_var &operator= (const ValueMember_var &); +- ValueMember *operator-> (void); +- const ValueMember *operator-> (void) const; +- +- operator const ValueMember &() const; +- operator ValueMember &(); +- operator ValueMember &() const; +- operator ValueMember *&(); // variable-size types only ++ IR_ValueMember_var (void); // default constructor ++ IR_ValueMember_var (IR_ValueMember *); ++ IR_ValueMember_var (const IR_ValueMember_var &); // copy constructor ++ ~IR_ValueMember_var (void); // destructor ++ ++ IR_ValueMember_var &operator= (IR_ValueMember *); ++ IR_ValueMember_var &operator= (const IR_ValueMember_var &); ++ IR_ValueMember *operator-> (void); ++ const IR_ValueMember *operator-> (void) const; ++ ++ operator const IR_ValueMember &() const; ++ operator IR_ValueMember &(); ++ operator IR_ValueMember &() const; ++ operator IR_ValueMember *&(); // variable-size types only + + // in, inout, out, _retn +- const ValueMember &in (void) const; +- ValueMember &inout (void); +- ValueMember *&out (void); +- ValueMember *_retn (void); +- ValueMember *ptr (void) const; ++ const IR_ValueMember &in (void) const; ++ IR_ValueMember &inout (void); ++ IR_ValueMember *&out (void); ++ IR_ValueMember *_retn (void); ++ IR_ValueMember *ptr (void) const; + + private: +- ValueMember *ptr_; ++ IR_ValueMember *ptr_; + }; + +-class TAO_Export ValueMember_out ++class TAO_Export IR_ValueMember_out + { + public: +- ValueMember_out (ValueMember *&); +- ValueMember_out (ValueMember_var &); +- ValueMember_out (const ValueMember_out &); +- ValueMember_out &operator= (const ValueMember_out &); +- ValueMember_out &operator= (ValueMember *); +- operator ValueMember *&(); +- ValueMember *&ptr (void); +- ValueMember *operator-> (void); ++ IR_ValueMember_out (IR_ValueMember *&); ++ IR_ValueMember_out (IR_ValueMember_var &); ++ IR_ValueMember_out (const IR_ValueMember_out &); ++ IR_ValueMember_out &operator= (const IR_ValueMember_out &); ++ IR_ValueMember_out &operator= (IR_ValueMember *); ++ operator IR_ValueMember *&(); ++ IR_ValueMember *&ptr (void); ++ IR_ValueMember *operator-> (void); + + private: +- ValueMember *&ptr_; ++ IR_ValueMember *&ptr_; + // assignment from T_var not allowed +- void operator= (const ValueMember_var &); ++ void operator= (const IR_ValueMember_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMember; +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_SEQUENCE_IR_VALUEMEMBERSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_SEQUENCE_IR_VALUEMEMBERSEQ_CH_ +- + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ValueMemberSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -20608,258 +12665,204 @@ + _TAO_Unbounded_Sequence_IR_ValueMemberSeq (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_IR_ValueMemberSeq (CORBA::ULong maximum, + CORBA::ULong length, +- ValueMember *data, ++ IR_ValueMember *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_IR_ValueMemberSeq (const _TAO_Unbounded_Sequence_IR_ValueMemberSeq &rhs); + _TAO_Unbounded_Sequence_IR_ValueMemberSeq &operator= (const _TAO_Unbounded_Sequence_IR_ValueMemberSeq &rhs); + virtual ~_TAO_Unbounded_Sequence_IR_ValueMemberSeq (void); // Dtor. + // = Accessors. +- ValueMember &operator[] (CORBA::ULong i); +- const ValueMember &operator[] (CORBA::ULong i) const; ++ IR_ValueMember &operator[] (CORBA::ULong i); ++ const IR_ValueMember &operator[] (CORBA::ULong i) const; + // = Static operations. +- static ValueMember *allocbuf (CORBA::ULong size); +- static void freebuf (ValueMember *buffer); ++ static IR_ValueMember *allocbuf (CORBA::ULong size); ++ static void freebuf (IR_ValueMember *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + +- ValueMember *get_buffer (CORBA::Boolean orphan = 0); +- const ValueMember *get_buffer (void) const; ++ IR_ValueMember *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_ValueMember *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, +- ValueMember *data, ++ IR_ValueMember *data, + CORBA::Boolean release); + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_VALUEMEMBERSEQ_CH_) +-#define _TAO_IR_VALUEMEMBERSEQ_CH_ +- +-class ValueMemberSeq; +-class ValueMemberSeq_var; +- + // ************************************************************* +-// ValueMemberSeq ++// IR_ValueMemberSeq + // ************************************************************* + +-class TAO_Export ValueMemberSeq : public ++class TAO_Export IR_ValueMemberSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IR_ValueMemberSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Sequence<ValueMember> ++ TAO_Unbounded_Sequence<IR_ValueMember> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- ValueMemberSeq (void); // default ctor +- ValueMemberSeq (CORBA::ULong max); // uses max size +- ValueMemberSeq ( ++ IR_ValueMemberSeq (void); // default ctor ++ IR_ValueMemberSeq (CORBA::ULong max); // uses max size ++ IR_ValueMemberSeq ( + CORBA::ULong max, + CORBA::ULong length, +- ValueMember *buffer, ++ IR_ValueMember *buffer, + CORBA::Boolean release = 0 + ); +- ValueMemberSeq (const ValueMemberSeq &); // copy ctor +- ~ValueMemberSeq (void); ++ IR_ValueMemberSeq (const IR_ValueMemberSeq &); // copy ctor ++ ~IR_ValueMemberSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ValueMemberSeq_var _var_type; ++ typedef IR_ValueMemberSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEMEMBERSEQ___VAR_CH_) +-#define _TAO_IR_VALUEMEMBERSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::ValueMemberSeq_var ++// class IR_ValueMemberSeq_var + // ************************************************************* + +-class TAO_Export ValueMemberSeq_var ++class TAO_Export IR_ValueMemberSeq_var + { + public: +- ValueMemberSeq_var (void); // default constructor +- ValueMemberSeq_var (ValueMemberSeq *); +- ValueMemberSeq_var (const ValueMemberSeq_var &); // copy constructor +- ~ValueMemberSeq_var (void); // destructor ++ IR_ValueMemberSeq_var (void); // default constructor ++ IR_ValueMemberSeq_var (IR_ValueMemberSeq *); ++ IR_ValueMemberSeq_var (const IR_ValueMemberSeq_var &); // copy constructor ++ ~IR_ValueMemberSeq_var (void); // destructor + +- ValueMemberSeq_var &operator= (ValueMemberSeq *); +- ValueMemberSeq_var &operator= (const ValueMemberSeq_var &); +- ValueMemberSeq *operator-> (void); +- const ValueMemberSeq *operator-> (void) const; ++ IR_ValueMemberSeq_var &operator= (IR_ValueMemberSeq *); ++ IR_ValueMemberSeq_var &operator= (const IR_ValueMemberSeq_var &); ++ IR_ValueMemberSeq *operator-> (void); ++ const IR_ValueMemberSeq *operator-> (void) const; + +- operator const ValueMemberSeq &() const; +- operator ValueMemberSeq &(); +- operator ValueMemberSeq &() const; +- operator ValueMemberSeq *&(); // variable-size base types only ++ operator const IR_ValueMemberSeq &() const; ++ operator IR_ValueMemberSeq &(); ++ operator IR_ValueMemberSeq &() const; ++ operator IR_ValueMemberSeq *&(); // variable-size base types only + +- ValueMember & operator[] (CORBA::ULong index); +- const ValueMember & operator[] (CORBA::ULong index) const; ++ IR_ValueMember & operator[] (CORBA::ULong index); ++ const IR_ValueMember & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn +- const ValueMemberSeq &in (void) const; +- ValueMemberSeq &inout (void); +- ValueMemberSeq *&out (void); +- ValueMemberSeq *_retn (void); +- ValueMemberSeq *ptr (void) const; ++ const IR_ValueMemberSeq &in (void) const; ++ IR_ValueMemberSeq &inout (void); ++ IR_ValueMemberSeq *&out (void); ++ IR_ValueMemberSeq *_retn (void); ++ IR_ValueMemberSeq *ptr (void) const; + + private: +- ValueMemberSeq *ptr_; ++ IR_ValueMemberSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEMEMBERSEQ___OUT_CH_) +-#define _TAO_IR_VALUEMEMBERSEQ___OUT_CH_ +- +-class TAO_Export ValueMemberSeq_out ++class TAO_Export IR_ValueMemberSeq_out + { + public: +- ValueMemberSeq_out (ValueMemberSeq *&); +- ValueMemberSeq_out (ValueMemberSeq_var &); +- ValueMemberSeq_out (const ValueMemberSeq_out &); +- ValueMemberSeq_out &operator= (const ValueMemberSeq_out &); +- ValueMemberSeq_out &operator= (ValueMemberSeq *); +- operator ValueMemberSeq *&(); +- ValueMemberSeq *&ptr (void); +- ValueMemberSeq *operator-> (void); +- ValueMember & operator[] (CORBA::ULong index); ++ IR_ValueMemberSeq_out (IR_ValueMemberSeq *&); ++ IR_ValueMemberSeq_out (IR_ValueMemberSeq_var &); ++ IR_ValueMemberSeq_out (const IR_ValueMemberSeq_out &); ++ IR_ValueMemberSeq_out &operator= (const IR_ValueMemberSeq_out &); ++ IR_ValueMemberSeq_out &operator= (IR_ValueMemberSeq *); ++ operator IR_ValueMemberSeq *&(); ++ IR_ValueMemberSeq *&ptr (void); ++ IR_ValueMemberSeq *operator-> (void); ++ IR_ValueMember & operator[] (CORBA::ULong index); + + private: +- ValueMemberSeq *&ptr_; ++ IR_ValueMemberSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const ValueMemberSeq_var &); ++ void operator= (const IR_ValueMemberSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMemberSeq; +- +- +-#if !defined (_TAO_IR_VALUEMEMBERDEF___PTR_CH_) +-#define _TAO_IR_VALUEMEMBERDEF___PTR_CH_ +- +-class ValueMemberDef; +-typedef ValueMemberDef *ValueMemberDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEMEMBERDEF___VAR_CH_) +-#define _TAO_IR_VALUEMEMBERDEF___VAR_CH_ +- +-class TAO_Export ValueMemberDef_var : public TAO_Base_var ++class TAO_Export IR_ValueMemberDef_var : public TAO_Base_var + { + public: +- ValueMemberDef_var (void); // default constructor +- ValueMemberDef_var (ValueMemberDef_ptr p) : ptr_ (p) {} +- ValueMemberDef_var (const ValueMemberDef_var &); // copy constructor +- ~ValueMemberDef_var (void); // destructor ++ IR_ValueMemberDef_var (void); // default constructor ++ IR_ValueMemberDef_var (IR_ValueMemberDef_ptr p) : ptr_ (p) {} ++ IR_ValueMemberDef_var (const IR_ValueMemberDef_var &); // copy constructor ++ ~IR_ValueMemberDef_var (void); // destructor + +- ValueMemberDef_var &operator= (ValueMemberDef_ptr); +- ValueMemberDef_var &operator= (const ValueMemberDef_var &); +- ValueMemberDef_ptr operator-> (void) const; ++ IR_ValueMemberDef_var &operator= (IR_ValueMemberDef_ptr); ++ IR_ValueMemberDef_var &operator= (const IR_ValueMemberDef_var &); ++ IR_ValueMemberDef_ptr operator-> (void) const; + +- operator const ValueMemberDef_ptr &() const; +- operator ValueMemberDef_ptr &(); ++ operator const IR_ValueMemberDef_ptr &() const; ++ operator IR_ValueMemberDef_ptr &(); + // in, inout, out, _retn +- ValueMemberDef_ptr in (void) const; +- ValueMemberDef_ptr &inout (void); +- ValueMemberDef_ptr &out (void); +- ValueMemberDef_ptr _retn (void); +- ValueMemberDef_ptr ptr (void) const; ++ IR_ValueMemberDef_ptr in (void) const; ++ IR_ValueMemberDef_ptr &inout (void); ++ IR_ValueMemberDef_ptr &out (void); ++ IR_ValueMemberDef_ptr _retn (void); ++ IR_ValueMemberDef_ptr ptr (void) const; + + private: +- ValueMemberDef_ptr ptr_; ++ IR_ValueMemberDef_ptr ptr_; + // Unimplemented - prevents widening assignment. +- ValueMemberDef_var (const TAO_Base_var &rhs); +- ValueMemberDef_var &operator= (const TAO_Base_var &rhs); ++ IR_ValueMemberDef_var (const TAO_Base_var &rhs); ++ IR_ValueMemberDef_var &operator= (const TAO_Base_var &rhs); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEMEMBERDEF___OUT_CH_) +-#define _TAO_IR_VALUEMEMBERDEF___OUT_CH_ +- +-class TAO_Export ValueMemberDef_out ++class TAO_Export IR_ValueMemberDef_out + { + public: +- ValueMemberDef_out (ValueMemberDef_ptr &); +- ValueMemberDef_out (ValueMemberDef_var &); +- ValueMemberDef_out (const ValueMemberDef_out &); +- ValueMemberDef_out &operator= (const ValueMemberDef_out &); +- ValueMemberDef_out &operator= (const ValueMemberDef_var &); +- ValueMemberDef_out &operator= (ValueMemberDef_ptr); +- operator ValueMemberDef_ptr &(); +- ValueMemberDef_ptr &ptr (void); +- ValueMemberDef_ptr operator-> (void); ++ IR_ValueMemberDef_out (IR_ValueMemberDef_ptr &); ++ IR_ValueMemberDef_out (IR_ValueMemberDef_var &); ++ IR_ValueMemberDef_out (const IR_ValueMemberDef_out &); ++ IR_ValueMemberDef_out &operator= (const IR_ValueMemberDef_out &); ++ IR_ValueMemberDef_out &operator= (const IR_ValueMemberDef_var &); ++ IR_ValueMemberDef_out &operator= (IR_ValueMemberDef_ptr); ++ operator IR_ValueMemberDef_ptr &(); ++ IR_ValueMemberDef_ptr &ptr (void); ++ IR_ValueMemberDef_ptr operator-> (void); + + private: +- ValueMemberDef_ptr &ptr_; ++ IR_ValueMemberDef_ptr &ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEMEMBERDEF_CH_) +-#define _TAO_IR_VALUEMEMBERDEF_CH_ +- + // Forward Classes Declaration + class _TAO_ValueMemberDef_Proxy_Impl; + class _TAO_ValueMemberDef_Remote_Proxy_Impl; + class _TAO_ValueMemberDef_Proxy_Broker; + class _TAO_ValueMemberDef_Remote_Proxy_Broker; + +-class TAO_Export ValueMemberDef: public virtual Contained ++class TAO_Export IR_ValueMemberDef: public virtual IR_Contained + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ValueMemberDef_ptr _ptr_type; +- typedef ValueMemberDef_var _var_type; ++ typedef IR_ValueMemberDef_ptr _ptr_type; ++ typedef IR_ValueMemberDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static ValueMemberDef_ptr _duplicate (ValueMemberDef_ptr obj); +- static ValueMemberDef_ptr _narrow ( ++ static IR_ValueMemberDef_ptr _duplicate (IR_ValueMemberDef_ptr obj); ++ static IR_ValueMemberDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ValueMemberDef_ptr _unchecked_narrow ( ++ static IR_ValueMemberDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ValueMemberDef_ptr _nil (void) ++ static IR_ValueMemberDef_ptr _nil (void) + { +- return (ValueMemberDef_ptr)0; ++ return (IR_ValueMemberDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual CORBA::TypeCode_ptr type ( +- CORBA::Environment &ACE_TRY_ENV = ++ virtual CORBA::TypeCode_ptr type ( ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr type_def ( +- CORBA::Environment &ACE_TRY_ENV = ++ virtual IR_IDLType_ptr type_def ( ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( +@@ -20867,7 +12870,7 @@ + )); + + virtual void type_def ( +- IR::IDLType_ptr type_def, ++ IR_IDLType_ptr type_def, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -20905,251 +12908,28 @@ + _TAO_ValueMemberDef_Proxy_Broker *the_TAO_ValueMemberDef_Proxy_Broker_; + + protected: +- ValueMemberDef (int collocated = 0); ++ IR_ValueMemberDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- ValueMemberDef ( ++ IR_ValueMemberDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); ++ ); + +- friend class _TAO_ValueMemberDef_Remote_Proxy_Impl; +- friend class _TAO_ValueMemberDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueMemberDef_Direct_Proxy_Impl; ++ friend class _TAO_ValueMemberDef_Remote_Proxy_Impl; ++ friend class _TAO_ValueMemberDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_ValueMemberDef_Direct_Proxy_Impl; + +- virtual ~ValueMemberDef (void); +- private: +- ValueMemberDef (const ValueMemberDef &); +- void operator= (const ValueMemberDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_ValueMemberDef_type_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ValueMemberDef; +- +- friend class _TAO_ValueMemberDef_Remote_Proxy_Impl; +- friend class _TAO_ValueMemberDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueMemberDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ValueMemberDef_type_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_ValueMemberDef_type_get (const TAO_ClientRequestInfo_IR_ValueMemberDef_type_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueMemberDef_type_get &); +- void result (CORBA::TypeCode_ptr result); +- // update the result +- CORBA::TypeCode_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ValueMemberDef; +- +- friend class _TAO_ValueMemberDef_Remote_Proxy_Impl; +- friend class _TAO_ValueMemberDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueMemberDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_get (const TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_get &); +- void result (IR::IDLType_ptr result); +- // update the result +- IR::IDLType_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueMemberDef; +- +- friend class _TAO_ValueMemberDef_Remote_Proxy_Impl; +- friend class _TAO_ValueMemberDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueMemberDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::IDLType_ptr type_def, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_set (const TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueMemberDef_type_def_set &); +- IR::IDLType_ptr type_def_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_ValueMemberDef_access_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueMemberDef; +- +- friend class _TAO_ValueMemberDef_Remote_Proxy_Impl; +- friend class _TAO_ValueMemberDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueMemberDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueMemberDef_access_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueMemberDef_access_get (const TAO_ClientRequestInfo_IR_ValueMemberDef_access_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueMemberDef_access_get &); +- void result (CORBA::Visibility result); +- // update the result +- CORBA::Visibility result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ValueMemberDef_access_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueMemberDef; +- +- friend class _TAO_ValueMemberDef_Remote_Proxy_Impl; +- friend class _TAO_ValueMemberDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueMemberDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueMemberDef_access_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::Visibility & access, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueMemberDef_access_set (const TAO_ClientRequestInfo_IR_ValueMemberDef_access_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueMemberDef_access_set &); +- const CORBA::Visibility & access_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- +-}; ++ virtual ~IR_ValueMemberDef (void); ++private: ++ IR_ValueMemberDef (const IR_ValueMemberDef &); ++ void operator= (const IR_ValueMemberDef &); ++}; + + + // The Proxy Implementations are used by each interface to +@@ -21162,12 +12942,12 @@ + // + + class TAO_Export _TAO_ValueMemberDef_Proxy_Impl : +- public virtual IR::_TAO_Contained_Proxy_Impl ++ public virtual _TAO_Contained_Proxy_Impl + { + public: + virtual ~_TAO_ValueMemberDef_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr type ( ++ virtual CORBA::TypeCode_ptr type ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -21175,7 +12955,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::IDLType_ptr type_def ( ++ virtual IR_IDLType_ptr type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -21185,7 +12965,7 @@ + + virtual void type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr type_def, ++ IR_IDLType_ptr type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -21213,6 +12993,7 @@ + _TAO_ValueMemberDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -21225,7 +13006,7 @@ + class TAO_Export _TAO_ValueMemberDef_Remote_Proxy_Impl : + public virtual _TAO_ValueMemberDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl ++ public virtual _TAO_Contained_Remote_Proxy_Impl + + { + public: +@@ -21233,15 +13014,15 @@ + + virtual ~_TAO_ValueMemberDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::TypeCode_ptr type ( ++ virtual CORBA::TypeCode_ptr type ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::IDLType_ptr type_def ( ++ virtual IR_IDLType_ptr type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -21251,7 +13032,7 @@ + + virtual void type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr type_def, ++ IR_IDLType_ptr type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -21297,8 +13078,9 @@ + { + public: + virtual ~_TAO_ValueMemberDef_Proxy_Broker (void); ++ + virtual _TAO_ValueMemberDef_Proxy_Impl &select_proxy ( +- ValueMemberDef *object, ++ IR_ValueMemberDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -21323,9 +13105,9 @@ + _TAO_ValueMemberDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_ValueMemberDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_ValueMemberDef_Proxy_Impl &select_proxy ( +- ValueMemberDef *object, ++ IR_ValueMemberDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -21339,122 +13121,44 @@ + static _TAO_ValueMemberDef_Remote_Proxy_Broker *the_TAO_ValueMemberDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMemberDef; +- +- +-#if !defined (_TAO_IR_VALUEDEF___PTR_CH_) +-#define _TAO_IR_VALUEDEF___PTR_CH_ +- +-class ValueDef; +-typedef ValueDef *ValueDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEDEF___VAR_CH_) +-#define _TAO_IR_VALUEDEF___VAR_CH_ +- +-class TAO_Export ValueDef_var : public TAO_Base_var +-{ +-public: +- ValueDef_var (void); // default constructor +- ValueDef_var (ValueDef_ptr p) : ptr_ (p) {} +- ValueDef_var (const ValueDef_var &); // copy constructor +- ~ValueDef_var (void); // destructor +- +- ValueDef_var &operator= (ValueDef_ptr); +- ValueDef_var &operator= (const ValueDef_var &); +- ValueDef_ptr operator-> (void) const; +- +- operator const ValueDef_ptr &() const; +- operator ValueDef_ptr &(); +- // in, inout, out, _retn +- ValueDef_ptr in (void) const; +- ValueDef_ptr &inout (void); +- ValueDef_ptr &out (void); +- ValueDef_ptr _retn (void); +- ValueDef_ptr ptr (void) const; +- +-private: +- ValueDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- ValueDef_var (const TAO_Base_var &rhs); +- ValueDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEDEF___OUT_CH_) +-#define _TAO_IR_VALUEDEF___OUT_CH_ +- +-class TAO_Export ValueDef_out +-{ +-public: +- ValueDef_out (ValueDef_ptr &); +- ValueDef_out (ValueDef_var &); +- ValueDef_out (const ValueDef_out &); +- ValueDef_out &operator= (const ValueDef_out &); +- ValueDef_out &operator= (const ValueDef_var &); +- ValueDef_out &operator= (ValueDef_ptr); +- operator ValueDef_ptr &(); +- ValueDef_ptr &ptr (void); +- ValueDef_ptr operator-> (void); +- +-private: +- ValueDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEDEF_CH_) +-#define _TAO_IR_VALUEDEF_CH_ +- + // Forward Classes Declaration + class _TAO_ValueDef_Proxy_Impl; + class _TAO_ValueDef_Remote_Proxy_Impl; + class _TAO_ValueDef_Proxy_Broker; + class _TAO_ValueDef_Remote_Proxy_Broker; + +-class TAO_Export ValueDef: public virtual Container, public virtual Contained, public virtual IDLType ++class TAO_Export IR_ValueDef: public virtual IR_Container, public virtual IR_Contained, public virtual IR_IDLType + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ValueDef_ptr _ptr_type; +- typedef ValueDef_var _var_type; ++ typedef IR_ValueDef_ptr _ptr_type; ++ typedef IR_ValueDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static ValueDef_ptr _duplicate (ValueDef_ptr obj); +- static ValueDef_ptr _narrow ( ++ static IR_ValueDef_ptr _duplicate (IR_ValueDef_ptr obj); ++ static IR_ValueDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ValueDef_ptr _unchecked_narrow ( ++ static IR_ValueDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ValueDef_ptr _nil (void) ++ static IR_ValueDef_ptr _nil (void) + { +- return (ValueDef_ptr)0; ++ return (IR_ValueDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::InterfaceDefSeq * supported_interfaces ( ++ virtual IR_InterfaceDefSeq * supported_interfaces ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -21463,7 +13167,7 @@ + )); + + virtual void supported_interfaces ( +- const IR::InterfaceDefSeq & supported_interfaces, ++ const IR_InterfaceDefSeq & supported_interfaces, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -21471,7 +13175,7 @@ + CORBA::SystemException + )); + +- virtual IR::InitializerSeq * initializers ( ++ virtual IR_InitializerSeq * initializers ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -21480,7 +13184,7 @@ + )); + + virtual void initializers ( +- const IR::InitializerSeq & initializers, ++ const IR_InitializerSeq & initializers, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -21488,7 +13192,7 @@ + CORBA::SystemException + )); + +- virtual IR::ValueDef_ptr base_value ( ++ virtual IR_ValueDef_ptr base_value ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -21497,7 +13201,7 @@ + )); + + virtual void base_value ( +- IR::ValueDef_ptr base_value, ++ IR_ValueDef_ptr base_value, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -21505,7 +13209,7 @@ + CORBA::SystemException + )); + +- virtual IR::ValueDefSeq * abstract_base_values ( ++ virtual IR_ValueDefSeq * abstract_base_values ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -21514,7 +13218,7 @@ + )); + + virtual void abstract_base_values ( +- const IR::ValueDefSeq & abstract_base_values, ++ const IR_ValueDefSeq & abstract_base_values, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -21582,11 +13286,11 @@ + CORBA::SystemException + )); + +- virtual IR::ValueMemberDef_ptr create_value_member ( ++ virtual IR_ValueMemberDef_ptr create_value_member ( + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr type, ++ IR_IDLType_ptr type, + CORBA::Visibility access, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () +@@ -21595,14 +13299,14 @@ + CORBA::SystemException + )); + +- virtual IR::AttributeDef_ptr create_attribute ( ++ virtual IR_AttributeDef_ptr create_attribute ( + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr type, +- IR::AttributeMode mode, +- const IR::ExceptionDefSeq & get_exceptions, +- const IR::ExceptionDefSeq & put_exceptions, ++ IR_IDLType_ptr type, ++ IR_AttributeMode mode, ++ const IR_ExceptionDefSeq & get_exceptions, ++ const IR_ExceptionDefSeq & put_exceptions, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -21610,15 +13314,15 @@ + CORBA::SystemException + )); + +- virtual IR::OperationDef_ptr create_operation ( ++ virtual IR_OperationDef_ptr create_operation ( + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr result, +- IR::OperationMode mode, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, +- const IR::ContextIdSeq & contexts, ++ IR_IDLType_ptr result, ++ IR_OperationMode mode, ++ const IR_ParDescriptionSeq & params, ++ const IR_ExceptionDefSeq & exceptions, ++ const IR_ContextIdSeq & contexts, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -21639,923 +13343,99 @@ + _TAO_ValueDef_Proxy_Broker *the_TAO_ValueDef_Proxy_Broker_; + + protected: +- ValueDef (int collocated = 0); ++ IR_ValueDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- ValueDef ( ++ IR_ValueDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +- virtual ~ValueDef (void); +- private: +- ValueDef (const ValueDef &); +- void operator= (const ValueDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_get (const TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_get &); +- void result (IR::InterfaceDefSeq * result); +- // update the result +- IR::InterfaceDefSeq * result_; +- }; +- +- class TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const IR::InterfaceDefSeq & supported_interfaces, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_set (const TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_supported_interfaces_set &); +- const IR::InterfaceDefSeq & supported_interfaces_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_initializers_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- ++ + friend class _TAO_ValueDef_Remote_Proxy_Impl; + friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; + friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_initializers_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ ++ virtual ~IR_ValueDef (void); + private: +- TAO_ClientRequestInfo_IR_ValueDef_initializers_get (const TAO_ClientRequestInfo_IR_ValueDef_initializers_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_initializers_get &); +- void result (IR::InitializerSeq * result); +- // update the result +- IR::InitializerSeq * result_; ++ IR_ValueDef (const IR_ValueDef &); ++ void operator= (const IR_ValueDef &); + }; + +-class TAO_ClientRequestInfo_IR_ValueDef_initializers_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_initializers_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const IR::InitializerSeq & initializers, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); + +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++// The Proxy Implementations are used by each interface to ++// perform a call. Each different implementation encapsulate ++// an invocation logics. + +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); + +-private: +- TAO_ClientRequestInfo_IR_ValueDef_initializers_set (const TAO_ClientRequestInfo_IR_ValueDef_initializers_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_initializers_set &); +- const IR::InitializerSeq & initializers_; +- +-}; ++/////////////////////////////////////////////////////////////////////// ++// Base Impl. Declaration ++// + +-class TAO_ClientRequestInfo_IR_ValueDef_base_value_get : public TAO_ClientRequestInfo ++class TAO_Export _TAO_ValueDef_Proxy_Impl : ++ public virtual _TAO_Container_Proxy_Impl, ++ public virtual _TAO_Contained_Proxy_Impl, ++ public virtual _TAO_IDLType_Proxy_Impl + { + public: +- friend class IR::ValueDef; ++ virtual ~_TAO_ValueDef_Proxy_Impl (void) { } + +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; ++ virtual IR_InterfaceDefSeq * supported_interfaces ( ++ CORBA_Object *_collocated_tao_target_, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-TAO_ClientRequestInfo_IR_ValueDef_base_value_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); ++ virtual void supported_interfaces ( ++ CORBA_Object *_collocated_tao_target_, ++ const IR_InterfaceDefSeq & supported_interfaces, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual IR_InitializerSeq * initializers ( ++ CORBA_Object *_collocated_tao_target_, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual void initializers ( ++ CORBA_Object *_collocated_tao_target_, ++ const IR_InitializerSeq & initializers, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual IR_ValueDef_ptr base_value ( ++ CORBA_Object *_collocated_tao_target_, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-private: +- TAO_ClientRequestInfo_IR_ValueDef_base_value_get (const TAO_ClientRequestInfo_IR_ValueDef_base_value_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_base_value_get &); +- void result (IR::ValueDef_ptr result); +- // update the result +- IR::ValueDef_ptr result_; +-}; ++ virtual void base_value ( ++ CORBA_Object *_collocated_tao_target_, ++ IR_ValueDef_ptr base_value, ++ CORBA::Environment &ACE_TRY_ENV ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )) = 0; + +-class TAO_ClientRequestInfo_IR_ValueDef_base_value_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_base_value_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::ValueDef_ptr base_value, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_base_value_set (const TAO_ClientRequestInfo_IR_ValueDef_base_value_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_base_value_set &); +- IR::ValueDef_ptr base_value_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_get (const TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_get &); +- void result (IR::ValueDefSeq * result); +- // update the result +- IR::ValueDefSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const IR::ValueDefSeq & abstract_base_values, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_set (const TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_abstract_base_values_set &); +- const IR::ValueDefSeq & abstract_base_values_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_is_abstract_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_is_abstract_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_is_abstract_get (const TAO_ClientRequestInfo_IR_ValueDef_is_abstract_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_is_abstract_get &); +- void result (CORBA::Boolean result); +- // update the result +- CORBA::Boolean result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_is_abstract_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_is_abstract_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::Boolean & is_abstract, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_is_abstract_set (const TAO_ClientRequestInfo_IR_ValueDef_is_abstract_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_is_abstract_set &); +- const CORBA::Boolean & is_abstract_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_is_custom_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_is_custom_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_is_custom_get (const TAO_ClientRequestInfo_IR_ValueDef_is_custom_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_is_custom_get &); +- void result (CORBA::Boolean result); +- // update the result +- CORBA::Boolean result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_is_custom_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_is_custom_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::Boolean & is_custom, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_is_custom_set (const TAO_ClientRequestInfo_IR_ValueDef_is_custom_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_is_custom_set &); +- const CORBA::Boolean & is_custom_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_get (const TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_get &); +- void result (CORBA::Boolean result); +- // update the result +- CORBA::Boolean result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_set : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const CORBA::Boolean & is_truncatable, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_set (const TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_is_truncatable_set &); +- const CORBA::Boolean & is_truncatable_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_is_a : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_is_a ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_is_a (const TAO_ClientRequestInfo_IR_ValueDef_is_a &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_is_a &); +- const char * id_; +- void result (CORBA::Boolean result); +- // update the result +- CORBA::Boolean result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_create_value_member : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_create_value_member ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::IDLType_ptr type, +- const CORBA::Visibility & access, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_create_value_member (const TAO_ClientRequestInfo_IR_ValueDef_create_value_member &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_create_value_member &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::IDLType_ptr type_; +- const CORBA::Visibility & access_; +- void result (IR::ValueMemberDef_ptr result); +- // update the result +- IR::ValueMemberDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_create_attribute : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_create_attribute ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::IDLType_ptr type, +- IR::AttributeMode & mode, +- const IR::ExceptionDefSeq & get_exceptions, +- const IR::ExceptionDefSeq & put_exceptions, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_create_attribute (const TAO_ClientRequestInfo_IR_ValueDef_create_attribute &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_create_attribute &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::IDLType_ptr type_; +- const IR::AttributeMode & mode_; +- const IR::ExceptionDefSeq & get_exceptions_; +- const IR::ExceptionDefSeq & put_exceptions_; +- void result (IR::AttributeDef_ptr result); +- // update the result +- IR::AttributeDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ValueDef_create_operation : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ValueDef; +- +- friend class _TAO_ValueDef_Remote_Proxy_Impl; +- friend class _TAO_ValueDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ValueDef_create_operation ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::IDLType_ptr result, +- IR::OperationMode & mode, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, +- const IR::ContextIdSeq & contexts, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ValueDef_create_operation (const TAO_ClientRequestInfo_IR_ValueDef_create_operation &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueDef_create_operation &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::IDLType_ptr result_; +- const IR::OperationMode & mode_; +- const IR::ParDescriptionSeq & params_; +- const IR::ExceptionDefSeq & exceptions_; +- const IR::ContextIdSeq & contexts_; +- void result (IR::OperationDef_ptr result); +- // update the result +- IR::OperationDef_ptr result_; +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- +-}; +- +- +-// The Proxy Implementations are used by each interface to +-// perform a call. Each different implementation encapsulate +-// an invocation logics. +- +- +-/////////////////////////////////////////////////////////////////////// +-// Base Impl. Declaration +-// +- +-class TAO_Export _TAO_ValueDef_Proxy_Impl : +- public virtual IR::_TAO_Container_Proxy_Impl, +- public virtual IR::_TAO_Contained_Proxy_Impl, +- public virtual IR::_TAO_IDLType_Proxy_Impl +-{ +-public: +- virtual ~_TAO_ValueDef_Proxy_Impl (void) { } +- +- virtual IR::InterfaceDefSeq * supported_interfaces ( +- CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual void supported_interfaces ( +- CORBA_Object *_collocated_tao_target_, +- const IR::InterfaceDefSeq & supported_interfaces, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual IR::InitializerSeq * initializers ( +- CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual void initializers ( +- CORBA_Object *_collocated_tao_target_, +- const IR::InitializerSeq & initializers, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual IR::ValueDef_ptr base_value ( +- CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual void base_value ( +- CORBA_Object *_collocated_tao_target_, +- IR::ValueDef_ptr base_value, +- CORBA::Environment &ACE_TRY_ENV +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )) = 0; +- +- virtual IR::ValueDefSeq * abstract_base_values ( ++ virtual IR_ValueDefSeq * abstract_base_values ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -22565,7 +13445,7 @@ + + virtual void abstract_base_values ( + CORBA_Object *_collocated_tao_target_, +- const IR::ValueDefSeq & abstract_base_values, ++ const IR_ValueDefSeq & abstract_base_values, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -22632,12 +13512,12 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::ValueMemberDef_ptr create_value_member ( ++ virtual IR_ValueMemberDef_ptr create_value_member ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr type, ++ IR_IDLType_ptr type, + CORBA::Visibility access, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -22645,31 +13525,31 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::AttributeDef_ptr create_attribute ( ++ virtual IR_AttributeDef_ptr create_attribute ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr type, +- IR::AttributeMode mode, +- const IR::ExceptionDefSeq & get_exceptions, +- const IR::ExceptionDefSeq & put_exceptions, ++ IR_IDLType_ptr type, ++ IR_AttributeMode mode, ++ const IR_ExceptionDefSeq & get_exceptions, ++ const IR_ExceptionDefSeq & put_exceptions, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::OperationDef_ptr create_operation ( ++ virtual IR_OperationDef_ptr create_operation ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr result, +- IR::OperationMode mode, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, +- const IR::ContextIdSeq & contexts, ++ IR_IDLType_ptr result, ++ IR_OperationMode mode, ++ const IR_ParDescriptionSeq & params, ++ const IR_ExceptionDefSeq & exceptions, ++ const IR_ContextIdSeq & contexts, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -22680,6 +13560,7 @@ + _TAO_ValueDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -22692,9 +13573,9 @@ + class TAO_Export _TAO_ValueDef_Remote_Proxy_Impl : + public virtual _TAO_ValueDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Container_Remote_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl, +- public virtual IR::_TAO_IDLType_Remote_Proxy_Impl ++ public virtual _TAO_Container_Remote_Proxy_Impl, ++ public virtual _TAO_Contained_Remote_Proxy_Impl, ++ public virtual _TAO_IDLType_Remote_Proxy_Impl + + { + public: +@@ -22702,7 +13583,7 @@ + + virtual ~_TAO_ValueDef_Remote_Proxy_Impl (void) { } + +- virtual IR::InterfaceDefSeq * supported_interfaces ( ++ virtual IR_InterfaceDefSeq * supported_interfaces ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -22712,14 +13593,14 @@ + + virtual void supported_interfaces ( + CORBA_Object *_collocated_tao_target_, +- const IR::InterfaceDefSeq & supported_interfaces, ++ const IR_InterfaceDefSeq & supported_interfaces, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::InitializerSeq * initializers ( ++ virtual IR_InitializerSeq * initializers ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -22729,14 +13610,14 @@ + + virtual void initializers ( + CORBA_Object *_collocated_tao_target_, +- const IR::InitializerSeq & initializers, ++ const IR_InitializerSeq & initializers, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::ValueDef_ptr base_value ( ++ virtual IR_ValueDef_ptr base_value ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -22746,14 +13627,14 @@ + + virtual void base_value ( + CORBA_Object *_collocated_tao_target_, +- IR::ValueDef_ptr base_value, ++ IR_ValueDef_ptr base_value, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::ValueDefSeq * abstract_base_values ( ++ virtual IR_ValueDefSeq * abstract_base_values ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -22763,7 +13644,7 @@ + + virtual void abstract_base_values ( + CORBA_Object *_collocated_tao_target_, +- const IR::ValueDefSeq & abstract_base_values, ++ const IR_ValueDefSeq & abstract_base_values, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -22830,12 +13711,12 @@ + CORBA::SystemException + )); + +- virtual IR::ValueMemberDef_ptr create_value_member ( ++ virtual IR_ValueMemberDef_ptr create_value_member ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr type, ++ IR_IDLType_ptr type, + CORBA::Visibility access, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -22843,31 +13724,31 @@ + CORBA::SystemException + )); + +- virtual IR::AttributeDef_ptr create_attribute ( ++ virtual IR_AttributeDef_ptr create_attribute ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr type, +- IR::AttributeMode mode, +- const IR::ExceptionDefSeq & get_exceptions, +- const IR::ExceptionDefSeq & put_exceptions, ++ IR_IDLType_ptr type, ++ IR_AttributeMode mode, ++ const IR_ExceptionDefSeq & get_exceptions, ++ const IR_ExceptionDefSeq & put_exceptions, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::OperationDef_ptr create_operation ( ++ virtual IR_OperationDef_ptr create_operation ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::IDLType_ptr result, +- IR::OperationMode mode, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, +- const IR::ContextIdSeq & contexts, ++ IR_IDLType_ptr result, ++ IR_OperationMode mode, ++ const IR_ParDescriptionSeq & params, ++ const IR_ExceptionDefSeq & exceptions, ++ const IR_ContextIdSeq & contexts, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -22896,8 +13777,9 @@ + { + public: + virtual ~_TAO_ValueDef_Proxy_Broker (void); ++ + virtual _TAO_ValueDef_Proxy_Impl &select_proxy ( +- ValueDef *object, ++ IR_ValueDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -22922,9 +13804,9 @@ + _TAO_ValueDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_ValueDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_ValueDef_Proxy_Impl &select_proxy ( +- ValueDef *object, ++ IR_ValueDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -22938,24 +13820,15 @@ + static _TAO_ValueDef_Remote_Proxy_Broker *the_TAO_ValueDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDef; +- +-struct ValueDescription; +-class ValueDescription_var; +- +-struct TAO_Export ValueDescription ++struct TAO_Export IR_ValueDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ValueDescription_var _var_type; ++ typedef IR_ValueDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -22966,172 +13839,98 @@ + CORBA::Boolean is_custom; + TAO_String_Manager defined_in; + TAO_String_Manager version; +- ACE_NESTED_CLASS (IR, OpDescriptionSeq) operations; +- ACE_NESTED_CLASS (IR, AttrDescriptionSeq) attributes; +- ACE_NESTED_CLASS (IR, ValueMemberSeq) members; +- ACE_NESTED_CLASS (IR, InitializerSeq) initializers; +- ACE_NESTED_CLASS (IR, RepositoryIdSeq) supported_interfaces; +- ACE_NESTED_CLASS (IR, RepositoryIdSeq) abstract_base_values; ++ IR_OpDescriptionSeq operations; ++ IR_AttrDescriptionSeq attributes; ++ IR_ValueMemberSeq members; ++ IR_InitializerSeq initializers; ++ IR_RepositoryIdSeq supported_interfaces; ++ IR_RepositoryIdSeq abstract_base_values; + CORBA::Boolean is_truncatable; + TAO_String_Manager base_value; + CORBA::TypeCode_var type; + }; + +-class TAO_Export ValueDescription_var ++class TAO_Export IR_ValueDescription_var + { + public: +- ValueDescription_var (void); // default constructor +- ValueDescription_var (ValueDescription *); +- ValueDescription_var (const ValueDescription_var &); // copy constructor +- ~ValueDescription_var (void); // destructor +- +- ValueDescription_var &operator= (ValueDescription *); +- ValueDescription_var &operator= (const ValueDescription_var &); +- ValueDescription *operator-> (void); +- const ValueDescription *operator-> (void) const; +- +- operator const ValueDescription &() const; +- operator ValueDescription &(); +- operator ValueDescription &() const; +- operator ValueDescription *&(); // variable-size types only ++ IR_ValueDescription_var (void); // default constructor ++ IR_ValueDescription_var (IR_ValueDescription *); ++ IR_ValueDescription_var (const IR_ValueDescription_var &); // copy constructor ++ ~IR_ValueDescription_var (void); // destructor ++ ++ IR_ValueDescription_var &operator= (IR_ValueDescription *); ++ IR_ValueDescription_var &operator= (const IR_ValueDescription_var &); ++ IR_ValueDescription *operator-> (void); ++ const IR_ValueDescription *operator-> (void) const; ++ ++ operator const IR_ValueDescription &() const; ++ operator IR_ValueDescription &(); ++ operator IR_ValueDescription &() const; ++ operator IR_ValueDescription *&(); // variable-size types only + + // in, inout, out, _retn +- const ValueDescription &in (void) const; +- ValueDescription &inout (void); +- ValueDescription *&out (void); +- ValueDescription *_retn (void); +- ValueDescription *ptr (void) const; ++ const IR_ValueDescription &in (void) const; ++ IR_ValueDescription &inout (void); ++ IR_ValueDescription *&out (void); ++ IR_ValueDescription *_retn (void); ++ IR_ValueDescription *ptr (void) const; + + private: +- ValueDescription *ptr_; ++ IR_ValueDescription *ptr_; + }; + +-class TAO_Export ValueDescription_out ++class TAO_Export IR_ValueDescription_out + { + public: +- ValueDescription_out (ValueDescription *&); +- ValueDescription_out (ValueDescription_var &); +- ValueDescription_out (const ValueDescription_out &); +- ValueDescription_out &operator= (const ValueDescription_out &); +- ValueDescription_out &operator= (ValueDescription *); +- operator ValueDescription *&(); +- ValueDescription *&ptr (void); +- ValueDescription *operator-> (void); ++ IR_ValueDescription_out (IR_ValueDescription *&); ++ IR_ValueDescription_out (IR_ValueDescription_var &); ++ IR_ValueDescription_out (const IR_ValueDescription_out &); ++ IR_ValueDescription_out &operator= (const IR_ValueDescription_out &); ++ IR_ValueDescription_out &operator= (IR_ValueDescription *); ++ operator IR_ValueDescription *&(); ++ IR_ValueDescription *&ptr (void); ++ IR_ValueDescription *operator-> (void); + + private: +- ValueDescription *&ptr_; ++ IR_ValueDescription *&ptr_; + // assignment from T_var not allowed +- void operator= (const ValueDescription_var &); ++ void operator= (const IR_ValueDescription_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDescription; +- +- +-#if !defined (_TAO_IR_VALUEBOXDEF___PTR_CH_) +-#define _TAO_IR_VALUEBOXDEF___PTR_CH_ ++// Forward Classes Declaration ++class _TAO_ValueBoxDef_Proxy_Impl; ++class _TAO_ValueBoxDef_Remote_Proxy_Impl; ++class _TAO_ValueBoxDef_Proxy_Broker; ++class _TAO_ValueBoxDef_Remote_Proxy_Broker; + +-class ValueBoxDef; +-typedef ValueBoxDef *ValueBoxDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEBOXDEF___VAR_CH_) +-#define _TAO_IR_VALUEBOXDEF___VAR_CH_ +- +-class TAO_Export ValueBoxDef_var : public TAO_Base_var +-{ +-public: +- ValueBoxDef_var (void); // default constructor +- ValueBoxDef_var (ValueBoxDef_ptr p) : ptr_ (p) {} +- ValueBoxDef_var (const ValueBoxDef_var &); // copy constructor +- ~ValueBoxDef_var (void); // destructor +- +- ValueBoxDef_var &operator= (ValueBoxDef_ptr); +- ValueBoxDef_var &operator= (const ValueBoxDef_var &); +- ValueBoxDef_ptr operator-> (void) const; +- +- operator const ValueBoxDef_ptr &() const; +- operator ValueBoxDef_ptr &(); +- // in, inout, out, _retn +- ValueBoxDef_ptr in (void) const; +- ValueBoxDef_ptr &inout (void); +- ValueBoxDef_ptr &out (void); +- ValueBoxDef_ptr _retn (void); +- ValueBoxDef_ptr ptr (void) const; +- +-private: +- ValueBoxDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- ValueBoxDef_var (const TAO_Base_var &rhs); +- ValueBoxDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEBOXDEF___OUT_CH_) +-#define _TAO_IR_VALUEBOXDEF___OUT_CH_ +- +-class TAO_Export ValueBoxDef_out +-{ +-public: +- ValueBoxDef_out (ValueBoxDef_ptr &); +- ValueBoxDef_out (ValueBoxDef_var &); +- ValueBoxDef_out (const ValueBoxDef_out &); +- ValueBoxDef_out &operator= (const ValueBoxDef_out &); +- ValueBoxDef_out &operator= (const ValueBoxDef_var &); +- ValueBoxDef_out &operator= (ValueBoxDef_ptr); +- operator ValueBoxDef_ptr &(); +- ValueBoxDef_ptr &ptr (void); +- ValueBoxDef_ptr operator-> (void); +- +-private: +- ValueBoxDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_VALUEBOXDEF_CH_) +-#define _TAO_IR_VALUEBOXDEF_CH_ +- +-// Forward Classes Declaration +-class _TAO_ValueBoxDef_Proxy_Impl; +-class _TAO_ValueBoxDef_Remote_Proxy_Impl; +-class _TAO_ValueBoxDef_Proxy_Broker; +-class _TAO_ValueBoxDef_Remote_Proxy_Broker; +- +-class TAO_Export ValueBoxDef: public virtual TypedefDef ++class TAO_Export IR_ValueBoxDef: public virtual IR_TypedefDef + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ValueBoxDef_ptr _ptr_type; +- typedef ValueBoxDef_var _var_type; ++ typedef IR_ValueBoxDef_ptr _ptr_type; ++ typedef IR_ValueBoxDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static ValueBoxDef_ptr _duplicate (ValueBoxDef_ptr obj); +- static ValueBoxDef_ptr _narrow ( ++ static IR_ValueBoxDef_ptr _duplicate (IR_ValueBoxDef_ptr obj); ++ static IR_ValueBoxDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ValueBoxDef_ptr _unchecked_narrow ( ++ static IR_ValueBoxDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ValueBoxDef_ptr _nil (void) ++ static IR_ValueBoxDef_ptr _nil (void) + { +- return (ValueBoxDef_ptr)0; ++ return (IR_ValueBoxDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::IDLType_ptr original_type_def ( ++ virtual IR_IDLType_ptr original_type_def ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -23140,7 +13939,7 @@ + )); + + virtual void original_type_def ( +- IR::IDLType_ptr original_type_def, ++ IR_IDLType_ptr original_type_def, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -23161,121 +13960,27 @@ + _TAO_ValueBoxDef_Proxy_Broker *the_TAO_ValueBoxDef_Proxy_Broker_; + + protected: +- ValueBoxDef (int collocated = 0); ++ IR_ValueBoxDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- ValueBoxDef ( ++ IR_ValueBoxDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_ValueBoxDef_Remote_Proxy_Impl; +- friend class _TAO_ValueBoxDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueBoxDef_Direct_Proxy_Impl; +- +- virtual ~ValueBoxDef (void); +- private: +- ValueBoxDef (const ValueBoxDef &); +- void operator= (const ValueBoxDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ValueBoxDef; +- +- friend class _TAO_ValueBoxDef_Remote_Proxy_Impl; +- friend class _TAO_ValueBoxDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueBoxDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_get (const TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_get &); +- void result (IR::IDLType_ptr result); +- // update the result +- IR::IDLType_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ValueBoxDef; +- +- friend class _TAO_ValueBoxDef_Remote_Proxy_Impl; +- friend class _TAO_ValueBoxDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ValueBoxDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- IR::IDLType_ptr original_type_def, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); ++ ++ friend class _TAO_ValueBoxDef_Remote_Proxy_Impl; ++ friend class _TAO_ValueBoxDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_ValueBoxDef_Direct_Proxy_Impl; + +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_ValueBoxDef (void); + private: +- TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_set (const TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ValueBoxDef_original_type_def_set &); +- IR::IDLType_ptr original_type_def_; +- +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_ValueBoxDef (const IR_ValueBoxDef &); ++ void operator= (const IR_ValueBoxDef &); + }; + + +@@ -23289,12 +13994,12 @@ + // + + class TAO_Export _TAO_ValueBoxDef_Proxy_Impl : +- public virtual IR::_TAO_TypedefDef_Proxy_Impl ++ public virtual _TAO_TypedefDef_Proxy_Impl + { + public: + virtual ~_TAO_ValueBoxDef_Proxy_Impl (void) { } + +- virtual IR::IDLType_ptr original_type_def ( ++ virtual IR_IDLType_ptr original_type_def ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -23304,7 +14009,7 @@ + + virtual void original_type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr original_type_def, ++ IR_IDLType_ptr original_type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -23315,6 +14020,7 @@ + _TAO_ValueBoxDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -23327,7 +14033,7 @@ + class TAO_Export _TAO_ValueBoxDef_Remote_Proxy_Impl : + public virtual _TAO_ValueBoxDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_TypedefDef_Remote_Proxy_Impl ++ public virtual _TAO_TypedefDef_Remote_Proxy_Impl + + { + public: +@@ -23335,9 +14041,9 @@ + + virtual ~_TAO_ValueBoxDef_Remote_Proxy_Impl (void) { } + +- virtual IR::IDLType_ptr original_type_def ( ++ virtual IR_IDLType_ptr original_type_def ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException +@@ -23345,7 +14051,7 @@ + + virtual void original_type_def ( + CORBA_Object *_collocated_tao_target_, +- IR::IDLType_ptr original_type_def, ++ IR_IDLType_ptr original_type_def, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -23374,8 +14080,9 @@ + { + public: + virtual ~_TAO_ValueBoxDef_Proxy_Broker (void); ++ + virtual _TAO_ValueBoxDef_Proxy_Impl &select_proxy ( +- ValueBoxDef *object, ++ IR_ValueBoxDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -23400,9 +14107,9 @@ + _TAO_ValueBoxDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_ValueBoxDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_ValueBoxDef_Proxy_Impl &select_proxy ( +- ValueBoxDef *object, ++ IR_ValueBoxDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -23416,122 +14123,44 @@ + static _TAO_ValueBoxDef_Remote_Proxy_Broker *the_TAO_ValueBoxDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueBoxDef; +- +- +-#if !defined (_TAO_IR_PROVIDESDEF___PTR_CH_) +-#define _TAO_IR_PROVIDESDEF___PTR_CH_ +- +-class ProvidesDef; +-typedef ProvidesDef *ProvidesDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PROVIDESDEF___VAR_CH_) +-#define _TAO_IR_PROVIDESDEF___VAR_CH_ +- +-class TAO_Export ProvidesDef_var : public TAO_Base_var +-{ +-public: +- ProvidesDef_var (void); // default constructor +- ProvidesDef_var (ProvidesDef_ptr p) : ptr_ (p) {} +- ProvidesDef_var (const ProvidesDef_var &); // copy constructor +- ~ProvidesDef_var (void); // destructor +- +- ProvidesDef_var &operator= (ProvidesDef_ptr); +- ProvidesDef_var &operator= (const ProvidesDef_var &); +- ProvidesDef_ptr operator-> (void) const; +- +- operator const ProvidesDef_ptr &() const; +- operator ProvidesDef_ptr &(); +- // in, inout, out, _retn +- ProvidesDef_ptr in (void) const; +- ProvidesDef_ptr &inout (void); +- ProvidesDef_ptr &out (void); +- ProvidesDef_ptr _retn (void); +- ProvidesDef_ptr ptr (void) const; +- +-private: +- ProvidesDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- ProvidesDef_var (const TAO_Base_var &rhs); +- ProvidesDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PROVIDESDEF___OUT_CH_) +-#define _TAO_IR_PROVIDESDEF___OUT_CH_ +- +-class TAO_Export ProvidesDef_out +-{ +-public: +- ProvidesDef_out (ProvidesDef_ptr &); +- ProvidesDef_out (ProvidesDef_var &); +- ProvidesDef_out (const ProvidesDef_out &); +- ProvidesDef_out &operator= (const ProvidesDef_out &); +- ProvidesDef_out &operator= (const ProvidesDef_var &); +- ProvidesDef_out &operator= (ProvidesDef_ptr); +- operator ProvidesDef_ptr &(); +- ProvidesDef_ptr &ptr (void); +- ProvidesDef_ptr operator-> (void); +- +-private: +- ProvidesDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PROVIDESDEF_CH_) +-#define _TAO_IR_PROVIDESDEF_CH_ +- + // Forward Classes Declaration + class _TAO_ProvidesDef_Proxy_Impl; + class _TAO_ProvidesDef_Remote_Proxy_Impl; + class _TAO_ProvidesDef_Proxy_Broker; + class _TAO_ProvidesDef_Remote_Proxy_Broker; + +-class TAO_Export ProvidesDef: public virtual Contained ++class TAO_Export IR_ProvidesDef: public virtual IR_Contained + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ProvidesDef_ptr _ptr_type; +- typedef ProvidesDef_var _var_type; ++ typedef IR_ProvidesDef_ptr _ptr_type; ++ typedef IR_ProvidesDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static ProvidesDef_ptr _duplicate (ProvidesDef_ptr obj); +- static ProvidesDef_ptr _narrow ( ++ static IR_ProvidesDef_ptr _duplicate (IR_ProvidesDef_ptr obj); ++ static IR_ProvidesDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ProvidesDef_ptr _unchecked_narrow ( ++ static IR_ProvidesDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ProvidesDef_ptr _nil (void) ++ static IR_ProvidesDef_ptr _nil (void) + { +- return (ProvidesDef_ptr)0; ++ return (IR_ProvidesDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::InterfaceDef_ptr interface_type ( ++ virtual IR_InterfaceDef_ptr interface_type ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -23552,78 +14181,27 @@ + _TAO_ProvidesDef_Proxy_Broker *the_TAO_ProvidesDef_Proxy_Broker_; + + protected: +- ProvidesDef (int collocated = 0); ++ IR_ProvidesDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- ProvidesDef ( ++ IR_ProvidesDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_ProvidesDef_Remote_Proxy_Impl; +- friend class _TAO_ProvidesDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ProvidesDef_Direct_Proxy_Impl; +- +- virtual ~ProvidesDef (void); +- private: +- ProvidesDef (const ProvidesDef &); +- void operator= (const ProvidesDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ProvidesDef; +- +- friend class _TAO_ProvidesDef_Remote_Proxy_Impl; +- friend class _TAO_ProvidesDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ProvidesDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ ); + +- private: +- TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get (const TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ProvidesDef_interface_type_get &); +- void result (IR::InterfaceDef_ptr result); +- // update the result +- IR::InterfaceDef_ptr result_; +- }; ++ friend class _TAO_ProvidesDef_Remote_Proxy_Impl; ++ friend class _TAO_ProvidesDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_ProvidesDef_Direct_Proxy_Impl; + +- #endif /* TAO_HAS_INTERCEPTORS */ +- ++ virtual ~IR_ProvidesDef (void); ++private: ++ IR_ProvidesDef (const IR_ProvidesDef &); ++ void operator= (const IR_ProvidesDef &); + }; + + +@@ -23637,12 +14215,12 @@ + // + + class TAO_Export _TAO_ProvidesDef_Proxy_Impl : +- public virtual IR::_TAO_Contained_Proxy_Impl ++ public virtual _TAO_Contained_Proxy_Impl + { + public: + virtual ~_TAO_ProvidesDef_Proxy_Impl (void) { } + +- virtual IR::InterfaceDef_ptr interface_type ( ++ virtual IR_InterfaceDef_ptr interface_type ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -23654,6 +14232,7 @@ + _TAO_ProvidesDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -23666,7 +14245,7 @@ + class TAO_Export _TAO_ProvidesDef_Remote_Proxy_Impl : + public virtual _TAO_ProvidesDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl ++ public virtual _TAO_Contained_Remote_Proxy_Impl + + { + public: +@@ -23674,7 +14253,7 @@ + + virtual ~_TAO_ProvidesDef_Remote_Proxy_Impl (void) { } + +- virtual IR::InterfaceDef_ptr interface_type ( ++ virtual IR_InterfaceDef_ptr interface_type ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -23704,8 +14283,9 @@ + { + public: + virtual ~_TAO_ProvidesDef_Proxy_Broker (void); ++ + virtual _TAO_ProvidesDef_Proxy_Impl &select_proxy ( +- ProvidesDef *object, ++ IR_ProvidesDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -23730,9 +14310,9 @@ + _TAO_ProvidesDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_ProvidesDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_ProvidesDef_Proxy_Impl &select_proxy ( +- ProvidesDef *object, ++ IR_ProvidesDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -23746,24 +14326,15 @@ + static _TAO_ProvidesDef_Remote_Proxy_Broker *the_TAO_ProvidesDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDef; +- +-struct ProvidesDescription; +-class ProvidesDescription_var; +- +-struct TAO_Export ProvidesDescription ++struct TAO_Export IR_ProvidesDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ProvidesDescription_var _var_type; ++ typedef IR_ProvidesDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -23772,164 +14343,90 @@ + TAO_String_Manager id; + TAO_String_Manager defined_in; + TAO_String_Manager version; +- ACE_NESTED_CLASS (IR, InterfaceDef_var) interface_type; ++ IR_InterfaceDef_var interface_type; + }; + +-class TAO_Export ProvidesDescription_var ++class TAO_Export IR_ProvidesDescription_var + { + public: +- ProvidesDescription_var (void); // default constructor +- ProvidesDescription_var (ProvidesDescription *); +- ProvidesDescription_var (const ProvidesDescription_var &); // copy constructor +- ~ProvidesDescription_var (void); // destructor ++ IR_ProvidesDescription_var (void); // default constructor ++ IR_ProvidesDescription_var (IR_ProvidesDescription *); ++ IR_ProvidesDescription_var (const IR_ProvidesDescription_var &); // copy constructor ++ ~IR_ProvidesDescription_var (void); // destructor + +- ProvidesDescription_var &operator= (ProvidesDescription *); +- ProvidesDescription_var &operator= (const ProvidesDescription_var &); +- ProvidesDescription *operator-> (void); +- const ProvidesDescription *operator-> (void) const; ++ IR_ProvidesDescription_var &operator= (IR_ProvidesDescription *); ++ IR_ProvidesDescription_var &operator= (const IR_ProvidesDescription_var &); ++ IR_ProvidesDescription *operator-> (void); ++ const IR_ProvidesDescription *operator-> (void) const; + +- operator const ProvidesDescription &() const; +- operator ProvidesDescription &(); +- operator ProvidesDescription &() const; +- operator ProvidesDescription *&(); // variable-size types only ++ operator const IR_ProvidesDescription &() const; ++ operator IR_ProvidesDescription &(); ++ operator IR_ProvidesDescription &() const; ++ operator IR_ProvidesDescription *&(); // variable-size types only + + // in, inout, out, _retn +- const ProvidesDescription &in (void) const; +- ProvidesDescription &inout (void); +- ProvidesDescription *&out (void); +- ProvidesDescription *_retn (void); +- ProvidesDescription *ptr (void) const; ++ const IR_ProvidesDescription &in (void) const; ++ IR_ProvidesDescription &inout (void); ++ IR_ProvidesDescription *&out (void); ++ IR_ProvidesDescription *_retn (void); ++ IR_ProvidesDescription *ptr (void) const; + + private: +- ProvidesDescription *ptr_; ++ IR_ProvidesDescription *ptr_; + }; + +-class TAO_Export ProvidesDescription_out ++class TAO_Export IR_ProvidesDescription_out + { + public: +- ProvidesDescription_out (ProvidesDescription *&); +- ProvidesDescription_out (ProvidesDescription_var &); +- ProvidesDescription_out (const ProvidesDescription_out &); +- ProvidesDescription_out &operator= (const ProvidesDescription_out &); +- ProvidesDescription_out &operator= (ProvidesDescription *); +- operator ProvidesDescription *&(); +- ProvidesDescription *&ptr (void); +- ProvidesDescription *operator-> (void); ++ IR_ProvidesDescription_out (IR_ProvidesDescription *&); ++ IR_ProvidesDescription_out (IR_ProvidesDescription_var &); ++ IR_ProvidesDescription_out (const IR_ProvidesDescription_out &); ++ IR_ProvidesDescription_out &operator= (const IR_ProvidesDescription_out &); ++ IR_ProvidesDescription_out &operator= (IR_ProvidesDescription *); ++ operator IR_ProvidesDescription *&(); ++ IR_ProvidesDescription *&ptr (void); ++ IR_ProvidesDescription *operator-> (void); + + private: +- ProvidesDescription *&ptr_; ++ IR_ProvidesDescription *&ptr_; + // assignment from T_var not allowed +- void operator= (const ProvidesDescription_var &); +-}; +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDescription; +- +- +-#if !defined (_TAO_IR_USESDEF___PTR_CH_) +-#define _TAO_IR_USESDEF___PTR_CH_ +- +-class UsesDef; +-typedef UsesDef *UsesDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_USESDEF___VAR_CH_) +-#define _TAO_IR_USESDEF___VAR_CH_ +- +-class TAO_Export UsesDef_var : public TAO_Base_var +-{ +-public: +- UsesDef_var (void); // default constructor +- UsesDef_var (UsesDef_ptr p) : ptr_ (p) {} +- UsesDef_var (const UsesDef_var &); // copy constructor +- ~UsesDef_var (void); // destructor +- +- UsesDef_var &operator= (UsesDef_ptr); +- UsesDef_var &operator= (const UsesDef_var &); +- UsesDef_ptr operator-> (void) const; +- +- operator const UsesDef_ptr &() const; +- operator UsesDef_ptr &(); +- // in, inout, out, _retn +- UsesDef_ptr in (void) const; +- UsesDef_ptr &inout (void); +- UsesDef_ptr &out (void); +- UsesDef_ptr _retn (void); +- UsesDef_ptr ptr (void) const; +- +-private: +- UsesDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- UsesDef_var (const TAO_Base_var &rhs); +- UsesDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_USESDEF___OUT_CH_) +-#define _TAO_IR_USESDEF___OUT_CH_ +- +-class TAO_Export UsesDef_out +-{ +-public: +- UsesDef_out (UsesDef_ptr &); +- UsesDef_out (UsesDef_var &); +- UsesDef_out (const UsesDef_out &); +- UsesDef_out &operator= (const UsesDef_out &); +- UsesDef_out &operator= (const UsesDef_var &); +- UsesDef_out &operator= (UsesDef_ptr); +- operator UsesDef_ptr &(); +- UsesDef_ptr &ptr (void); +- UsesDef_ptr operator-> (void); +- +-private: +- UsesDef_ptr &ptr_; ++ void operator= (const IR_ProvidesDescription_var &); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_USESDEF_CH_) +-#define _TAO_IR_USESDEF_CH_ +- + // Forward Classes Declaration + class _TAO_UsesDef_Proxy_Impl; + class _TAO_UsesDef_Remote_Proxy_Impl; + class _TAO_UsesDef_Proxy_Broker; + class _TAO_UsesDef_Remote_Proxy_Broker; + +-class TAO_Export UsesDef: public virtual Contained ++class TAO_Export IR_UsesDef: public virtual IR_Contained + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef UsesDef_ptr _ptr_type; +- typedef UsesDef_var _var_type; ++ typedef IR_UsesDef_ptr _ptr_type; ++ typedef IR_UsesDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static UsesDef_ptr _duplicate (UsesDef_ptr obj); +- static UsesDef_ptr _narrow ( ++ static IR_UsesDef_ptr _duplicate (IR_UsesDef_ptr obj); ++ static IR_UsesDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static UsesDef_ptr _unchecked_narrow ( ++ static IR_UsesDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static UsesDef_ptr _nil (void) ++ static IR_UsesDef_ptr _nil (void) + { +- return (UsesDef_ptr)0; ++ return (IR_UsesDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::InterfaceDef_ptr interface_type ( ++ virtual IR_InterfaceDef_ptr interface_type ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -23958,121 +14455,27 @@ + _TAO_UsesDef_Proxy_Broker *the_TAO_UsesDef_Proxy_Broker_; + + protected: +- UsesDef (int collocated = 0); ++ IR_UsesDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- UsesDef ( ++ IR_UsesDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_UsesDef_Remote_Proxy_Impl; +- friend class _TAO_UsesDef_ThruPOA_Proxy_Impl; +- friend class _TAO_UsesDef_Direct_Proxy_Impl; +- +- virtual ~UsesDef (void); +- private: +- UsesDef (const UsesDef &); +- void operator= (const UsesDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_UsesDef_interface_type_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::UsesDef; +- +- friend class _TAO_UsesDef_Remote_Proxy_Impl; +- friend class _TAO_UsesDef_ThruPOA_Proxy_Impl; +- friend class _TAO_UsesDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_UsesDef_interface_type_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_UsesDef_interface_type_get (const TAO_ClientRequestInfo_IR_UsesDef_interface_type_get &); +- void operator= (const TAO_ClientRequestInfo_IR_UsesDef_interface_type_get &); +- void result (IR::InterfaceDef_ptr result); +- // update the result +- IR::InterfaceDef_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::UsesDef; +- +- friend class _TAO_UsesDef_Remote_Proxy_Impl; +- friend class _TAO_UsesDef_ThruPOA_Proxy_Impl; +- friend class _TAO_UsesDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); ++ ++ friend class _TAO_UsesDef_Remote_Proxy_Impl; ++ friend class _TAO_UsesDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_UsesDef_Direct_Proxy_Impl; + +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_UsesDef (void); + private: +- TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get (const TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get &); +- void operator= (const TAO_ClientRequestInfo_IR_UsesDef_is_multiple_get &); +- void result (CORBA::Boolean result); +- // update the result +- CORBA::Boolean result_; +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_UsesDef (const IR_UsesDef &); ++ void operator= (const IR_UsesDef &); + }; + + +@@ -24086,12 +14489,12 @@ + // + + class TAO_Export _TAO_UsesDef_Proxy_Impl : +- public virtual IR::_TAO_Contained_Proxy_Impl ++ public virtual _TAO_Contained_Proxy_Impl + { + public: + virtual ~_TAO_UsesDef_Proxy_Impl (void) { } + +- virtual IR::InterfaceDef_ptr interface_type ( ++ virtual IR_InterfaceDef_ptr interface_type ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -24111,6 +14514,7 @@ + _TAO_UsesDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -24123,7 +14527,7 @@ + class TAO_Export _TAO_UsesDef_Remote_Proxy_Impl : + public virtual _TAO_UsesDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl ++ public virtual _TAO_Contained_Remote_Proxy_Impl + + { + public: +@@ -24131,7 +14535,7 @@ + + virtual ~_TAO_UsesDef_Remote_Proxy_Impl (void) { } + +- virtual IR::InterfaceDef_ptr interface_type ( ++ virtual IR_InterfaceDef_ptr interface_type ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -24169,8 +14573,9 @@ + { + public: + virtual ~_TAO_UsesDef_Proxy_Broker (void); ++ + virtual _TAO_UsesDef_Proxy_Impl &select_proxy ( +- UsesDef *object, ++ IR_UsesDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -24195,9 +14600,9 @@ + _TAO_UsesDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_UsesDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_UsesDef_Proxy_Impl &select_proxy ( +- UsesDef *object, ++ IR_UsesDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -24211,24 +14616,15 @@ + static _TAO_UsesDef_Remote_Proxy_Broker *the_TAO_UsesDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDef; +- +-struct UsesDescription; +-class UsesDescription_var; +- +-struct TAO_Export UsesDescription ++struct TAO_Export IR_UsesDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef UsesDescription_var _var_type; ++ typedef IR_UsesDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -24237,65 +14633,61 @@ + TAO_String_Manager id; + TAO_String_Manager defined_in; + TAO_String_Manager version; +- ACE_NESTED_CLASS (IR, InterfaceDef_var) interface_type; ++ IR_InterfaceDef_var interface_type; + CORBA::Boolean is_multiple; + }; + +-class TAO_Export UsesDescription_var ++class TAO_Export IR_UsesDescription_var + { + public: +- UsesDescription_var (void); // default constructor +- UsesDescription_var (UsesDescription *); +- UsesDescription_var (const UsesDescription_var &); // copy constructor +- ~UsesDescription_var (void); // destructor +- +- UsesDescription_var &operator= (UsesDescription *); +- UsesDescription_var &operator= (const UsesDescription_var &); +- UsesDescription *operator-> (void); +- const UsesDescription *operator-> (void) const; +- +- operator const UsesDescription &() const; +- operator UsesDescription &(); +- operator UsesDescription &() const; +- operator UsesDescription *&(); // variable-size types only ++ IR_UsesDescription_var (void); // default constructor ++ IR_UsesDescription_var (IR_UsesDescription *); ++ IR_UsesDescription_var (const IR_UsesDescription_var &); // copy constructor ++ ~IR_UsesDescription_var (void); // destructor ++ ++ IR_UsesDescription_var &operator= (IR_UsesDescription *); ++ IR_UsesDescription_var &operator= (const IR_UsesDescription_var &); ++ IR_UsesDescription *operator-> (void); ++ const IR_UsesDescription *operator-> (void) const; ++ ++ operator const IR_UsesDescription &() const; ++ operator IR_UsesDescription &(); ++ operator IR_UsesDescription &() const; ++ operator IR_UsesDescription *&(); // variable-size types only + + // in, inout, out, _retn +- const UsesDescription &in (void) const; +- UsesDescription &inout (void); +- UsesDescription *&out (void); +- UsesDescription *_retn (void); +- UsesDescription *ptr (void) const; ++ const IR_UsesDescription &in (void) const; ++ IR_UsesDescription &inout (void); ++ IR_UsesDescription *&out (void); ++ IR_UsesDescription *_retn (void); ++ IR_UsesDescription *ptr (void) const; + + private: +- UsesDescription *ptr_; ++ IR_UsesDescription *ptr_; + }; + +-class TAO_Export UsesDescription_out ++class TAO_Export IR_UsesDescription_out + { + public: +- UsesDescription_out (UsesDescription *&); +- UsesDescription_out (UsesDescription_var &); +- UsesDescription_out (const UsesDescription_out &); +- UsesDescription_out &operator= (const UsesDescription_out &); +- UsesDescription_out &operator= (UsesDescription *); +- operator UsesDescription *&(); +- UsesDescription *&ptr (void); +- UsesDescription *operator-> (void); ++ IR_UsesDescription_out (IR_UsesDescription *&); ++ IR_UsesDescription_out (IR_UsesDescription_var &); ++ IR_UsesDescription_out (const IR_UsesDescription_out &); ++ IR_UsesDescription_out &operator= (const IR_UsesDescription_out &); ++ IR_UsesDescription_out &operator= (IR_UsesDescription *); ++ operator IR_UsesDescription *&(); ++ IR_UsesDescription *&ptr (void); ++ IR_UsesDescription *operator-> (void); + + private: +- UsesDescription *&ptr_; ++ IR_UsesDescription *&ptr_; + // assignment from T_var not allowed +- void operator= (const UsesDescription_var &); ++ void operator= (const IR_UsesDescription_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDescription; +- ++TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IR_UsesDescription; + + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CH_ +- + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ProvidesDescSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -24305,149 +14697,118 @@ + _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum, + CORBA::ULong length, +- ProvidesDescription *data, ++ IR_ProvidesDescription *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (const _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &rhs); + _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &operator= (const _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &rhs); + virtual ~_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (void); // Dtor. + // = Accessors. +- ProvidesDescription &operator[] (CORBA::ULong i); +- const ProvidesDescription &operator[] (CORBA::ULong i) const; ++ IR_ProvidesDescription &operator[] (CORBA::ULong i); ++ const IR_ProvidesDescription &operator[] (CORBA::ULong i) const; + // = Static operations. +- static ProvidesDescription *allocbuf (CORBA::ULong size); +- static void freebuf (ProvidesDescription *buffer); ++ static IR_ProvidesDescription *allocbuf (CORBA::ULong size); ++ static void freebuf (IR_ProvidesDescription *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + +- ProvidesDescription *get_buffer (CORBA::Boolean orphan = 0); +- const ProvidesDescription *get_buffer (void) const; ++ IR_ProvidesDescription *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_ProvidesDescription *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, +- ProvidesDescription *data, ++ IR_ProvidesDescription *data, + CORBA::Boolean release); + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_PROVIDESDESCSEQ_CH_) +-#define _TAO_IR_PROVIDESDESCSEQ_CH_ +- +-class ProvidesDescSeq; +-class ProvidesDescSeq_var; +- + // ************************************************************* +-// ProvidesDescSeq ++// IR_ProvidesDescSeq + // ************************************************************* + +-class TAO_Export ProvidesDescSeq : public ++class TAO_Export IR_ProvidesDescSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IR_ProvidesDescSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Sequence<ProvidesDescription> ++ TAO_Unbounded_Sequence<IR_ProvidesDescription> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- ProvidesDescSeq (void); // default ctor +- ProvidesDescSeq (CORBA::ULong max); // uses max size +- ProvidesDescSeq ( ++ IR_ProvidesDescSeq (void); // default ctor ++ IR_ProvidesDescSeq (CORBA::ULong max); // uses max size ++ IR_ProvidesDescSeq ( + CORBA::ULong max, + CORBA::ULong length, +- ProvidesDescription *buffer, ++ IR_ProvidesDescription *buffer, + CORBA::Boolean release = 0 + ); +- ProvidesDescSeq (const ProvidesDescSeq &); // copy ctor +- ~ProvidesDescSeq (void); ++ IR_ProvidesDescSeq (const IR_ProvidesDescSeq &); // copy ctor ++ ~IR_ProvidesDescSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ProvidesDescSeq_var _var_type; ++ typedef IR_ProvidesDescSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PROVIDESDESCSEQ___VAR_CH_) +-#define _TAO_IR_PROVIDESDESCSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::ProvidesDescSeq_var ++// class IR_ProvidesDescSeq_var + // ************************************************************* + +-class TAO_Export ProvidesDescSeq_var ++class TAO_Export IR_ProvidesDescSeq_var + { + public: +- ProvidesDescSeq_var (void); // default constructor +- ProvidesDescSeq_var (ProvidesDescSeq *); +- ProvidesDescSeq_var (const ProvidesDescSeq_var &); // copy constructor +- ~ProvidesDescSeq_var (void); // destructor ++ IR_ProvidesDescSeq_var (void); // default constructor ++ IR_ProvidesDescSeq_var (IR_ProvidesDescSeq *); ++ IR_ProvidesDescSeq_var (const IR_ProvidesDescSeq_var &); // copy constructor ++ ~IR_ProvidesDescSeq_var (void); // destructor + +- ProvidesDescSeq_var &operator= (ProvidesDescSeq *); +- ProvidesDescSeq_var &operator= (const ProvidesDescSeq_var &); +- ProvidesDescSeq *operator-> (void); +- const ProvidesDescSeq *operator-> (void) const; ++ IR_ProvidesDescSeq_var &operator= (IR_ProvidesDescSeq *); ++ IR_ProvidesDescSeq_var &operator= (const IR_ProvidesDescSeq_var &); ++ IR_ProvidesDescSeq *operator-> (void); ++ const IR_ProvidesDescSeq *operator-> (void) const; + +- operator const ProvidesDescSeq &() const; +- operator ProvidesDescSeq &(); +- operator ProvidesDescSeq &() const; +- operator ProvidesDescSeq *&(); // variable-size base types only ++ operator const IR_ProvidesDescSeq &() const; ++ operator IR_ProvidesDescSeq &(); ++ operator IR_ProvidesDescSeq &() const; ++ operator IR_ProvidesDescSeq *&(); // variable-size base types only + +- ProvidesDescription & operator[] (CORBA::ULong index); +- const ProvidesDescription & operator[] (CORBA::ULong index) const; ++ IR_ProvidesDescription & operator[] (CORBA::ULong index); ++ const IR_ProvidesDescription & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn +- const ProvidesDescSeq &in (void) const; +- ProvidesDescSeq &inout (void); +- ProvidesDescSeq *&out (void); +- ProvidesDescSeq *_retn (void); +- ProvidesDescSeq *ptr (void) const; ++ const IR_ProvidesDescSeq &in (void) const; ++ IR_ProvidesDescSeq &inout (void); ++ IR_ProvidesDescSeq *&out (void); ++ IR_ProvidesDescSeq *_retn (void); ++ IR_ProvidesDescSeq *ptr (void) const; + + private: +- ProvidesDescSeq *ptr_; ++ IR_ProvidesDescSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PROVIDESDESCSEQ___OUT_CH_) +-#define _TAO_IR_PROVIDESDESCSEQ___OUT_CH_ +- +-class TAO_Export ProvidesDescSeq_out ++class TAO_Export IR_ProvidesDescSeq_out + { + public: +- ProvidesDescSeq_out (ProvidesDescSeq *&); +- ProvidesDescSeq_out (ProvidesDescSeq_var &); +- ProvidesDescSeq_out (const ProvidesDescSeq_out &); +- ProvidesDescSeq_out &operator= (const ProvidesDescSeq_out &); +- ProvidesDescSeq_out &operator= (ProvidesDescSeq *); +- operator ProvidesDescSeq *&(); +- ProvidesDescSeq *&ptr (void); +- ProvidesDescSeq *operator-> (void); +- ProvidesDescription & operator[] (CORBA::ULong index); ++ IR_ProvidesDescSeq_out (IR_ProvidesDescSeq *&); ++ IR_ProvidesDescSeq_out (IR_ProvidesDescSeq_var &); ++ IR_ProvidesDescSeq_out (const IR_ProvidesDescSeq_out &); ++ IR_ProvidesDescSeq_out &operator= (const IR_ProvidesDescSeq_out &); ++ IR_ProvidesDescSeq_out &operator= (IR_ProvidesDescSeq *); ++ operator IR_ProvidesDescSeq *&(); ++ IR_ProvidesDescSeq *&ptr (void); ++ IR_ProvidesDescSeq *operator-> (void); ++ IR_ProvidesDescription & operator[] (CORBA::ULong index); + + private: +- ProvidesDescSeq *&ptr_; ++ IR_ProvidesDescSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const ProvidesDescSeq_var &); ++ void operator= (const IR_ProvidesDescSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDescSeq; +- +- + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +-#if !defined (_TAO__TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CH_) +-#define _TAO__TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CH_ +- + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_UsesDescSeq : public TAO_Unbounded_Base_Sequence + { + public: +@@ -24457,244 +14818,145 @@ + _TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum, + CORBA::ULong length, +- UsesDescription *data, ++ IR_UsesDescription *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_IR_UsesDescSeq (const _TAO_Unbounded_Sequence_IR_UsesDescSeq &rhs); + _TAO_Unbounded_Sequence_IR_UsesDescSeq &operator= (const _TAO_Unbounded_Sequence_IR_UsesDescSeq &rhs); + virtual ~_TAO_Unbounded_Sequence_IR_UsesDescSeq (void); // Dtor. + // = Accessors. +- UsesDescription &operator[] (CORBA::ULong i); +- const UsesDescription &operator[] (CORBA::ULong i) const; ++ IR_UsesDescription &operator[] (CORBA::ULong i); ++ const IR_UsesDescription &operator[] (CORBA::ULong i) const; + // = Static operations. +- static UsesDescription *allocbuf (CORBA::ULong size); +- static void freebuf (UsesDescription *buffer); ++ static IR_UsesDescription *allocbuf (CORBA::ULong size); ++ static void freebuf (IR_UsesDescription *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + +- UsesDescription *get_buffer (CORBA::Boolean orphan = 0); +- const UsesDescription *get_buffer (void) const; ++ IR_UsesDescription *get_buffer (CORBA::Boolean orphan = 0); ++ const IR_UsesDescription *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, +- UsesDescription *data, ++ IR_UsesDescription *data, + CORBA::Boolean release); + }; + +-#endif /* end #if !defined */ +- +- + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +-#if !defined (_TAO_IR_USESDESCSEQ_CH_) +-#define _TAO_IR_USESDESCSEQ_CH_ +- +-class UsesDescSeq; +-class UsesDescSeq_var; +- + // ************************************************************* +-// UsesDescSeq ++// IR_UsesDescSeq + // ************************************************************* + +-class TAO_Export UsesDescSeq : public ++class TAO_Export IR_UsesDescSeq : public + #if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IR_UsesDescSeq + #else /* TAO_USE_SEQUENCE_TEMPLATES */ +- TAO_Unbounded_Sequence<UsesDescription> ++ TAO_Unbounded_Sequence<IR_UsesDescription> + #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: +- UsesDescSeq (void); // default ctor +- UsesDescSeq (CORBA::ULong max); // uses max size +- UsesDescSeq ( ++ IR_UsesDescSeq (void); // default ctor ++ IR_UsesDescSeq (CORBA::ULong max); // uses max size ++ IR_UsesDescSeq ( + CORBA::ULong max, + CORBA::ULong length, +- UsesDescription *buffer, ++ IR_UsesDescription *buffer, + CORBA::Boolean release = 0 + ); +- UsesDescSeq (const UsesDescSeq &); // copy ctor +- ~UsesDescSeq (void); ++ IR_UsesDescSeq (const IR_UsesDescSeq &); // copy ctor ++ ~IR_UsesDescSeq (void); + static void _tao_any_destructor (void*); + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef UsesDescSeq_var _var_type; ++ typedef IR_UsesDescSeq_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_USESDESCSEQ___VAR_CH_) +-#define _TAO_IR_USESDESCSEQ___VAR_CH_ +- + // ************************************************************* +-// class IR::UsesDescSeq_var ++// class IR_UsesDescSeq_var + // ************************************************************* + +-class TAO_Export UsesDescSeq_var ++class TAO_Export IR_UsesDescSeq_var + { + public: +- UsesDescSeq_var (void); // default constructor +- UsesDescSeq_var (UsesDescSeq *); +- UsesDescSeq_var (const UsesDescSeq_var &); // copy constructor +- ~UsesDescSeq_var (void); // destructor ++ IR_UsesDescSeq_var (void); // default constructor ++ IR_UsesDescSeq_var (IR_UsesDescSeq *); ++ IR_UsesDescSeq_var (const IR_UsesDescSeq_var &); // copy constructor ++ ~IR_UsesDescSeq_var (void); // destructor + +- UsesDescSeq_var &operator= (UsesDescSeq *); +- UsesDescSeq_var &operator= (const UsesDescSeq_var &); +- UsesDescSeq *operator-> (void); +- const UsesDescSeq *operator-> (void) const; ++ IR_UsesDescSeq_var &operator= (IR_UsesDescSeq *); ++ IR_UsesDescSeq_var &operator= (const IR_UsesDescSeq_var &); ++ IR_UsesDescSeq *operator-> (void); ++ const IR_UsesDescSeq *operator-> (void) const; + +- operator const UsesDescSeq &() const; +- operator UsesDescSeq &(); +- operator UsesDescSeq &() const; +- operator UsesDescSeq *&(); // variable-size base types only ++ operator const IR_UsesDescSeq &() const; ++ operator IR_UsesDescSeq &(); ++ operator IR_UsesDescSeq &() const; ++ operator IR_UsesDescSeq *&(); // variable-size base types only + +- UsesDescription & operator[] (CORBA::ULong index); +- const UsesDescription & operator[] (CORBA::ULong index) const; ++ IR_UsesDescription & operator[] (CORBA::ULong index); ++ const IR_UsesDescription & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn +- const UsesDescSeq &in (void) const; +- UsesDescSeq &inout (void); +- UsesDescSeq *&out (void); +- UsesDescSeq *_retn (void); +- UsesDescSeq *ptr (void) const; ++ const IR_UsesDescSeq &in (void) const; ++ IR_UsesDescSeq &inout (void); ++ IR_UsesDescSeq *&out (void); ++ IR_UsesDescSeq *_retn (void); ++ IR_UsesDescSeq *ptr (void) const; + + private: +- UsesDescSeq *ptr_; ++ IR_UsesDescSeq *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_USESDESCSEQ___OUT_CH_) +-#define _TAO_IR_USESDESCSEQ___OUT_CH_ +- +-class TAO_Export UsesDescSeq_out ++class TAO_Export IR_UsesDescSeq_out + { + public: +- UsesDescSeq_out (UsesDescSeq *&); +- UsesDescSeq_out (UsesDescSeq_var &); +- UsesDescSeq_out (const UsesDescSeq_out &); +- UsesDescSeq_out &operator= (const UsesDescSeq_out &); +- UsesDescSeq_out &operator= (UsesDescSeq *); +- operator UsesDescSeq *&(); +- UsesDescSeq *&ptr (void); +- UsesDescSeq *operator-> (void); +- UsesDescription & operator[] (CORBA::ULong index); ++ IR_UsesDescSeq_out (IR_UsesDescSeq *&); ++ IR_UsesDescSeq_out (IR_UsesDescSeq_var &); ++ IR_UsesDescSeq_out (const IR_UsesDescSeq_out &); ++ IR_UsesDescSeq_out &operator= (const IR_UsesDescSeq_out &); ++ IR_UsesDescSeq_out &operator= (IR_UsesDescSeq *); ++ operator IR_UsesDescSeq *&(); ++ IR_UsesDescSeq *&ptr (void); ++ IR_UsesDescSeq *operator-> (void); ++ IR_UsesDescription & operator[] (CORBA::ULong index); + + private: +- UsesDescSeq *&ptr_; ++ IR_UsesDescSeq *&ptr_; + // assignment from T_var not allowed +- void operator= (const UsesDescSeq_var &); +-}; +- +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDescSeq; +- +- +-#if !defined (_TAO_IR_EVENTDEF___PTR_CH_) +-#define _TAO_IR_EVENTDEF___PTR_CH_ +- +-class EventDef; +-typedef EventDef *EventDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EVENTDEF___VAR_CH_) +-#define _TAO_IR_EVENTDEF___VAR_CH_ +- +-class TAO_Export EventDef_var : public TAO_Base_var +-{ +-public: +- EventDef_var (void); // default constructor +- EventDef_var (EventDef_ptr p) : ptr_ (p) {} +- EventDef_var (const EventDef_var &); // copy constructor +- ~EventDef_var (void); // destructor +- +- EventDef_var &operator= (EventDef_ptr); +- EventDef_var &operator= (const EventDef_var &); +- EventDef_ptr operator-> (void) const; +- +- operator const EventDef_ptr &() const; +- operator EventDef_ptr &(); +- // in, inout, out, _retn +- EventDef_ptr in (void) const; +- EventDef_ptr &inout (void); +- EventDef_ptr &out (void); +- EventDef_ptr _retn (void); +- EventDef_ptr ptr (void) const; +- +-private: +- EventDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- EventDef_var (const TAO_Base_var &rhs); +- EventDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EVENTDEF___OUT_CH_) +-#define _TAO_IR_EVENTDEF___OUT_CH_ +- +-class TAO_Export EventDef_out +-{ +-public: +- EventDef_out (EventDef_ptr &); +- EventDef_out (EventDef_var &); +- EventDef_out (const EventDef_out &); +- EventDef_out &operator= (const EventDef_out &); +- EventDef_out &operator= (const EventDef_var &); +- EventDef_out &operator= (EventDef_ptr); +- operator EventDef_ptr &(); +- EventDef_ptr &ptr (void); +- EventDef_ptr operator-> (void); +- +-private: +- EventDef_ptr &ptr_; ++ void operator= (const IR_UsesDescSeq_var &); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EVENTDEF_CH_) +-#define _TAO_IR_EVENTDEF_CH_ +- + // Forward Classes Declaration + class _TAO_EventDef_Proxy_Impl; + class _TAO_EventDef_Remote_Proxy_Impl; + class _TAO_EventDef_Proxy_Broker; + class _TAO_EventDef_Remote_Proxy_Broker; + +-class TAO_Export EventDef: public virtual Contained ++class TAO_Export IR_EventDef: public virtual IR_Contained + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef EventDef_ptr _ptr_type; +- typedef EventDef_var _var_type; ++ typedef IR_EventDef_ptr _ptr_type; ++ typedef IR_EventDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static EventDef_ptr _duplicate (EventDef_ptr obj); +- static EventDef_ptr _narrow ( ++ static IR_EventDef_ptr _duplicate (IR_EventDef_ptr obj); ++ static IR_EventDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static EventDef_ptr _unchecked_narrow ( ++ static IR_EventDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static EventDef_ptr _nil (void) ++ static IR_EventDef_ptr _nil (void) + { +- return (EventDef_ptr)0; ++ return (IR_EventDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -24708,7 +14970,7 @@ + CORBA::SystemException + )); + +- virtual IR::ValueDef_ptr event ( ++ virtual IR_ValueDef_ptr event ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -24729,123 +14991,27 @@ + _TAO_EventDef_Proxy_Broker *the_TAO_EventDef_Proxy_Broker_; + + protected: +- EventDef (int collocated = 0); ++ IR_EventDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- EventDef ( ++ IR_EventDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_EventDef_Remote_Proxy_Impl; +- friend class _TAO_EventDef_ThruPOA_Proxy_Impl; +- friend class _TAO_EventDef_Direct_Proxy_Impl; +- +- virtual ~EventDef (void); +- private: +- EventDef (const EventDef &); +- void operator= (const EventDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_EventDef_is_a : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::EventDef; +- +- friend class _TAO_EventDef_Remote_Proxy_Impl; +- friend class _TAO_EventDef_ThruPOA_Proxy_Impl; +- friend class _TAO_EventDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_EventDef_is_a ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * event_id, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_EventDef_is_a (const TAO_ClientRequestInfo_IR_EventDef_is_a &); +- void operator= (const TAO_ClientRequestInfo_IR_EventDef_is_a &); +- const char * event_id_; +- void result (CORBA::Boolean result); +- // update the result +- CORBA::Boolean result_; +- }; +- +- class TAO_ClientRequestInfo_IR_EventDef_event_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::EventDef; +- +- friend class _TAO_EventDef_Remote_Proxy_Impl; +- friend class _TAO_EventDef_ThruPOA_Proxy_Impl; +- friend class _TAO_EventDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_EventDef_event_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); ++ ++ friend class _TAO_EventDef_Remote_Proxy_Impl; ++ friend class _TAO_EventDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_EventDef_Direct_Proxy_Impl; + +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_EventDef (void); + private: +- TAO_ClientRequestInfo_IR_EventDef_event_get (const TAO_ClientRequestInfo_IR_EventDef_event_get &); +- void operator= (const TAO_ClientRequestInfo_IR_EventDef_event_get &); +- void result (IR::ValueDef_ptr result); +- // update the result +- IR::ValueDef_ptr result_; +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_EventDef (const IR_EventDef &); ++ void operator= (const IR_EventDef &); + }; + + +@@ -24859,12 +15025,12 @@ + // + + class TAO_Export _TAO_EventDef_Proxy_Impl : +- public virtual IR::_TAO_Contained_Proxy_Impl ++ public virtual _TAO_Contained_Proxy_Impl + { + public: + virtual ~_TAO_EventDef_Proxy_Impl (void) { } + +- virtual CORBA::Boolean is_a ( ++ virtual CORBA::Boolean is_a ( + CORBA_Object *_collocated_tao_target_, + const char * event_id, + CORBA::Environment &ACE_TRY_ENV +@@ -24873,7 +15039,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::ValueDef_ptr event ( ++ virtual IR_ValueDef_ptr event ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -24885,6 +15051,7 @@ + _TAO_EventDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -24897,7 +15064,7 @@ + class TAO_Export _TAO_EventDef_Remote_Proxy_Impl : + public virtual _TAO_EventDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl ++ public virtual _TAO_Contained_Remote_Proxy_Impl + + { + public: +@@ -24905,7 +15072,7 @@ + + virtual ~_TAO_EventDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::Boolean is_a ( ++ virtual CORBA::Boolean is_a ( + CORBA_Object *_collocated_tao_target_, + const char * event_id, + CORBA::Environment &ACE_TRY_ENV +@@ -24914,7 +15081,7 @@ + CORBA::SystemException + )); + +- virtual IR::ValueDef_ptr event ( ++ virtual IR_ValueDef_ptr event ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -24944,8 +15111,9 @@ + { + public: + virtual ~_TAO_EventDef_Proxy_Broker (void); ++ + virtual _TAO_EventDef_Proxy_Impl &select_proxy ( +- EventDef *object, ++ IR_EventDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -24970,9 +15138,9 @@ + _TAO_EventDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_EventDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_EventDef_Proxy_Impl &select_proxy ( +- EventDef *object, ++ IR_EventDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -24986,24 +15154,15 @@ + static _TAO_EventDef_Remote_Proxy_Broker *the_TAO_EventDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EventDef; +- +-struct EventDescription; +-class EventDescription_var; +- +-struct TAO_Export EventDescription ++struct TAO_Export IR_EventDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef EventDescription_var _var_type; ++ typedef IR_EventDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -25012,159 +15171,85 @@ + TAO_String_Manager id; + TAO_String_Manager defined_in; + TAO_String_Manager version; +- ACE_NESTED_CLASS (IR, ValueDef_var) value; ++ IR_ValueDef_var value; + }; + +-class TAO_Export EventDescription_var ++class TAO_Export IR_EventDescription_var + { + public: +- EventDescription_var (void); // default constructor +- EventDescription_var (EventDescription *); +- EventDescription_var (const EventDescription_var &); // copy constructor +- ~EventDescription_var (void); // destructor ++ IR_EventDescription_var (void); // default constructor ++ IR_EventDescription_var (IR_EventDescription *); ++ IR_EventDescription_var (const IR_EventDescription_var &); // copy constructor ++ ~IR_EventDescription_var (void); // destructor + +- EventDescription_var &operator= (EventDescription *); +- EventDescription_var &operator= (const EventDescription_var &); +- EventDescription *operator-> (void); +- const EventDescription *operator-> (void) const; ++ IR_EventDescription_var &operator= (IR_EventDescription *); ++ IR_EventDescription_var &operator= (const IR_EventDescription_var &); ++ IR_EventDescription *operator-> (void); ++ const IR_EventDescription *operator-> (void) const; + +- operator const EventDescription &() const; +- operator EventDescription &(); +- operator EventDescription &() const; +- operator EventDescription *&(); // variable-size types only ++ operator const IR_EventDescription &() const; ++ operator IR_EventDescription &(); ++ operator IR_EventDescription &() const; ++ operator IR_EventDescription *&(); // variable-size types only + + // in, inout, out, _retn +- const EventDescription &in (void) const; +- EventDescription &inout (void); +- EventDescription *&out (void); +- EventDescription *_retn (void); +- EventDescription *ptr (void) const; ++ const IR_EventDescription &in (void) const; ++ IR_EventDescription &inout (void); ++ IR_EventDescription *&out (void); ++ IR_EventDescription *_retn (void); ++ IR_EventDescription *ptr (void) const; + + private: +- EventDescription *ptr_; ++ IR_EventDescription *ptr_; + }; + +-class TAO_Export EventDescription_out ++class TAO_Export IR_EventDescription_out + { + public: +- EventDescription_out (EventDescription *&); +- EventDescription_out (EventDescription_var &); +- EventDescription_out (const EventDescription_out &); +- EventDescription_out &operator= (const EventDescription_out &); +- EventDescription_out &operator= (EventDescription *); +- operator EventDescription *&(); +- EventDescription *&ptr (void); +- EventDescription *operator-> (void); ++ IR_EventDescription_out (IR_EventDescription *&); ++ IR_EventDescription_out (IR_EventDescription_var &); ++ IR_EventDescription_out (const IR_EventDescription_out &); ++ IR_EventDescription_out &operator= (const IR_EventDescription_out &); ++ IR_EventDescription_out &operator= (IR_EventDescription *); ++ operator IR_EventDescription *&(); ++ IR_EventDescription *&ptr (void); ++ IR_EventDescription *operator-> (void); + + private: +- EventDescription *&ptr_; ++ IR_EventDescription *&ptr_; + // assignment from T_var not allowed +- void operator= (const EventDescription_var &); +-}; +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EventDescription; +- +- +-#if !defined (_TAO_IR_EMITSDEF___PTR_CH_) +-#define _TAO_IR_EMITSDEF___PTR_CH_ +- +-class EmitsDef; +-typedef EmitsDef *EmitsDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EMITSDEF___VAR_CH_) +-#define _TAO_IR_EMITSDEF___VAR_CH_ +- +-class TAO_Export EmitsDef_var : public TAO_Base_var +-{ +-public: +- EmitsDef_var (void); // default constructor +- EmitsDef_var (EmitsDef_ptr p) : ptr_ (p) {} +- EmitsDef_var (const EmitsDef_var &); // copy constructor +- ~EmitsDef_var (void); // destructor +- +- EmitsDef_var &operator= (EmitsDef_ptr); +- EmitsDef_var &operator= (const EmitsDef_var &); +- EmitsDef_ptr operator-> (void) const; +- +- operator const EmitsDef_ptr &() const; +- operator EmitsDef_ptr &(); +- // in, inout, out, _retn +- EmitsDef_ptr in (void) const; +- EmitsDef_ptr &inout (void); +- EmitsDef_ptr &out (void); +- EmitsDef_ptr _retn (void); +- EmitsDef_ptr ptr (void) const; +- +-private: +- EmitsDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- EmitsDef_var (const TAO_Base_var &rhs); +- EmitsDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EMITSDEF___OUT_CH_) +-#define _TAO_IR_EMITSDEF___OUT_CH_ +- +-class TAO_Export EmitsDef_out +-{ +-public: +- EmitsDef_out (EmitsDef_ptr &); +- EmitsDef_out (EmitsDef_var &); +- EmitsDef_out (const EmitsDef_out &); +- EmitsDef_out &operator= (const EmitsDef_out &); +- EmitsDef_out &operator= (const EmitsDef_var &); +- EmitsDef_out &operator= (EmitsDef_ptr); +- operator EmitsDef_ptr &(); +- EmitsDef_ptr &ptr (void); +- EmitsDef_ptr operator-> (void); +- +-private: +- EmitsDef_ptr &ptr_; ++ void operator= (const IR_EventDescription_var &); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_EMITSDEF_CH_) +-#define _TAO_IR_EMITSDEF_CH_ +- + // Forward Classes Declaration + class _TAO_EmitsDef_Proxy_Impl; + class _TAO_EmitsDef_Remote_Proxy_Impl; + class _TAO_EmitsDef_Proxy_Broker; + class _TAO_EmitsDef_Remote_Proxy_Broker; + +-class TAO_Export EmitsDef: public virtual EventDef ++class TAO_Export IR_EmitsDef: public virtual IR_EventDef + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef EmitsDef_ptr _ptr_type; +- typedef EmitsDef_var _var_type; ++ typedef IR_EmitsDef_ptr _ptr_type; ++ typedef IR_EmitsDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static EmitsDef_ptr _duplicate (EmitsDef_ptr obj); +- static EmitsDef_ptr _narrow ( ++ static IR_EmitsDef_ptr _duplicate (IR_EmitsDef_ptr obj); ++ static IR_EmitsDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static EmitsDef_ptr _unchecked_narrow ( ++ static IR_EmitsDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static EmitsDef_ptr _nil (void) ++ static IR_EmitsDef_ptr _nil (void) + { +- return (EmitsDef_ptr)0; ++ return (IR_EmitsDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -25182,60 +15267,53 @@ + _TAO_EmitsDef_Proxy_Broker *the_TAO_EmitsDef_Proxy_Broker_; + + protected: +- EmitsDef (int collocated = 0); ++ IR_EmitsDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- EmitsDef ( ++ IR_EmitsDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); ++ ); + +- friend class _TAO_EmitsDef_Remote_Proxy_Impl; +- friend class _TAO_EmitsDef_ThruPOA_Proxy_Impl; +- friend class _TAO_EmitsDef_Direct_Proxy_Impl; ++ friend class _TAO_EmitsDef_Remote_Proxy_Impl; ++ friend class _TAO_EmitsDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_EmitsDef_Direct_Proxy_Impl; + +- virtual ~EmitsDef (void); +- private: +- EmitsDef (const EmitsDef &); +- void operator= (const EmitsDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- #endif /* TAO_HAS_INTERCEPTORS */ +- +- }; ++ virtual ~IR_EmitsDef (void); ++private: ++ IR_EmitsDef (const IR_EmitsDef &); ++ void operator= (const IR_EmitsDef &); ++}; + + + // The Proxy Implementations are used by each interface to + // perform a call. Each different implementation encapsulate + // an invocation logics. + +- +- /////////////////////////////////////////////////////////////////////// +- // Base Impl. Declaration +- // + +- class TAO_Export _TAO_EmitsDef_Proxy_Impl : +- public virtual IR::_TAO_EventDef_Proxy_Impl +- { +- public: +- virtual ~_TAO_EmitsDef_Proxy_Impl (void) { } ++/////////////////////////////////////////////////////////////////////// ++// Base Impl. Declaration ++// ++ ++class TAO_Export _TAO_EmitsDef_Proxy_Impl ++ : public virtual _TAO_EventDef_Proxy_Impl ++{ ++public: ++ virtual ~_TAO_EmitsDef_Proxy_Impl (void) { } + +- protected: +- _TAO_EmitsDef_Proxy_Impl (void); ++protected: ++ _TAO_EmitsDef_Proxy_Impl (void); + +- }; +- // +- // Base Proxy Impl. Declaration +- /////////////////////////////////////////////////////////////////////// ++}; ++ ++// ++// Base Proxy Impl. Declaration ++/////////////////////////////////////////////////////////////////////// + + + /////////////////////////////////////////////////////////////////////// +@@ -25245,7 +15323,7 @@ + class TAO_Export _TAO_EmitsDef_Remote_Proxy_Impl : + public virtual _TAO_EmitsDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_EventDef_Remote_Proxy_Impl ++ public virtual _TAO_EventDef_Remote_Proxy_Impl + + { + public: +@@ -25253,7 +15331,7 @@ + + virtual ~_TAO_EmitsDef_Remote_Proxy_Impl (void) { } + +- }; ++}; + + // + // Base Proxy Impl. Declaration +@@ -25275,8 +15353,9 @@ + { + public: + virtual ~_TAO_EmitsDef_Proxy_Broker (void); ++ + virtual _TAO_EmitsDef_Proxy_Impl &select_proxy ( +- EmitsDef *object, ++ IR_EmitsDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -25301,9 +15380,9 @@ + _TAO_EmitsDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_EmitsDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_EmitsDef_Proxy_Impl &select_proxy ( +- EmitsDef *object, ++ IR_EmitsDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -25317,117 +15396,38 @@ + static _TAO_EmitsDef_Remote_Proxy_Broker *the_TAO_EmitsDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EmitsDef; +- +- +-#if !defined (_TAO_IR_PUBLISHESDEF___PTR_CH_) +-#define _TAO_IR_PUBLISHESDEF___PTR_CH_ +- +-class PublishesDef; +-typedef PublishesDef *PublishesDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PUBLISHESDEF___VAR_CH_) +-#define _TAO_IR_PUBLISHESDEF___VAR_CH_ +- +-class TAO_Export PublishesDef_var : public TAO_Base_var +-{ +-public: +- PublishesDef_var (void); // default constructor +- PublishesDef_var (PublishesDef_ptr p) : ptr_ (p) {} +- PublishesDef_var (const PublishesDef_var &); // copy constructor +- ~PublishesDef_var (void); // destructor +- +- PublishesDef_var &operator= (PublishesDef_ptr); +- PublishesDef_var &operator= (const PublishesDef_var &); +- PublishesDef_ptr operator-> (void) const; +- +- operator const PublishesDef_ptr &() const; +- operator PublishesDef_ptr &(); +- // in, inout, out, _retn +- PublishesDef_ptr in (void) const; +- PublishesDef_ptr &inout (void); +- PublishesDef_ptr &out (void); +- PublishesDef_ptr _retn (void); +- PublishesDef_ptr ptr (void) const; +- +-private: +- PublishesDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- PublishesDef_var (const TAO_Base_var &rhs); +- PublishesDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PUBLISHESDEF___OUT_CH_) +-#define _TAO_IR_PUBLISHESDEF___OUT_CH_ +- +-class TAO_Export PublishesDef_out +-{ +-public: +- PublishesDef_out (PublishesDef_ptr &); +- PublishesDef_out (PublishesDef_var &); +- PublishesDef_out (const PublishesDef_out &); +- PublishesDef_out &operator= (const PublishesDef_out &); +- PublishesDef_out &operator= (const PublishesDef_var &); +- PublishesDef_out &operator= (PublishesDef_ptr); +- operator PublishesDef_ptr &(); +- PublishesDef_ptr &ptr (void); +- PublishesDef_ptr operator-> (void); +- +-private: +- PublishesDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PUBLISHESDEF_CH_) +-#define _TAO_IR_PUBLISHESDEF_CH_ +- +-// Forward Classes Declaration + class _TAO_PublishesDef_Proxy_Impl; + class _TAO_PublishesDef_Remote_Proxy_Impl; + class _TAO_PublishesDef_Proxy_Broker; + class _TAO_PublishesDef_Remote_Proxy_Broker; + +-class TAO_Export PublishesDef: public virtual EventDef ++class TAO_Export IR_PublishesDef: public virtual IR_EventDef + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef PublishesDef_ptr _ptr_type; +- typedef PublishesDef_var _var_type; ++ typedef IR_PublishesDef_ptr _ptr_type; ++ typedef IR_PublishesDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static PublishesDef_ptr _duplicate (PublishesDef_ptr obj); +- static PublishesDef_ptr _narrow ( ++ static IR_PublishesDef_ptr _duplicate (IR_PublishesDef_ptr obj); ++ static IR_PublishesDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static PublishesDef_ptr _unchecked_narrow ( ++ static IR_PublishesDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static PublishesDef_ptr _nil (void) ++ static IR_PublishesDef_ptr _nil (void) + { +- return (PublishesDef_ptr)0; ++ return (IR_PublishesDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -25445,60 +15445,53 @@ + _TAO_PublishesDef_Proxy_Broker *the_TAO_PublishesDef_Proxy_Broker_; + + protected: +- PublishesDef (int collocated = 0); ++ IR_PublishesDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- PublishesDef ( ++ IR_PublishesDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); ++ ); + +- friend class _TAO_PublishesDef_Remote_Proxy_Impl; +- friend class _TAO_PublishesDef_ThruPOA_Proxy_Impl; +- friend class _TAO_PublishesDef_Direct_Proxy_Impl; ++ friend class _TAO_PublishesDef_Remote_Proxy_Impl; ++ friend class _TAO_PublishesDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_PublishesDef_Direct_Proxy_Impl; + +- virtual ~PublishesDef (void); +- private: +- PublishesDef (const PublishesDef &); +- void operator= (const PublishesDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- #endif /* TAO_HAS_INTERCEPTORS */ +- +- }; ++ virtual ~IR_PublishesDef (void); ++private: ++ IR_PublishesDef (const IR_PublishesDef &); ++ void operator= (const IR_PublishesDef &); ++}; + + + // The Proxy Implementations are used by each interface to + // perform a call. Each different implementation encapsulate + // an invocation logics. + +- +- /////////////////////////////////////////////////////////////////////// +- // Base Impl. Declaration +- // + +- class TAO_Export _TAO_PublishesDef_Proxy_Impl : +- public virtual IR::_TAO_EventDef_Proxy_Impl +- { +- public: +- virtual ~_TAO_PublishesDef_Proxy_Impl (void) { } ++/////////////////////////////////////////////////////////////////////// ++// Base Impl. Declaration ++// ++ ++class TAO_Export _TAO_PublishesDef_Proxy_Impl ++ : public virtual _TAO_EventDef_Proxy_Impl ++{ ++public: ++ virtual ~_TAO_PublishesDef_Proxy_Impl (void) { } + +- protected: +- _TAO_PublishesDef_Proxy_Impl (void); ++protected: ++ _TAO_PublishesDef_Proxy_Impl (void); ++ ++}; + +- }; +- // +- // Base Proxy Impl. Declaration +- /////////////////////////////////////////////////////////////////////// ++// ++// Base Proxy Impl. Declaration ++/////////////////////////////////////////////////////////////////////// + + + /////////////////////////////////////////////////////////////////////// +@@ -25508,7 +15501,7 @@ + class TAO_Export _TAO_PublishesDef_Remote_Proxy_Impl : + public virtual _TAO_PublishesDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_EventDef_Remote_Proxy_Impl ++ public virtual _TAO_EventDef_Remote_Proxy_Impl + + { + public: +@@ -25516,7 +15509,7 @@ + + virtual ~_TAO_PublishesDef_Remote_Proxy_Impl (void) { } + +- }; ++}; + + // + // Base Proxy Impl. Declaration +@@ -25538,8 +15531,9 @@ + { + public: + virtual ~_TAO_PublishesDef_Proxy_Broker (void); ++ + virtual _TAO_PublishesDef_Proxy_Impl &select_proxy ( +- PublishesDef *object, ++ IR_PublishesDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -25564,9 +15558,9 @@ + _TAO_PublishesDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_PublishesDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_PublishesDef_Proxy_Impl &select_proxy ( +- PublishesDef *object, ++ IR_PublishesDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -25580,117 +15574,39 @@ + static _TAO_PublishesDef_Remote_Proxy_Broker *the_TAO_PublishesDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PublishesDef; +- +- +-#if !defined (_TAO_IR_CONSUMESDEF___PTR_CH_) +-#define _TAO_IR_CONSUMESDEF___PTR_CH_ +- +-class ConsumesDef; +-typedef ConsumesDef *ConsumesDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONSUMESDEF___VAR_CH_) +-#define _TAO_IR_CONSUMESDEF___VAR_CH_ +- +-class TAO_Export ConsumesDef_var : public TAO_Base_var +-{ +-public: +- ConsumesDef_var (void); // default constructor +- ConsumesDef_var (ConsumesDef_ptr p) : ptr_ (p) {} +- ConsumesDef_var (const ConsumesDef_var &); // copy constructor +- ~ConsumesDef_var (void); // destructor +- +- ConsumesDef_var &operator= (ConsumesDef_ptr); +- ConsumesDef_var &operator= (const ConsumesDef_var &); +- ConsumesDef_ptr operator-> (void) const; +- +- operator const ConsumesDef_ptr &() const; +- operator ConsumesDef_ptr &(); +- // in, inout, out, _retn +- ConsumesDef_ptr in (void) const; +- ConsumesDef_ptr &inout (void); +- ConsumesDef_ptr &out (void); +- ConsumesDef_ptr _retn (void); +- ConsumesDef_ptr ptr (void) const; +- +-private: +- ConsumesDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- ConsumesDef_var (const TAO_Base_var &rhs); +- ConsumesDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONSUMESDEF___OUT_CH_) +-#define _TAO_IR_CONSUMESDEF___OUT_CH_ +- +-class TAO_Export ConsumesDef_out +-{ +-public: +- ConsumesDef_out (ConsumesDef_ptr &); +- ConsumesDef_out (ConsumesDef_var &); +- ConsumesDef_out (const ConsumesDef_out &); +- ConsumesDef_out &operator= (const ConsumesDef_out &); +- ConsumesDef_out &operator= (const ConsumesDef_var &); +- ConsumesDef_out &operator= (ConsumesDef_ptr); +- operator ConsumesDef_ptr &(); +- ConsumesDef_ptr &ptr (void); +- ConsumesDef_ptr operator-> (void); +- +-private: +- ConsumesDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_CONSUMESDEF_CH_) +-#define _TAO_IR_CONSUMESDEF_CH_ +- + // Forward Classes Declaration + class _TAO_ConsumesDef_Proxy_Impl; + class _TAO_ConsumesDef_Remote_Proxy_Impl; + class _TAO_ConsumesDef_Proxy_Broker; + class _TAO_ConsumesDef_Remote_Proxy_Broker; + +-class TAO_Export ConsumesDef: public virtual EventDef ++class TAO_Export IR_ConsumesDef: public virtual IR_EventDef + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ConsumesDef_ptr _ptr_type; +- typedef ConsumesDef_var _var_type; ++ typedef IR_ConsumesDef_ptr _ptr_type; ++ typedef IR_ConsumesDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static ConsumesDef_ptr _duplicate (ConsumesDef_ptr obj); +- static ConsumesDef_ptr _narrow ( ++ static IR_ConsumesDef_ptr _duplicate (IR_ConsumesDef_ptr obj); ++ static IR_ConsumesDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ConsumesDef_ptr _unchecked_narrow ( ++ static IR_ConsumesDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ConsumesDef_ptr _nil (void) ++ static IR_ConsumesDef_ptr _nil (void) + { +- return (ConsumesDef_ptr)0; ++ return (IR_ConsumesDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -25708,60 +15624,53 @@ + _TAO_ConsumesDef_Proxy_Broker *the_TAO_ConsumesDef_Proxy_Broker_; + + protected: +- ConsumesDef (int collocated = 0); ++ IR_ConsumesDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- ConsumesDef ( ++ IR_ConsumesDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); ++ ); + +- friend class _TAO_ConsumesDef_Remote_Proxy_Impl; +- friend class _TAO_ConsumesDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ConsumesDef_Direct_Proxy_Impl; ++ friend class _TAO_ConsumesDef_Remote_Proxy_Impl; ++ friend class _TAO_ConsumesDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_ConsumesDef_Direct_Proxy_Impl; + +- virtual ~ConsumesDef (void); +- private: +- ConsumesDef (const ConsumesDef &); +- void operator= (const ConsumesDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- #endif /* TAO_HAS_INTERCEPTORS */ +- +- }; ++ virtual ~IR_ConsumesDef (void); ++private: ++ IR_ConsumesDef (const IR_ConsumesDef &); ++ void operator= (const IR_ConsumesDef &); ++}; + + + // The Proxy Implementations are used by each interface to + // perform a call. Each different implementation encapsulate + // an invocation logics. + +- +- /////////////////////////////////////////////////////////////////////// +- // Base Impl. Declaration +- // + +- class TAO_Export _TAO_ConsumesDef_Proxy_Impl : +- public virtual IR::_TAO_EventDef_Proxy_Impl +- { +- public: +- virtual ~_TAO_ConsumesDef_Proxy_Impl (void) { } ++/////////////////////////////////////////////////////////////////////// ++// Base Impl. Declaration ++// ++ ++class TAO_Export _TAO_ConsumesDef_Proxy_Impl ++ : public virtual _TAO_EventDef_Proxy_Impl ++{ ++public: ++ virtual ~_TAO_ConsumesDef_Proxy_Impl (void) { } + +- protected: +- _TAO_ConsumesDef_Proxy_Impl (void); ++protected: ++ _TAO_ConsumesDef_Proxy_Impl (void); ++ ++}; + +- }; +- // +- // Base Proxy Impl. Declaration +- /////////////////////////////////////////////////////////////////////// ++// ++// Base Proxy Impl. Declaration ++/////////////////////////////////////////////////////////////////////// + + + /////////////////////////////////////////////////////////////////////// +@@ -25771,7 +15680,7 @@ + class TAO_Export _TAO_ConsumesDef_Remote_Proxy_Impl : + public virtual _TAO_ConsumesDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_EventDef_Remote_Proxy_Impl ++ public virtual _TAO_EventDef_Remote_Proxy_Impl + + { + public: +@@ -25779,7 +15688,7 @@ + + virtual ~_TAO_ConsumesDef_Remote_Proxy_Impl (void) { } + +- }; ++}; + + // + // Base Proxy Impl. Declaration +@@ -25801,8 +15710,9 @@ + { + public: + virtual ~_TAO_ConsumesDef_Proxy_Broker (void); ++ + virtual _TAO_ConsumesDef_Proxy_Impl &select_proxy ( +- ConsumesDef *object, ++ IR_ConsumesDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -25827,9 +15737,9 @@ + _TAO_ConsumesDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_ConsumesDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_ConsumesDef_Proxy_Impl &select_proxy ( +- ConsumesDef *object, ++ IR_ConsumesDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -25843,122 +15753,44 @@ + static _TAO_ConsumesDef_Remote_Proxy_Broker *the_TAO_ConsumesDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConsumesDef; +- +- +-#if !defined (_TAO_IR_COMPONENTDEF___PTR_CH_) +-#define _TAO_IR_COMPONENTDEF___PTR_CH_ +- +-class ComponentDef; +-typedef ComponentDef *ComponentDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_COMPONENTDEF___VAR_CH_) +-#define _TAO_IR_COMPONENTDEF___VAR_CH_ +- +-class TAO_Export ComponentDef_var : public TAO_Base_var +-{ +-public: +- ComponentDef_var (void); // default constructor +- ComponentDef_var (ComponentDef_ptr p) : ptr_ (p) {} +- ComponentDef_var (const ComponentDef_var &); // copy constructor +- ~ComponentDef_var (void); // destructor +- +- ComponentDef_var &operator= (ComponentDef_ptr); +- ComponentDef_var &operator= (const ComponentDef_var &); +- ComponentDef_ptr operator-> (void) const; +- +- operator const ComponentDef_ptr &() const; +- operator ComponentDef_ptr &(); +- // in, inout, out, _retn +- ComponentDef_ptr in (void) const; +- ComponentDef_ptr &inout (void); +- ComponentDef_ptr &out (void); +- ComponentDef_ptr _retn (void); +- ComponentDef_ptr ptr (void) const; +- +-private: +- ComponentDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- ComponentDef_var (const TAO_Base_var &rhs); +- ComponentDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_COMPONENTDEF___OUT_CH_) +-#define _TAO_IR_COMPONENTDEF___OUT_CH_ +- +-class TAO_Export ComponentDef_out +-{ +-public: +- ComponentDef_out (ComponentDef_ptr &); +- ComponentDef_out (ComponentDef_var &); +- ComponentDef_out (const ComponentDef_out &); +- ComponentDef_out &operator= (const ComponentDef_out &); +- ComponentDef_out &operator= (const ComponentDef_var &); +- ComponentDef_out &operator= (ComponentDef_ptr); +- operator ComponentDef_ptr &(); +- ComponentDef_ptr &ptr (void); +- ComponentDef_ptr operator-> (void); +- +-private: +- ComponentDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_COMPONENTDEF_CH_) +-#define _TAO_IR_COMPONENTDEF_CH_ +- + // Forward Classes Declaration + class _TAO_ComponentDef_Proxy_Impl; + class _TAO_ComponentDef_Remote_Proxy_Impl; + class _TAO_ComponentDef_Proxy_Broker; + class _TAO_ComponentDef_Remote_Proxy_Broker; + +-class TAO_Export ComponentDef: public virtual InterfaceDef ++class TAO_Export IR_ComponentDef: public virtual IR_InterfaceDef + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ComponentDef_ptr _ptr_type; +- typedef ComponentDef_var _var_type; ++ typedef IR_ComponentDef_ptr _ptr_type; ++ typedef IR_ComponentDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static ComponentDef_ptr _duplicate (ComponentDef_ptr obj); +- static ComponentDef_ptr _narrow ( ++ static IR_ComponentDef_ptr _duplicate (IR_ComponentDef_ptr obj); ++ static IR_ComponentDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ComponentDef_ptr _unchecked_narrow ( ++ static IR_ComponentDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static ComponentDef_ptr _nil (void) ++ static IR_ComponentDef_ptr _nil (void) + { +- return (ComponentDef_ptr)0; ++ return (IR_ComponentDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::InterfaceDefSeq * supported_interfaces ( ++ virtual IR_InterfaceDefSeq * supported_interfaces ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -25967,39 +15799,7 @@ + )); + + virtual void supported_interfaces ( +- const IR::InterfaceDefSeq & supported_interfaces, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual IR::ComponentDef_ptr base_component ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual IR::ProvidesDefSeq * provides_interfaces ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual IR::UsesDefSeq * uses_interfaces ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual IR::EmitsDefSeq * emits_events ( ++ const IR_InterfaceDefSeq & supported_interfaces, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -26007,7 +15807,7 @@ + CORBA::SystemException + )); + +- virtual IR::PublishesDefSeq * publishes_events ( ++ virtual IR_ComponentDef_ptr base_component ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -26015,7 +15815,7 @@ + CORBA::SystemException + )); + +- virtual IR::ConsumesDefSeq * consumes_events ( ++ virtual IR_ProvidesDefSeq * provides_interfaces ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -26023,7 +15823,7 @@ + CORBA::SystemException + )); + +- virtual CORBA::Boolean is_basic ( ++ virtual IR_UsesDefSeq * uses_interfaces ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -26031,756 +15831,135 @@ + CORBA::SystemException + )); + +- virtual IR::ProvidesDef_ptr create_provides ( +- const char * id, +- const char * name, +- const char * version, +- IR::InterfaceDef_ptr interface_type, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual IR::UsesDef_ptr create_uses ( +- const char * id, +- const char * name, +- const char * version, +- IR::InterfaceDef_ptr interface_type, +- CORBA::Boolean is_multiple, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual IR::EmitsDef_ptr create_emits ( +- const char * id, +- const char * name, +- const char * version, +- IR::ValueDef_ptr value, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual IR::PublishesDef_ptr create_publishes ( +- const char * id, +- const char * name, +- const char * version, +- IR::ValueDef_ptr value, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual IR::ConsumesDef_ptr create_consumes ( +- const char * id, +- const char * name, +- const char * version, +- IR::ValueDef_ptr value, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual CORBA::Boolean _is_a ( +- const CORBA::Char *type_id, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- virtual void *_tao_QueryInterface (ptr_arith_t type); +- +- virtual const char* _interface_repository_id (void) const; +- +-private: +- _TAO_ComponentDef_Proxy_Broker *the_TAO_ComponentDef_Proxy_Broker_; +- +-protected: +- ComponentDef (int collocated = 0); +- +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); +- +- ComponentDef ( +- TAO_Stub *objref, +- CORBA::Boolean _tao_collocated = 0, +- TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +- virtual ~ComponentDef (void); +- private: +- ComponentDef (const ComponentDef &); +- void operator= (const ComponentDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ComponentDef; +- +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get (const TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_get &); +- void result (IR::InterfaceDefSeq * result); +- // update the result +- IR::InterfaceDefSeq * result_; +- }; +- +- class TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::ComponentDef; +- +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const IR::InterfaceDefSeq & supported_interfaces, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set (const TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_supported_interfaces_set &); +- const IR::InterfaceDefSeq & supported_interfaces_; +- +-}; +- +-class TAO_ClientRequestInfo_IR_ComponentDef_base_component_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ComponentDef; +- +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ComponentDef_base_component_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_base_component_get (const TAO_ClientRequestInfo_IR_ComponentDef_base_component_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_base_component_get &); +- void result (IR::ComponentDef_ptr result); +- // update the result +- IR::ComponentDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ComponentDef; +- +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get (const TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_provides_interfaces_get &); +- void result (IR::ProvidesDefSeq * result); +- // update the result +- IR::ProvidesDefSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ComponentDef; +- +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get (const TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_uses_interfaces_get &); +- void result (IR::UsesDefSeq * result); +- // update the result +- IR::UsesDefSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ComponentDef; +- +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get (const TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_emits_events_get &); +- void result (IR::EmitsDefSeq * result); +- // update the result +- IR::EmitsDefSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ComponentDef; +- +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get (const TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_publishes_events_get &); +- void result (IR::PublishesDefSeq * result); +- // update the result +- IR::PublishesDefSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ComponentDef; +- +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get (const TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_consumes_events_get &); +- void result (IR::ConsumesDefSeq * result); +- // update the result +- IR::ConsumesDefSeq * result_; +-}; ++ virtual IR_EmitsDefSeq * emits_events ( ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )); + +-class TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ComponentDef; +- +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; ++ virtual IR_PublishesDefSeq * publishes_events ( ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )); + +-TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); ++ virtual IR_ConsumesDefSeq * consumes_events ( ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )); + +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual CORBA::Boolean is_basic ( ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )); + +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual IR_ProvidesDef_ptr create_provides ( ++ const char * id, ++ const char * name, ++ const char * version, ++ IR_InterfaceDef_ptr interface_type, ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )); + +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ virtual IR_UsesDef_ptr create_uses ( ++ const char * id, ++ const char * name, ++ const char * version, ++ IR_InterfaceDef_ptr interface_type, ++ CORBA::Boolean is_multiple, ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )); + +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get (const TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_is_basic_get &); +- void result (CORBA::Boolean result); +- // update the result +- CORBA::Boolean result_; +-}; ++ virtual IR_EmitsDef_ptr create_emits ( ++ const char * id, ++ const char * name, ++ const char * version, ++ IR_ValueDef_ptr value, ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )); + +-class TAO_ClientRequestInfo_IR_ComponentDef_create_provides : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ComponentDef; +- +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; ++ virtual IR_PublishesDef_ptr create_publishes ( ++ const char * id, ++ const char * name, ++ const char * version, ++ IR_ValueDef_ptr value, ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )); + +-TAO_ClientRequestInfo_IR_ComponentDef_create_provides ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::InterfaceDef_ptr interface_type, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_create_provides (const TAO_ClientRequestInfo_IR_ComponentDef_create_provides &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_create_provides &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::InterfaceDef_ptr interface_type_; +- void result (IR::ProvidesDef_ptr result); +- // update the result +- IR::ProvidesDef_ptr result_; +-}; ++ virtual IR_ConsumesDef_ptr create_consumes ( ++ const char * id, ++ const char * name, ++ const char * version, ++ IR_ValueDef_ptr value, ++ CORBA::Environment &ACE_TRY_ENV = ++ TAO_default_environment () ++ ) ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )); + +-class TAO_ClientRequestInfo_IR_ComponentDef_create_uses : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ComponentDef; ++ 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); + +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ComponentDef_create_uses ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::InterfaceDef_ptr interface_type, +- const CORBA::Boolean & is_multiple, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_create_uses (const TAO_ClientRequestInfo_IR_ComponentDef_create_uses &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_create_uses &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::InterfaceDef_ptr interface_type_; +- const CORBA::Boolean & is_multiple_; +- void result (IR::UsesDef_ptr result); +- // update the result +- IR::UsesDef_ptr result_; +-}; ++ virtual const char* _interface_repository_id (void) const; + +-class TAO_ClientRequestInfo_IR_ComponentDef_create_emits : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ComponentDef; ++private: ++ _TAO_ComponentDef_Proxy_Broker *the_TAO_ComponentDef_Proxy_Broker_; + +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ComponentDef_create_emits ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::ValueDef_ptr value, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_create_emits (const TAO_ClientRequestInfo_IR_ComponentDef_create_emits &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_create_emits &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::ValueDef_ptr value_; +- void result (IR::EmitsDef_ptr result); +- // update the result +- IR::EmitsDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ComponentDef_create_publishes : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ComponentDef; ++protected: ++ IR_ComponentDef (int collocated = 0); + ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); ++ ++ IR_ComponentDef ( ++ TAO_Stub *objref, ++ CORBA::Boolean _tao_collocated = 0, ++ TAO_Abstract_ServantBase *servant = 0 ++ ); ++ + friend class _TAO_ComponentDef_Remote_Proxy_Impl; + friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; + friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ComponentDef_create_publishes ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::ValueDef_ptr value, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_create_publishes (const TAO_ClientRequestInfo_IR_ComponentDef_create_publishes &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_create_publishes &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::ValueDef_ptr value_; +- void result (IR::PublishesDef_ptr result); +- // update the result +- IR::PublishesDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_ComponentDef_create_consumes : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::ComponentDef; + +- friend class _TAO_ComponentDef_Remote_Proxy_Impl; +- friend class _TAO_ComponentDef_ThruPOA_Proxy_Impl; +- friend class _TAO_ComponentDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_ComponentDef_create_consumes ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::ValueDef_ptr value, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_ComponentDef_create_consumes (const TAO_ClientRequestInfo_IR_ComponentDef_create_consumes &); +- void operator= (const TAO_ClientRequestInfo_IR_ComponentDef_create_consumes &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::ValueDef_ptr value_; +- void result (IR::ConsumesDef_ptr result); +- // update the result +- IR::ConsumesDef_ptr result_; +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ virtual ~IR_ComponentDef (void); ++private: ++ IR_ComponentDef (const IR_ComponentDef &); ++ void operator= (const IR_ComponentDef &); + }; + +- + // The Proxy Implementations are used by each interface to + // perform a call. Each different implementation encapsulate + // an invocation logics. +@@ -26791,12 +15970,12 @@ + // + + class TAO_Export _TAO_ComponentDef_Proxy_Impl : +- public virtual IR::_TAO_InterfaceDef_Proxy_Impl ++ public virtual _TAO_InterfaceDef_Proxy_Impl + { + public: + virtual ~_TAO_ComponentDef_Proxy_Impl (void) { } + +- virtual IR::InterfaceDefSeq * supported_interfaces ( ++ virtual IR_InterfaceDefSeq * supported_interfaces ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -26806,14 +15985,14 @@ + + virtual void supported_interfaces ( + CORBA_Object *_collocated_tao_target_, +- const IR::InterfaceDefSeq & supported_interfaces, ++ const IR_InterfaceDefSeq & supported_interfaces, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::ComponentDef_ptr base_component ( ++ virtual IR_ComponentDef_ptr base_component ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -26821,7 +16000,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::ProvidesDefSeq * provides_interfaces ( ++ virtual IR_ProvidesDefSeq * provides_interfaces ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -26829,7 +16008,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::UsesDefSeq * uses_interfaces ( ++ virtual IR_UsesDefSeq * uses_interfaces ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -26837,7 +16016,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::EmitsDefSeq * emits_events ( ++ virtual IR_EmitsDefSeq * emits_events ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -26845,7 +16024,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::PublishesDefSeq * publishes_events ( ++ virtual IR_PublishesDefSeq * publishes_events ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -26853,7 +16032,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::ConsumesDefSeq * consumes_events ( ++ virtual IR_ConsumesDefSeq * consumes_events ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -26869,24 +16048,24 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::ProvidesDef_ptr create_provides ( ++ virtual IR_ProvidesDef_ptr create_provides ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::InterfaceDef_ptr interface_type, ++ IR_InterfaceDef_ptr interface_type, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::UsesDef_ptr create_uses ( ++ virtual IR_UsesDef_ptr create_uses ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::InterfaceDef_ptr interface_type, ++ IR_InterfaceDef_ptr interface_type, + CORBA::Boolean is_multiple, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -26894,36 +16073,36 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::EmitsDef_ptr create_emits ( ++ virtual IR_EmitsDef_ptr create_emits ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::ValueDef_ptr value, ++ IR_ValueDef_ptr value, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::PublishesDef_ptr create_publishes ( ++ virtual IR_PublishesDef_ptr create_publishes ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::ValueDef_ptr value, ++ IR_ValueDef_ptr value, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::ConsumesDef_ptr create_consumes ( ++ virtual IR_ConsumesDef_ptr create_consumes ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::ValueDef_ptr value, ++ IR_ValueDef_ptr value, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -26934,6 +16113,7 @@ + _TAO_ComponentDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -26946,7 +16126,7 @@ + class TAO_Export _TAO_ComponentDef_Remote_Proxy_Impl : + public virtual _TAO_ComponentDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_InterfaceDef_Remote_Proxy_Impl ++ public virtual _TAO_InterfaceDef_Remote_Proxy_Impl + + { + public: +@@ -26954,7 +16134,7 @@ + + virtual ~_TAO_ComponentDef_Remote_Proxy_Impl (void) { } + +- virtual IR::InterfaceDefSeq * supported_interfaces ( ++ virtual IR_InterfaceDefSeq * supported_interfaces ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -26964,14 +16144,14 @@ + + virtual void supported_interfaces ( + CORBA_Object *_collocated_tao_target_, +- const IR::InterfaceDefSeq & supported_interfaces, ++ const IR_InterfaceDefSeq & supported_interfaces, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::ComponentDef_ptr base_component ( ++ virtual IR_ComponentDef_ptr base_component ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -26979,7 +16159,7 @@ + CORBA::SystemException + )); + +- virtual IR::ProvidesDefSeq * provides_interfaces ( ++ virtual IR_ProvidesDefSeq * provides_interfaces ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -26987,7 +16167,7 @@ + CORBA::SystemException + )); + +- virtual IR::UsesDefSeq * uses_interfaces ( ++ virtual IR_UsesDefSeq * uses_interfaces ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -26995,7 +16175,7 @@ + CORBA::SystemException + )); + +- virtual IR::EmitsDefSeq * emits_events ( ++ virtual IR_EmitsDefSeq * emits_events ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -27003,7 +16183,7 @@ + CORBA::SystemException + )); + +- virtual IR::PublishesDefSeq * publishes_events ( ++ virtual IR_PublishesDefSeq * publishes_events ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -27011,7 +16191,7 @@ + CORBA::SystemException + )); + +- virtual IR::ConsumesDefSeq * consumes_events ( ++ virtual IR_ConsumesDefSeq * consumes_events ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -27027,24 +16207,24 @@ + CORBA::SystemException + )); + +- virtual IR::ProvidesDef_ptr create_provides ( ++ virtual IR_ProvidesDef_ptr create_provides ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::InterfaceDef_ptr interface_type, ++ IR_InterfaceDef_ptr interface_type, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::UsesDef_ptr create_uses ( ++ virtual IR_UsesDef_ptr create_uses ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::InterfaceDef_ptr interface_type, ++ IR_InterfaceDef_ptr interface_type, + CORBA::Boolean is_multiple, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -27052,36 +16232,36 @@ + CORBA::SystemException + )); + +- virtual IR::EmitsDef_ptr create_emits ( ++ virtual IR_EmitsDef_ptr create_emits ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::ValueDef_ptr value, ++ IR_ValueDef_ptr value, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::PublishesDef_ptr create_publishes ( ++ virtual IR_PublishesDef_ptr create_publishes ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::ValueDef_ptr value, ++ IR_ValueDef_ptr value, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::ConsumesDef_ptr create_consumes ( ++ virtual IR_ConsumesDef_ptr create_consumes ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::ValueDef_ptr value, ++ IR_ValueDef_ptr value, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -27110,8 +16290,9 @@ + { + public: + virtual ~_TAO_ComponentDef_Proxy_Broker (void); ++ + virtual _TAO_ComponentDef_Proxy_Impl &select_proxy ( +- ComponentDef *object, ++ IR_ComponentDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -27136,9 +16317,9 @@ + _TAO_ComponentDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_ComponentDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_ComponentDef_Proxy_Impl &select_proxy ( +- ComponentDef *object, ++ IR_ComponentDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -27152,24 +16333,15 @@ + static _TAO_ComponentDef_Remote_Proxy_Broker *the_TAO_ComponentDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentDef; +- +-struct ComponentDescription; +-class ComponentDescription_var; +- +-struct TAO_Export ComponentDescription ++struct TAO_Export IR_ComponentDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef ComponentDescription_var _var_type; ++ typedef IR_ComponentDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -27179,317 +16351,147 @@ + TAO_String_Manager defined_in; + TAO_String_Manager version; + TAO_String_Manager base_component; +- ACE_NESTED_CLASS (IR, RepositoryIdSeq) supports_interfaces; +- ACE_NESTED_CLASS (IR, ProvidesDefSeq) provides_interfaces; +- ACE_NESTED_CLASS (IR, UsesDefSeq) uses_interfaces; +- ACE_NESTED_CLASS (IR, AttrDescriptionSeq) attributes; +- ACE_NESTED_CLASS (IR, EmitsDefSeq) emits_events; +- ACE_NESTED_CLASS (IR, PublishesDefSeq) publishes_events; +- ACE_NESTED_CLASS (IR, ConsumesDefSeq) consumes_events; ++ IR_RepositoryIdSeq supports_interfaces; ++ IR_ProvidesDefSeq provides_interfaces; ++ IR_UsesDefSeq uses_interfaces; ++ IR_AttrDescriptionSeq attributes; ++ IR_EmitsDefSeq emits_events; ++ IR_PublishesDefSeq publishes_events; ++ IR_ConsumesDefSeq consumes_events; + CORBA::Boolean is_basic; + }; + +-class TAO_Export ComponentDescription_var +-{ +-public: +- ComponentDescription_var (void); // default constructor +- ComponentDescription_var (ComponentDescription *); +- ComponentDescription_var (const ComponentDescription_var &); // copy constructor +- ~ComponentDescription_var (void); // destructor +- +- ComponentDescription_var &operator= (ComponentDescription *); +- ComponentDescription_var &operator= (const ComponentDescription_var &); +- ComponentDescription *operator-> (void); +- const ComponentDescription *operator-> (void) const; +- +- operator const ComponentDescription &() const; +- operator ComponentDescription &(); +- operator ComponentDescription &() const; +- operator ComponentDescription *&(); // variable-size types only +- +- // in, inout, out, _retn +- const ComponentDescription &in (void) const; +- ComponentDescription &inout (void); +- ComponentDescription *&out (void); +- ComponentDescription *_retn (void); +- ComponentDescription *ptr (void) const; +- +-private: +- ComponentDescription *ptr_; +-}; +- +-class TAO_Export ComponentDescription_out ++class TAO_Export IR_ComponentDescription_var + { + public: +- ComponentDescription_out (ComponentDescription *&); +- ComponentDescription_out (ComponentDescription_var &); +- ComponentDescription_out (const ComponentDescription_out &); +- ComponentDescription_out &operator= (const ComponentDescription_out &); +- ComponentDescription_out &operator= (ComponentDescription *); +- operator ComponentDescription *&(); +- ComponentDescription *&ptr (void); +- ComponentDescription *operator-> (void); ++ IR_ComponentDescription_var (void); // default constructor ++ IR_ComponentDescription_var (IR_ComponentDescription *); ++ IR_ComponentDescription_var (const IR_ComponentDescription_var &); // copy constructor ++ ~IR_ComponentDescription_var (void); // destructor + +-private: +- ComponentDescription *&ptr_; +- // assignment from T_var not allowed +- void operator= (const ComponentDescription_var &); +-}; +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentDescription; +- +- +-#if !defined (_TAO_IR_PRIMARYKEYDEF___PTR_CH_) +-#define _TAO_IR_PRIMARYKEYDEF___PTR_CH_ +- +-class PrimaryKeyDef; +-typedef PrimaryKeyDef *PrimaryKeyDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PRIMARYKEYDEF___VAR_CH_) +-#define _TAO_IR_PRIMARYKEYDEF___VAR_CH_ +- +-class TAO_Export PrimaryKeyDef_var : public TAO_Base_var +-{ +-public: +- PrimaryKeyDef_var (void); // default constructor +- PrimaryKeyDef_var (PrimaryKeyDef_ptr p) : ptr_ (p) {} +- PrimaryKeyDef_var (const PrimaryKeyDef_var &); // copy constructor +- ~PrimaryKeyDef_var (void); // destructor ++ IR_ComponentDescription_var &operator= (IR_ComponentDescription *); ++ IR_ComponentDescription_var &operator= (const IR_ComponentDescription_var &); ++ IR_ComponentDescription *operator-> (void); ++ const IR_ComponentDescription *operator-> (void) const; + +- PrimaryKeyDef_var &operator= (PrimaryKeyDef_ptr); +- PrimaryKeyDef_var &operator= (const PrimaryKeyDef_var &); +- PrimaryKeyDef_ptr operator-> (void) const; ++ operator const IR_ComponentDescription &() const; ++ operator IR_ComponentDescription &(); ++ operator IR_ComponentDescription &() const; ++ operator IR_ComponentDescription *&(); // variable-size types only + +- operator const PrimaryKeyDef_ptr &() const; +- operator PrimaryKeyDef_ptr &(); + // in, inout, out, _retn +- PrimaryKeyDef_ptr in (void) const; +- PrimaryKeyDef_ptr &inout (void); +- PrimaryKeyDef_ptr &out (void); +- PrimaryKeyDef_ptr _retn (void); +- PrimaryKeyDef_ptr ptr (void) const; ++ const IR_ComponentDescription &in (void) const; ++ IR_ComponentDescription &inout (void); ++ IR_ComponentDescription *&out (void); ++ IR_ComponentDescription *_retn (void); ++ IR_ComponentDescription *ptr (void) const; + + private: +- PrimaryKeyDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- PrimaryKeyDef_var (const TAO_Base_var &rhs); +- PrimaryKeyDef_var &operator= (const TAO_Base_var &rhs); ++ IR_ComponentDescription *ptr_; + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PRIMARYKEYDEF___OUT_CH_) +-#define _TAO_IR_PRIMARYKEYDEF___OUT_CH_ +- +-class TAO_Export PrimaryKeyDef_out ++class TAO_Export IR_ComponentDescription_out + { + public: +- PrimaryKeyDef_out (PrimaryKeyDef_ptr &); +- PrimaryKeyDef_out (PrimaryKeyDef_var &); +- PrimaryKeyDef_out (const PrimaryKeyDef_out &); +- PrimaryKeyDef_out &operator= (const PrimaryKeyDef_out &); +- PrimaryKeyDef_out &operator= (const PrimaryKeyDef_var &); +- PrimaryKeyDef_out &operator= (PrimaryKeyDef_ptr); +- operator PrimaryKeyDef_ptr &(); +- PrimaryKeyDef_ptr &ptr (void); +- PrimaryKeyDef_ptr operator-> (void); ++ IR_ComponentDescription_out (IR_ComponentDescription *&); ++ IR_ComponentDescription_out (IR_ComponentDescription_var &); ++ IR_ComponentDescription_out (const IR_ComponentDescription_out &); ++ IR_ComponentDescription_out &operator= (const IR_ComponentDescription_out &); ++ IR_ComponentDescription_out &operator= (IR_ComponentDescription *); ++ operator IR_ComponentDescription *&(); ++ IR_ComponentDescription *&ptr (void); ++ IR_ComponentDescription *operator-> (void); + + private: +- PrimaryKeyDef_ptr &ptr_; ++ IR_ComponentDescription *&ptr_; ++ // assignment from T_var not allowed ++ void operator= (const IR_ComponentDescription_var &); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_PRIMARYKEYDEF_CH_) +-#define _TAO_IR_PRIMARYKEYDEF_CH_ +- + // Forward Classes Declaration + class _TAO_PrimaryKeyDef_Proxy_Impl; + class _TAO_PrimaryKeyDef_Remote_Proxy_Impl; + class _TAO_PrimaryKeyDef_Proxy_Broker; + class _TAO_PrimaryKeyDef_Remote_Proxy_Broker; + +-class TAO_Export PrimaryKeyDef: public virtual Contained ++class TAO_Export IR_PrimaryKeyDef: public virtual IR_Contained + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef PrimaryKeyDef_ptr _ptr_type; +- typedef PrimaryKeyDef_var _var_type; ++ typedef IR_PrimaryKeyDef_ptr _ptr_type; ++ typedef IR_PrimaryKeyDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static PrimaryKeyDef_ptr _duplicate (PrimaryKeyDef_ptr obj); +- static PrimaryKeyDef_ptr _narrow ( +- CORBA::Object_ptr obj, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- static PrimaryKeyDef_ptr _unchecked_narrow ( ++ static IR_PrimaryKeyDef_ptr _duplicate (IR_PrimaryKeyDef_ptr obj); ++ static IR_PrimaryKeyDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () +- ); +- static PrimaryKeyDef_ptr _nil (void) +- { +- return (PrimaryKeyDef_ptr)0; +- } +- +- static void _tao_any_destructor (void*); +- +- virtual CORBA::Boolean is_a ( +- const char * primary_key_id, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual IR::ValueDef_ptr primary_key ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC (( +- CORBA::SystemException +- )); +- +- virtual CORBA::Boolean _is_a ( +- const CORBA::Char *type_id, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- virtual void *_tao_QueryInterface (ptr_arith_t type); +- +- virtual const char* _interface_repository_id (void) const; +- +-private: +- _TAO_PrimaryKeyDef_Proxy_Broker *the_TAO_PrimaryKeyDef_Proxy_Broker_; +- +-protected: +- PrimaryKeyDef (int collocated = 0); +- +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); +- +- PrimaryKeyDef ( +- TAO_Stub *objref, +- CORBA::Boolean _tao_collocated = 0, +- TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_PrimaryKeyDef_Remote_Proxy_Impl; +- friend class _TAO_PrimaryKeyDef_ThruPOA_Proxy_Impl; +- friend class _TAO_PrimaryKeyDef_Direct_Proxy_Impl; +- +- virtual ~PrimaryKeyDef (void); +- private: +- PrimaryKeyDef (const PrimaryKeyDef &); +- void operator= (const PrimaryKeyDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::PrimaryKeyDef; +- +- friend class _TAO_PrimaryKeyDef_Remote_Proxy_Impl; +- friend class _TAO_PrimaryKeyDef_ThruPOA_Proxy_Impl; +- friend class _TAO_PrimaryKeyDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * primary_key_id, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a (const TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a &); +- void operator= (const TAO_ClientRequestInfo_IR_PrimaryKeyDef_is_a &); +- const char * primary_key_id_; +- void result (CORBA::Boolean result); +- // update the result +- CORBA::Boolean result_; +- }; +- +- class TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::PrimaryKeyDef; +- +- friend class _TAO_PrimaryKeyDef_Remote_Proxy_Impl; +- friend class _TAO_PrimaryKeyDef_ThruPOA_Proxy_Impl; +- friend class _TAO_PrimaryKeyDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, ++ ); ++ static IR_PrimaryKeyDef_ptr _unchecked_narrow ( ++ CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- +- virtual Dynamic::ParameterList * arguments ( ++ static IR_PrimaryKeyDef_ptr _nil (void) ++ { ++ return (IR_PrimaryKeyDef_ptr)0; ++ } ++ ++ static void _tao_any_destructor (void*); ++ ++ virtual CORBA::Boolean is_a ( ++ const char * primary_key_id, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )); ++ ++ virtual IR_ValueDef_ptr primary_key ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( ++ ACE_THROW_SPEC (( ++ CORBA::SystemException ++ )); ++ ++ virtual CORBA::Boolean _is_a ( ++ const CORBA::Char *type_id, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); ++ ); ++ virtual void *_tao_QueryInterface (ptr_arith_t type); + +-private: +- TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get (const TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get &); +- void operator= (const TAO_ClientRequestInfo_IR_PrimaryKeyDef_primary_key_get &); +- void result (IR::ValueDef_ptr result); +- // update the result +- IR::ValueDef_ptr result_; +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ ++ virtual const char* _interface_repository_id (void) const; + ++private: ++ _TAO_PrimaryKeyDef_Proxy_Broker *the_TAO_PrimaryKeyDef_Proxy_Broker_; ++ ++protected: ++ IR_PrimaryKeyDef (int collocated = 0); ++ ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); ++ ++ IR_PrimaryKeyDef ( ++ TAO_Stub *objref, ++ CORBA::Boolean _tao_collocated = 0, ++ TAO_Abstract_ServantBase *servant = 0 ++ ); ++ ++ friend class _TAO_PrimaryKeyDef_Remote_Proxy_Impl; ++ friend class _TAO_PrimaryKeyDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_PrimaryKeyDef_Direct_Proxy_Impl; ++ ++ virtual ~IR_PrimaryKeyDef (void); ++private: ++ IR_PrimaryKeyDef (const IR_PrimaryKeyDef &); ++ void operator= (const IR_PrimaryKeyDef &); + }; + + +@@ -27503,12 +16505,12 @@ + // + + class TAO_Export _TAO_PrimaryKeyDef_Proxy_Impl : +- public virtual IR::_TAO_Contained_Proxy_Impl ++ public virtual _TAO_Contained_Proxy_Impl + { + public: + virtual ~_TAO_PrimaryKeyDef_Proxy_Impl (void) { } + +- virtual CORBA::Boolean is_a ( ++ virtual CORBA::Boolean is_a ( + CORBA_Object *_collocated_tao_target_, + const char * primary_key_id, + CORBA::Environment &ACE_TRY_ENV +@@ -27517,7 +16519,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::ValueDef_ptr primary_key ( ++ virtual IR_ValueDef_ptr primary_key ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -27529,6 +16531,7 @@ + _TAO_PrimaryKeyDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -27541,7 +16544,7 @@ + class TAO_Export _TAO_PrimaryKeyDef_Remote_Proxy_Impl : + public virtual _TAO_PrimaryKeyDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_Contained_Remote_Proxy_Impl ++ public virtual _TAO_Contained_Remote_Proxy_Impl + + { + public: +@@ -27549,7 +16552,7 @@ + + virtual ~_TAO_PrimaryKeyDef_Remote_Proxy_Impl (void) { } + +- virtual CORBA::Boolean is_a ( ++ virtual CORBA::Boolean is_a ( + CORBA_Object *_collocated_tao_target_, + const char * primary_key_id, + CORBA::Environment &ACE_TRY_ENV +@@ -27558,7 +16561,7 @@ + CORBA::SystemException + )); + +- virtual IR::ValueDef_ptr primary_key ( ++ virtual IR_ValueDef_ptr primary_key ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -27588,8 +16591,9 @@ + { + public: + virtual ~_TAO_PrimaryKeyDef_Proxy_Broker (void); ++ + virtual _TAO_PrimaryKeyDef_Proxy_Impl &select_proxy ( +- PrimaryKeyDef *object, ++ IR_PrimaryKeyDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -27614,9 +16618,9 @@ + _TAO_PrimaryKeyDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_PrimaryKeyDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_PrimaryKeyDef_Proxy_Impl &select_proxy ( +- PrimaryKeyDef *object, ++ IR_PrimaryKeyDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -27630,24 +16634,15 @@ + static _TAO_PrimaryKeyDef_Remote_Proxy_Broker *the_TAO_PrimaryKeyDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimaryKeyDef; +- +-struct PrimaryKeyDescription; +-class PrimaryKeyDescription_var; +- +-struct TAO_Export PrimaryKeyDescription ++struct TAO_Export IR_PrimaryKeyDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef PrimaryKeyDescription_var _var_type; ++ typedef IR_PrimaryKeyDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -27656,159 +16651,85 @@ + TAO_String_Manager id; + TAO_String_Manager defined_in; + TAO_String_Manager version; +- ACE_NESTED_CLASS (IR, ValueDef_var) primary_key; ++ IR_ValueDef_var primary_key; + }; + +-class TAO_Export PrimaryKeyDescription_var ++class TAO_Export IR_PrimaryKeyDescription_var + { + public: +- PrimaryKeyDescription_var (void); // default constructor +- PrimaryKeyDescription_var (PrimaryKeyDescription *); +- PrimaryKeyDescription_var (const PrimaryKeyDescription_var &); // copy constructor +- ~PrimaryKeyDescription_var (void); // destructor ++ IR_PrimaryKeyDescription_var (void); // default constructor ++ IR_PrimaryKeyDescription_var (IR_PrimaryKeyDescription *); ++ IR_PrimaryKeyDescription_var (const IR_PrimaryKeyDescription_var &); // copy constructor ++ ~IR_PrimaryKeyDescription_var (void); // destructor + +- PrimaryKeyDescription_var &operator= (PrimaryKeyDescription *); +- PrimaryKeyDescription_var &operator= (const PrimaryKeyDescription_var &); +- PrimaryKeyDescription *operator-> (void); +- const PrimaryKeyDescription *operator-> (void) const; ++ IR_PrimaryKeyDescription_var &operator= (IR_PrimaryKeyDescription *); ++ IR_PrimaryKeyDescription_var &operator= (const IR_PrimaryKeyDescription_var &); ++ IR_PrimaryKeyDescription *operator-> (void); ++ const IR_PrimaryKeyDescription *operator-> (void) const; + +- operator const PrimaryKeyDescription &() const; +- operator PrimaryKeyDescription &(); +- operator PrimaryKeyDescription &() const; +- operator PrimaryKeyDescription *&(); // variable-size types only ++ operator const IR_PrimaryKeyDescription &() const; ++ operator IR_PrimaryKeyDescription &(); ++ operator IR_PrimaryKeyDescription &() const; ++ operator IR_PrimaryKeyDescription *&(); // variable-size types only + + // in, inout, out, _retn +- const PrimaryKeyDescription &in (void) const; +- PrimaryKeyDescription &inout (void); +- PrimaryKeyDescription *&out (void); +- PrimaryKeyDescription *_retn (void); +- PrimaryKeyDescription *ptr (void) const; ++ const IR_PrimaryKeyDescription &in (void) const; ++ IR_PrimaryKeyDescription &inout (void); ++ IR_PrimaryKeyDescription *&out (void); ++ IR_PrimaryKeyDescription *_retn (void); ++ IR_PrimaryKeyDescription *ptr (void) const; + + private: +- PrimaryKeyDescription *ptr_; ++ IR_PrimaryKeyDescription *ptr_; + }; + +-class TAO_Export PrimaryKeyDescription_out ++class TAO_Export IR_PrimaryKeyDescription_out + { + public: +- PrimaryKeyDescription_out (PrimaryKeyDescription *&); +- PrimaryKeyDescription_out (PrimaryKeyDescription_var &); +- PrimaryKeyDescription_out (const PrimaryKeyDescription_out &); +- PrimaryKeyDescription_out &operator= (const PrimaryKeyDescription_out &); +- PrimaryKeyDescription_out &operator= (PrimaryKeyDescription *); +- operator PrimaryKeyDescription *&(); +- PrimaryKeyDescription *&ptr (void); +- PrimaryKeyDescription *operator-> (void); ++ IR_PrimaryKeyDescription_out (IR_PrimaryKeyDescription *&); ++ IR_PrimaryKeyDescription_out (IR_PrimaryKeyDescription_var &); ++ IR_PrimaryKeyDescription_out (const IR_PrimaryKeyDescription_out &); ++ IR_PrimaryKeyDescription_out &operator= (const IR_PrimaryKeyDescription_out &); ++ IR_PrimaryKeyDescription_out &operator= (IR_PrimaryKeyDescription *); ++ operator IR_PrimaryKeyDescription *&(); ++ IR_PrimaryKeyDescription *&ptr (void); ++ IR_PrimaryKeyDescription *operator-> (void); + + private: +- PrimaryKeyDescription *&ptr_; ++ IR_PrimaryKeyDescription *&ptr_; + // assignment from T_var not allowed +- void operator= (const PrimaryKeyDescription_var &); +-}; +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimaryKeyDescription; +- +- +-#if !defined (_TAO_IR_FACTORYDEF___PTR_CH_) +-#define _TAO_IR_FACTORYDEF___PTR_CH_ +- +-class FactoryDef; +-typedef FactoryDef *FactoryDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FACTORYDEF___VAR_CH_) +-#define _TAO_IR_FACTORYDEF___VAR_CH_ +- +-class TAO_Export FactoryDef_var : public TAO_Base_var +-{ +-public: +- FactoryDef_var (void); // default constructor +- FactoryDef_var (FactoryDef_ptr p) : ptr_ (p) {} +- FactoryDef_var (const FactoryDef_var &); // copy constructor +- ~FactoryDef_var (void); // destructor +- +- FactoryDef_var &operator= (FactoryDef_ptr); +- FactoryDef_var &operator= (const FactoryDef_var &); +- FactoryDef_ptr operator-> (void) const; +- +- operator const FactoryDef_ptr &() const; +- operator FactoryDef_ptr &(); +- // in, inout, out, _retn +- FactoryDef_ptr in (void) const; +- FactoryDef_ptr &inout (void); +- FactoryDef_ptr &out (void); +- FactoryDef_ptr _retn (void); +- FactoryDef_ptr ptr (void) const; +- +-private: +- FactoryDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- FactoryDef_var (const TAO_Base_var &rhs); +- FactoryDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FACTORYDEF___OUT_CH_) +-#define _TAO_IR_FACTORYDEF___OUT_CH_ +- +-class TAO_Export FactoryDef_out +-{ +-public: +- FactoryDef_out (FactoryDef_ptr &); +- FactoryDef_out (FactoryDef_var &); +- FactoryDef_out (const FactoryDef_out &); +- FactoryDef_out &operator= (const FactoryDef_out &); +- FactoryDef_out &operator= (const FactoryDef_var &); +- FactoryDef_out &operator= (FactoryDef_ptr); +- operator FactoryDef_ptr &(); +- FactoryDef_ptr &ptr (void); +- FactoryDef_ptr operator-> (void); +- +-private: +- FactoryDef_ptr &ptr_; ++ void operator= (const IR_PrimaryKeyDescription_var &); + }; + +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FACTORYDEF_CH_) +-#define _TAO_IR_FACTORYDEF_CH_ +- + // Forward Classes Declaration + class _TAO_FactoryDef_Proxy_Impl; + class _TAO_FactoryDef_Remote_Proxy_Impl; + class _TAO_FactoryDef_Proxy_Broker; + class _TAO_FactoryDef_Remote_Proxy_Broker; + +-class TAO_Export FactoryDef: public virtual OperationDef ++class TAO_Export IR_FactoryDef: public virtual IR_OperationDef + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef FactoryDef_ptr _ptr_type; +- typedef FactoryDef_var _var_type; ++ typedef IR_FactoryDef_ptr _ptr_type; ++ typedef IR_FactoryDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static FactoryDef_ptr _duplicate (FactoryDef_ptr obj); +- static FactoryDef_ptr _narrow ( ++ static IR_FactoryDef_ptr _duplicate (IR_FactoryDef_ptr obj); ++ static IR_FactoryDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static FactoryDef_ptr _unchecked_narrow ( ++ static IR_FactoryDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static FactoryDef_ptr _nil (void) ++ static IR_FactoryDef_ptr _nil (void) + { +- return (FactoryDef_ptr)0; ++ return (IR_FactoryDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -27826,60 +16747,53 @@ + _TAO_FactoryDef_Proxy_Broker *the_TAO_FactoryDef_Proxy_Broker_; + + protected: +- FactoryDef (int collocated = 0); ++ IR_FactoryDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- FactoryDef ( ++ IR_FactoryDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); ++ ); + +- friend class _TAO_FactoryDef_Remote_Proxy_Impl; +- friend class _TAO_FactoryDef_ThruPOA_Proxy_Impl; +- friend class _TAO_FactoryDef_Direct_Proxy_Impl; ++ friend class _TAO_FactoryDef_Remote_Proxy_Impl; ++ friend class _TAO_FactoryDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_FactoryDef_Direct_Proxy_Impl; + +- virtual ~FactoryDef (void); +- private: +- FactoryDef (const FactoryDef &); +- void operator= (const FactoryDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- #endif /* TAO_HAS_INTERCEPTORS */ +- +- }; ++ virtual ~IR_FactoryDef (void); ++private: ++ IR_FactoryDef (const IR_FactoryDef &); ++ void operator= (const IR_FactoryDef &); ++}; + + + // The Proxy Implementations are used by each interface to + // perform a call. Each different implementation encapsulate + // an invocation logics. + +- +- /////////////////////////////////////////////////////////////////////// +- // Base Impl. Declaration +- // + +- class TAO_Export _TAO_FactoryDef_Proxy_Impl : +- public virtual IR::_TAO_OperationDef_Proxy_Impl +- { +- public: +- virtual ~_TAO_FactoryDef_Proxy_Impl (void) { } ++/////////////////////////////////////////////////////////////////////// ++// Base Impl. Declaration ++// ++ ++class TAO_Export _TAO_FactoryDef_Proxy_Impl ++ : public virtual _TAO_OperationDef_Proxy_Impl ++{ ++public: ++ virtual ~_TAO_FactoryDef_Proxy_Impl (void) { } ++ ++protected: ++ _TAO_FactoryDef_Proxy_Impl (void); + +- protected: +- _TAO_FactoryDef_Proxy_Impl (void); ++}; + +- }; +- // +- // Base Proxy Impl. Declaration +- /////////////////////////////////////////////////////////////////////// ++// ++// Base Proxy Impl. Declaration ++/////////////////////////////////////////////////////////////////////// + + + /////////////////////////////////////////////////////////////////////// +@@ -27889,7 +16803,7 @@ + class TAO_Export _TAO_FactoryDef_Remote_Proxy_Impl : + public virtual _TAO_FactoryDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_OperationDef_Remote_Proxy_Impl ++ public virtual _TAO_OperationDef_Remote_Proxy_Impl + + { + public: +@@ -27897,7 +16811,7 @@ + + virtual ~_TAO_FactoryDef_Remote_Proxy_Impl (void) { } + +- }; ++}; + + // + // Base Proxy Impl. Declaration +@@ -27919,8 +16833,9 @@ + { + public: + virtual ~_TAO_FactoryDef_Proxy_Broker (void); ++ + virtual _TAO_FactoryDef_Proxy_Impl &select_proxy ( +- FactoryDef *object, ++ IR_FactoryDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -27945,9 +16860,9 @@ + _TAO_FactoryDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_FactoryDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_FactoryDef_Proxy_Impl &select_proxy ( +- FactoryDef *object, ++ IR_FactoryDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -27961,117 +16876,39 @@ + static _TAO_FactoryDef_Remote_Proxy_Broker *the_TAO_FactoryDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FactoryDef; +- +- +-#if !defined (_TAO_IR_FINDERDEF___PTR_CH_) +-#define _TAO_IR_FINDERDEF___PTR_CH_ +- +-class FinderDef; +-typedef FinderDef *FinderDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FINDERDEF___VAR_CH_) +-#define _TAO_IR_FINDERDEF___VAR_CH_ +- +-class TAO_Export FinderDef_var : public TAO_Base_var +-{ +-public: +- FinderDef_var (void); // default constructor +- FinderDef_var (FinderDef_ptr p) : ptr_ (p) {} +- FinderDef_var (const FinderDef_var &); // copy constructor +- ~FinderDef_var (void); // destructor +- +- FinderDef_var &operator= (FinderDef_ptr); +- FinderDef_var &operator= (const FinderDef_var &); +- FinderDef_ptr operator-> (void) const; +- +- operator const FinderDef_ptr &() const; +- operator FinderDef_ptr &(); +- // in, inout, out, _retn +- FinderDef_ptr in (void) const; +- FinderDef_ptr &inout (void); +- FinderDef_ptr &out (void); +- FinderDef_ptr _retn (void); +- FinderDef_ptr ptr (void) const; +- +-private: +- FinderDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- FinderDef_var (const TAO_Base_var &rhs); +- FinderDef_var &operator= (const TAO_Base_var &rhs); +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FINDERDEF___OUT_CH_) +-#define _TAO_IR_FINDERDEF___OUT_CH_ +- +-class TAO_Export FinderDef_out +-{ +-public: +- FinderDef_out (FinderDef_ptr &); +- FinderDef_out (FinderDef_var &); +- FinderDef_out (const FinderDef_out &); +- FinderDef_out &operator= (const FinderDef_out &); +- FinderDef_out &operator= (const FinderDef_var &); +- FinderDef_out &operator= (FinderDef_ptr); +- operator FinderDef_ptr &(); +- FinderDef_ptr &ptr (void); +- FinderDef_ptr operator-> (void); +- +-private: +- FinderDef_ptr &ptr_; +-}; +- +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_FINDERDEF_CH_) +-#define _TAO_IR_FINDERDEF_CH_ +- + // Forward Classes Declaration + class _TAO_FinderDef_Proxy_Impl; + class _TAO_FinderDef_Remote_Proxy_Impl; + class _TAO_FinderDef_Proxy_Broker; + class _TAO_FinderDef_Remote_Proxy_Broker; + +-class TAO_Export FinderDef: public virtual OperationDef ++class TAO_Export IR_FinderDef: public virtual IR_OperationDef + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef FinderDef_ptr _ptr_type; +- typedef FinderDef_var _var_type; ++ typedef IR_FinderDef_ptr _ptr_type; ++ typedef IR_FinderDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static FinderDef_ptr _duplicate (FinderDef_ptr obj); +- static FinderDef_ptr _narrow ( ++ static IR_FinderDef_ptr _duplicate (IR_FinderDef_ptr obj); ++ static IR_FinderDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static FinderDef_ptr _unchecked_narrow ( ++ static IR_FinderDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static FinderDef_ptr _nil (void) ++ static IR_FinderDef_ptr _nil (void) + { +- return (FinderDef_ptr)0; ++ return (IR_FinderDef_ptr)0; + } + + static void _tao_any_destructor (void*); +@@ -28089,60 +16926,53 @@ + _TAO_FinderDef_Proxy_Broker *the_TAO_FinderDef_Proxy_Broker_; + + protected: +- FinderDef (int collocated = 0); ++ IR_FinderDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); +- +- FinderDef ( ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); ++ ++ IR_FinderDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); ++ ); + +- friend class _TAO_FinderDef_Remote_Proxy_Impl; +- friend class _TAO_FinderDef_ThruPOA_Proxy_Impl; +- friend class _TAO_FinderDef_Direct_Proxy_Impl; ++ friend class _TAO_FinderDef_Remote_Proxy_Impl; ++ friend class _TAO_FinderDef_ThruPOA_Proxy_Impl; ++ friend class _TAO_FinderDef_Direct_Proxy_Impl; + +- virtual ~FinderDef (void); +- private: +- FinderDef (const FinderDef &); +- void operator= (const FinderDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- #endif /* TAO_HAS_INTERCEPTORS */ +- +- }; ++ virtual ~IR_FinderDef (void); ++private: ++ IR_FinderDef (const IR_FinderDef &); ++ void operator= (const IR_FinderDef &); ++}; + + + // The Proxy Implementations are used by each interface to + // perform a call. Each different implementation encapsulate + // an invocation logics. + +- +- /////////////////////////////////////////////////////////////////////// +- // Base Impl. Declaration +- // + +- class TAO_Export _TAO_FinderDef_Proxy_Impl : +- public virtual IR::_TAO_OperationDef_Proxy_Impl +- { +- public: +- virtual ~_TAO_FinderDef_Proxy_Impl (void) { } ++/////////////////////////////////////////////////////////////////////// ++// Base Impl. Declaration ++// ++ ++class TAO_Export _TAO_FinderDef_Proxy_Impl ++ : public virtual _TAO_OperationDef_Proxy_Impl ++{ ++public: ++ virtual ~_TAO_FinderDef_Proxy_Impl (void) { } ++ ++protected: ++ _TAO_FinderDef_Proxy_Impl (void); + +- protected: +- _TAO_FinderDef_Proxy_Impl (void); ++}; + +- }; +- // +- // Base Proxy Impl. Declaration +- /////////////////////////////////////////////////////////////////////// ++// ++// Base Proxy Impl. Declaration ++/////////////////////////////////////////////////////////////////////// + + + /////////////////////////////////////////////////////////////////////// +@@ -28152,7 +16982,7 @@ + class TAO_Export _TAO_FinderDef_Remote_Proxy_Impl : + public virtual _TAO_FinderDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_OperationDef_Remote_Proxy_Impl ++ public virtual _TAO_OperationDef_Remote_Proxy_Impl + + { + public: +@@ -28160,7 +16990,7 @@ + + virtual ~_TAO_FinderDef_Remote_Proxy_Impl (void) { } + +- }; ++}; + + // + // Base Proxy Impl. Declaration +@@ -28182,129 +17012,52 @@ + { + public: + virtual ~_TAO_FinderDef_Proxy_Broker (void); ++ + virtual _TAO_FinderDef_Proxy_Impl &select_proxy ( +- FinderDef *object, ++ IR_FinderDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + + protected: +- _TAO_FinderDef_Proxy_Broker (void); +- +-}; +- +- +-// +-// End Base Proxy Broker Declaration +-/////////////////////////////////////////////////////////////////////// +- +- +-/////////////////////////////////////////////////////////////////////// +-// Remote Proxy Broker Declaration +-// +- +-class TAO_Export _TAO_FinderDef_Remote_Proxy_Broker : public virtual _TAO_FinderDef_Proxy_Broker +-{ +-public: +- _TAO_FinderDef_Remote_Proxy_Broker (void); +- +- virtual ~_TAO_FinderDef_Remote_Proxy_Broker (void); +- +- virtual _TAO_FinderDef_Proxy_Impl &select_proxy ( +- FinderDef *object, +- CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () +- ); +- +-private: +- _TAO_FinderDef_Remote_Proxy_Impl remote_proxy_impl_; +-// This member function is used to get an handle to the unique instance +-// of the Remote Proxy Broker that is available for a given +-// interface. +- +-public: +- static _TAO_FinderDef_Remote_Proxy_Broker *the_TAO_FinderDef_Remote_Proxy_Broker (void); +-}; +- +- +-// +-// End Remote Proxy Broker Declaration +-/////////////////////////////////////////////////////////////////////// +- +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FinderDef; +- +- +-#if !defined (_TAO_IR_HOMEDEF___PTR_CH_) +-#define _TAO_IR_HOMEDEF___PTR_CH_ +- +-class HomeDef; +-typedef HomeDef *HomeDef_ptr; +- +-#endif /* end #if !defined */ +- +- +-#if !defined (_TAO_IR_HOMEDEF___VAR_CH_) +-#define _TAO_IR_HOMEDEF___VAR_CH_ +- +-class TAO_Export HomeDef_var : public TAO_Base_var +-{ +-public: +- HomeDef_var (void); // default constructor +- HomeDef_var (HomeDef_ptr p) : ptr_ (p) {} +- HomeDef_var (const HomeDef_var &); // copy constructor +- ~HomeDef_var (void); // destructor +- +- HomeDef_var &operator= (HomeDef_ptr); +- HomeDef_var &operator= (const HomeDef_var &); +- HomeDef_ptr operator-> (void) const; +- +- operator const HomeDef_ptr &() const; +- operator HomeDef_ptr &(); +- // in, inout, out, _retn +- HomeDef_ptr in (void) const; +- HomeDef_ptr &inout (void); +- HomeDef_ptr &out (void); +- HomeDef_ptr _retn (void); +- HomeDef_ptr ptr (void) const; +- +-private: +- HomeDef_ptr ptr_; +- // Unimplemented - prevents widening assignment. +- HomeDef_var (const TAO_Base_var &rhs); +- HomeDef_var &operator= (const TAO_Base_var &rhs); ++ _TAO_FinderDef_Proxy_Broker (void); ++ + }; + + +-#endif /* end #if !defined */ ++// ++// End Base Proxy Broker Declaration ++/////////////////////////////////////////////////////////////////////// + + +-#if !defined (_TAO_IR_HOMEDEF___OUT_CH_) +-#define _TAO_IR_HOMEDEF___OUT_CH_ ++/////////////////////////////////////////////////////////////////////// ++// Remote Proxy Broker Declaration ++// + +-class TAO_Export HomeDef_out ++class TAO_Export _TAO_FinderDef_Remote_Proxy_Broker : public virtual _TAO_FinderDef_Proxy_Broker + { +-public: +- HomeDef_out (HomeDef_ptr &); +- HomeDef_out (HomeDef_var &); +- HomeDef_out (const HomeDef_out &); +- HomeDef_out &operator= (const HomeDef_out &); +- HomeDef_out &operator= (const HomeDef_var &); +- HomeDef_out &operator= (HomeDef_ptr); +- operator HomeDef_ptr &(); +- HomeDef_ptr &ptr (void); +- HomeDef_ptr operator-> (void); ++public: ++ _TAO_FinderDef_Remote_Proxy_Broker (void); + +-private: +- HomeDef_ptr &ptr_; +-}; ++ virtual ~_TAO_FinderDef_Remote_Proxy_Broker (void); + ++ virtual _TAO_FinderDef_Proxy_Impl &select_proxy ( ++ IR_FinderDef *object, ++ CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () ++ ); + +-#endif /* end #if !defined */ ++private: ++ _TAO_FinderDef_Remote_Proxy_Impl remote_proxy_impl_; ++// This member function is used to get an handle to the unique instance ++// of the Remote Proxy Broker that is available for a given ++// interface. + ++public: ++ static _TAO_FinderDef_Remote_Proxy_Broker *the_TAO_FinderDef_Remote_Proxy_Broker (void); ++}; + +-#if !defined (_TAO_IR_HOMEDEF_CH_) +-#define _TAO_IR_HOMEDEF_CH_ ++// ++// End Remote Proxy Broker Declaration ++/////////////////////////////////////////////////////////////////////// + + // Forward Classes Declaration + class _TAO_HomeDef_Proxy_Impl; +@@ -28312,42 +17065,42 @@ + class _TAO_HomeDef_Proxy_Broker; + class _TAO_HomeDef_Remote_Proxy_Broker; + +-class TAO_Export HomeDef: public virtual InterfaceDef ++class TAO_Export IR_HomeDef: public virtual IR_InterfaceDef + { + public: + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef HomeDef_ptr _ptr_type; +- typedef HomeDef_var _var_type; ++ typedef IR_HomeDef_ptr _ptr_type; ++ typedef IR_HomeDef_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + // the static operations +- static HomeDef_ptr _duplicate (HomeDef_ptr obj); +- static HomeDef_ptr _narrow ( ++ static IR_HomeDef_ptr _duplicate (IR_HomeDef_ptr obj); ++ static IR_HomeDef_ptr _narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static HomeDef_ptr _unchecked_narrow ( ++ static IR_HomeDef_ptr _unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); +- static HomeDef_ptr _nil (void) ++ static IR_HomeDef_ptr _nil (void) + { +- return (HomeDef_ptr)0; ++ return (IR_HomeDef_ptr)0; + } + + static void _tao_any_destructor (void*); + +- virtual IR::HomeDef_ptr base_home ( +- CORBA::Environment &ACE_TRY_ENV = ++ virtual IR_HomeDef_ptr base_home ( ++ CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::ComponentDef_ptr managed_component ( ++ virtual IR_ComponentDef_ptr managed_component ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -28355,7 +17108,7 @@ + CORBA::SystemException + )); + +- virtual IR::PrimaryKeyDef_ptr primary_key ( ++ virtual IR_PrimaryKeyDef_ptr primary_key ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -28363,7 +17116,7 @@ + CORBA::SystemException + )); + +- virtual IR::FactoryDefSeq * factories ( ++ virtual IR_FactoryDefSeq * factories ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -28371,7 +17124,7 @@ + CORBA::SystemException + )); + +- virtual IR::FinderDefSeq * finders ( ++ virtual IR_FinderDefSeq * finders ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -28387,11 +17140,11 @@ + CORBA::SystemException + )); + +- virtual IR::PrimaryKeyDef_ptr create_primary_key ( ++ virtual IR_PrimaryKeyDef_ptr create_primary_key ( + const char * id, + const char * name, + const char * version, +- IR::ValueDef_ptr primary_key, ++ IR_ValueDef_ptr primary_key, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -28399,12 +17152,12 @@ + CORBA::SystemException + )); + +- virtual IR::FactoryDef_ptr create_factory ( ++ virtual IR_FactoryDef_ptr create_factory ( + const char * id, + const char * name, + const char * version, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, ++ const IR_ParDescriptionSeq & params, ++ const IR_ExceptionDefSeq & exceptions, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -28412,12 +17165,12 @@ + CORBA::SystemException + )); + +- virtual IR::FinderDef_ptr create_finder ( ++ virtual IR_FinderDef_ptr create_finder ( + const char * id, + const char * name, + const char * version, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, ++ const IR_ParDescriptionSeq & params, ++ const IR_ExceptionDefSeq & exceptions, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) +@@ -28438,450 +17191,27 @@ + _TAO_HomeDef_Proxy_Broker *the_TAO_HomeDef_Proxy_Broker_; + + protected: +- HomeDef (int collocated = 0); ++ IR_HomeDef (int collocated = 0); + +- protected: +- // This methods travese the inheritance tree and set the +- // parents piece of the given class in the right mode +- virtual void _tao_setup_collocation (int collocated); ++protected: ++ // This methods travese the inheritance tree and set the ++ // parents piece of the given class in the right mode ++ virtual void _tao_setup_collocation (int collocated); + +- HomeDef ( ++ IR_HomeDef ( + TAO_Stub *objref, + CORBA::Boolean _tao_collocated = 0, + TAO_Abstract_ServantBase *servant = 0 +- ); +- +- friend class _TAO_HomeDef_Remote_Proxy_Impl; +- friend class _TAO_HomeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_HomeDef_Direct_Proxy_Impl; +- +- virtual ~HomeDef (void); +- private: +- HomeDef (const HomeDef &); +- void operator= (const HomeDef &); +- +-#if (TAO_HAS_INTERCEPTORS == 1) +- // Generation of interceptors related RequestInfo classes per operation. +- // This needed to be able to store the arguments, exceptions, contexts +- // and build the lists dynamically on demand so that unnecessary time overhead +- // of building these lists when they arent used is avoided. +- class TAO_ClientRequestInfo_IR_HomeDef_base_home_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::HomeDef; +- +- friend class _TAO_HomeDef_Remote_Proxy_Impl; +- friend class _TAO_HomeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_HomeDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_HomeDef_base_home_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- private: +- TAO_ClientRequestInfo_IR_HomeDef_base_home_get (const TAO_ClientRequestInfo_IR_HomeDef_base_home_get &); +- void operator= (const TAO_ClientRequestInfo_IR_HomeDef_base_home_get &); +- void result (IR::HomeDef_ptr result); +- // update the result +- IR::HomeDef_ptr result_; +- }; +- +- class TAO_ClientRequestInfo_IR_HomeDef_managed_component_get : public TAO_ClientRequestInfo +- { +- public: +- friend class IR::HomeDef; +- +- friend class _TAO_HomeDef_Remote_Proxy_Impl; +- friend class _TAO_HomeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_HomeDef_Direct_Proxy_Impl; +- +- TAO_ClientRequestInfo_IR_HomeDef_managed_component_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () + ); +- +- virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +- virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_HomeDef_managed_component_get (const TAO_ClientRequestInfo_IR_HomeDef_managed_component_get &); +- void operator= (const TAO_ClientRequestInfo_IR_HomeDef_managed_component_get &); +- void result (IR::ComponentDef_ptr result); +- // update the result +- IR::ComponentDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_HomeDef_primary_key_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::HomeDef; +- +- friend class _TAO_HomeDef_Remote_Proxy_Impl; +- friend class _TAO_HomeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_HomeDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_HomeDef_primary_key_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_HomeDef_primary_key_get (const TAO_ClientRequestInfo_IR_HomeDef_primary_key_get &); +- void operator= (const TAO_ClientRequestInfo_IR_HomeDef_primary_key_get &); +- void result (IR::PrimaryKeyDef_ptr result); +- // update the result +- IR::PrimaryKeyDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_HomeDef_factories_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::HomeDef; +- +- friend class _TAO_HomeDef_Remote_Proxy_Impl; +- friend class _TAO_HomeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_HomeDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_HomeDef_factories_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_HomeDef_factories_get (const TAO_ClientRequestInfo_IR_HomeDef_factories_get &); +- void operator= (const TAO_ClientRequestInfo_IR_HomeDef_factories_get &); +- void result (IR::FactoryDefSeq * result); +- // update the result +- IR::FactoryDefSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_HomeDef_finders_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::HomeDef; +- ++ + friend class _TAO_HomeDef_Remote_Proxy_Impl; + friend class _TAO_HomeDef_ThruPOA_Proxy_Impl; + friend class _TAO_HomeDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_HomeDef_finders_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_HomeDef_finders_get (const TAO_ClientRequestInfo_IR_HomeDef_finders_get &); +- void operator= (const TAO_ClientRequestInfo_IR_HomeDef_finders_get &); +- void result (IR::FinderDefSeq * result); +- // update the result +- IR::FinderDefSeq * result_; +-}; +- +-class TAO_ClientRequestInfo_IR_HomeDef_is_basic_get : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::HomeDef; + +- friend class _TAO_HomeDef_Remote_Proxy_Impl; +- friend class _TAO_HomeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_HomeDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_HomeDef_is_basic_get ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- ++ virtual ~IR_HomeDef (void); + private: +- TAO_ClientRequestInfo_IR_HomeDef_is_basic_get (const TAO_ClientRequestInfo_IR_HomeDef_is_basic_get &); +- void operator= (const TAO_ClientRequestInfo_IR_HomeDef_is_basic_get &); +- void result (CORBA::Boolean result); +- // update the result +- CORBA::Boolean result_; +-}; +- +-class TAO_ClientRequestInfo_IR_HomeDef_create_primary_key : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::HomeDef; +- +- friend class _TAO_HomeDef_Remote_Proxy_Impl; +- friend class _TAO_HomeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_HomeDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_HomeDef_create_primary_key ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- IR::ValueDef_ptr primary_key, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_HomeDef_create_primary_key (const TAO_ClientRequestInfo_IR_HomeDef_create_primary_key &); +- void operator= (const TAO_ClientRequestInfo_IR_HomeDef_create_primary_key &); +- const char * id_; +- const char * name_; +- const char * version_; +- IR::ValueDef_ptr primary_key_; +- void result (IR::PrimaryKeyDef_ptr result); +- // update the result +- IR::PrimaryKeyDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_HomeDef_create_factory : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::HomeDef; +- +- friend class _TAO_HomeDef_Remote_Proxy_Impl; +- friend class _TAO_HomeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_HomeDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_HomeDef_create_factory ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_HomeDef_create_factory (const TAO_ClientRequestInfo_IR_HomeDef_create_factory &); +- void operator= (const TAO_ClientRequestInfo_IR_HomeDef_create_factory &); +- const char * id_; +- const char * name_; +- const char * version_; +- const IR::ParDescriptionSeq & params_; +- const IR::ExceptionDefSeq & exceptions_; +- void result (IR::FactoryDef_ptr result); +- // update the result +- IR::FactoryDef_ptr result_; +-}; +- +-class TAO_ClientRequestInfo_IR_HomeDef_create_finder : public TAO_ClientRequestInfo +-{ +-public: +- friend class IR::HomeDef; +- +- friend class _TAO_HomeDef_Remote_Proxy_Impl; +- friend class _TAO_HomeDef_ThruPOA_Proxy_Impl; +- friend class _TAO_HomeDef_Direct_Proxy_Impl; +- +-TAO_ClientRequestInfo_IR_HomeDef_create_finder ( +- const char *_tao_operation, +- IOP::ServiceContextList &_tao_service_context_list, +- CORBA::Object *_tao_target, +- const char * id, +- const char * name, +- const char * version, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ); +- +-virtual Dynamic::ParameterList * arguments ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual Dynamic::ExceptionList * exceptions ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-virtual CORBA::Any * result ( +- CORBA::Environment &ACE_TRY_ENV = +- TAO_default_environment () +- ) +- ACE_THROW_SPEC ((CORBA::SystemException)); +- +-private: +- TAO_ClientRequestInfo_IR_HomeDef_create_finder (const TAO_ClientRequestInfo_IR_HomeDef_create_finder &); +- void operator= (const TAO_ClientRequestInfo_IR_HomeDef_create_finder &); +- const char * id_; +- const char * name_; +- const char * version_; +- const IR::ParDescriptionSeq & params_; +- const IR::ExceptionDefSeq & exceptions_; +- void result (IR::FinderDef_ptr result); +- // update the result +- IR::FinderDef_ptr result_; +-}; +- +-#endif /* TAO_HAS_INTERCEPTORS */ +- ++ IR_HomeDef (const IR_HomeDef &); ++ void operator= (const IR_HomeDef &); + }; + + +@@ -28895,12 +17225,12 @@ + // + + class TAO_Export _TAO_HomeDef_Proxy_Impl : +- public virtual IR::_TAO_InterfaceDef_Proxy_Impl ++ public virtual _TAO_InterfaceDef_Proxy_Impl + { + public: + virtual ~_TAO_HomeDef_Proxy_Impl (void) { } + +- virtual IR::HomeDef_ptr base_home ( ++ virtual IR_HomeDef_ptr base_home ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -28908,7 +17238,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::ComponentDef_ptr managed_component ( ++ virtual IR_ComponentDef_ptr managed_component ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -28916,7 +17246,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::PrimaryKeyDef_ptr primary_key ( ++ virtual IR_PrimaryKeyDef_ptr primary_key ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -28924,7 +17254,7 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::FactoryDefSeq * factories ( ++ virtual IR_FactoryDefSeq * factories ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -28932,54 +17262,54 @@ + CORBA::SystemException + )) = 0; + +- virtual IR::FinderDefSeq * finders ( ++ virtual IR_FinderDefSeq * finders ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual CORBA::Boolean is_basic ( ++ virtual CORBA::Boolean is_basic ( + CORBA_Object *_collocated_tao_target_, +- CORBA::Environment &ACE_TRY_ENV ++ CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::PrimaryKeyDef_ptr create_primary_key ( ++ virtual IR_PrimaryKeyDef_ptr create_primary_key ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::ValueDef_ptr primary_key, ++ IR_ValueDef_ptr primary_key, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::FactoryDef_ptr create_factory ( ++ virtual IR_FactoryDef_ptr create_factory ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, ++ const IR_ParDescriptionSeq & params, ++ const IR_ExceptionDefSeq & exceptions, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) = 0; + +- virtual IR::FinderDef_ptr create_finder ( ++ virtual IR_FinderDef_ptr create_finder ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, ++ const IR_ParDescriptionSeq & params, ++ const IR_ExceptionDefSeq & exceptions, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -28990,6 +17320,7 @@ + _TAO_HomeDef_Proxy_Impl (void); + + }; ++ + // + // Base Proxy Impl. Declaration + /////////////////////////////////////////////////////////////////////// +@@ -29002,7 +17333,7 @@ + class TAO_Export _TAO_HomeDef_Remote_Proxy_Impl : + public virtual _TAO_HomeDef_Proxy_Impl, + public virtual TAO_Remote_Object_Proxy_Impl, +- public virtual IR::_TAO_InterfaceDef_Remote_Proxy_Impl ++ public virtual _TAO_InterfaceDef_Remote_Proxy_Impl + + { + public: +@@ -29010,7 +17341,7 @@ + + virtual ~_TAO_HomeDef_Remote_Proxy_Impl (void) { } + +- virtual IR::HomeDef_ptr base_home ( ++ virtual IR_HomeDef_ptr base_home ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -29018,7 +17349,7 @@ + CORBA::SystemException + )); + +- virtual IR::ComponentDef_ptr managed_component ( ++ virtual IR_ComponentDef_ptr managed_component ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -29026,7 +17357,7 @@ + CORBA::SystemException + )); + +- virtual IR::PrimaryKeyDef_ptr primary_key ( ++ virtual IR_PrimaryKeyDef_ptr primary_key ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -29034,7 +17365,7 @@ + CORBA::SystemException + )); + +- virtual IR::FactoryDefSeq * factories ( ++ virtual IR_FactoryDefSeq * factories ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -29042,7 +17373,7 @@ + CORBA::SystemException + )); + +- virtual IR::FinderDefSeq * finders ( ++ virtual IR_FinderDefSeq * finders ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) +@@ -29058,38 +17389,38 @@ + CORBA::SystemException + )); + +- virtual IR::PrimaryKeyDef_ptr create_primary_key ( ++ virtual IR_PrimaryKeyDef_ptr create_primary_key ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- IR::ValueDef_ptr primary_key, ++ IR_ValueDef_ptr primary_key, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::FactoryDef_ptr create_factory ( ++ virtual IR_FactoryDef_ptr create_factory ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, ++ const IR_ParDescriptionSeq & params, ++ const IR_ExceptionDefSeq & exceptions, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )); + +- virtual IR::FinderDef_ptr create_finder ( ++ virtual IR_FinderDef_ptr create_finder ( + CORBA_Object *_collocated_tao_target_, + const char * id, + const char * name, + const char * version, +- const IR::ParDescriptionSeq & params, +- const IR::ExceptionDefSeq & exceptions, ++ const IR_ParDescriptionSeq & params, ++ const IR_ExceptionDefSeq & exceptions, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( +@@ -29118,8 +17449,9 @@ + { + public: + virtual ~_TAO_HomeDef_Proxy_Broker (void); ++ + virtual _TAO_HomeDef_Proxy_Impl &select_proxy ( +- HomeDef *object, ++ IR_HomeDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ) = 0; + +@@ -29144,9 +17476,9 @@ + _TAO_HomeDef_Remote_Proxy_Broker (void); + + virtual ~_TAO_HomeDef_Remote_Proxy_Broker (void); +- ++ + virtual _TAO_HomeDef_Proxy_Impl &select_proxy ( +- HomeDef *object, ++ IR_HomeDef *object, + CORBA_Environment &ACE_TRY_ENV = TAO_default_environment () + ); + +@@ -29160,24 +17492,15 @@ + static _TAO_HomeDef_Remote_Proxy_Broker *the_TAO_HomeDef_Remote_Proxy_Broker (void); + }; + +- + // + // End Remote Proxy Broker Declaration + /////////////////////////////////////////////////////////////////////// + +- +-#endif /* end #if !defined */ +- +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HomeDef; +- +-struct HomeDescription; +-class HomeDescription_var; +- +-struct TAO_Export HomeDescription ++struct TAO_Export IR_HomeDescription + { + + #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) +- typedef HomeDescription_var _var_type; ++ typedef IR_HomeDescription_var _var_type; + #endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); +@@ -29188,1033 +17511,875 @@ + TAO_String_Manager version; + TAO_String_Manager base_home; + TAO_String_Manager managed_component; +- ACE_NESTED_CLASS (IR, PrimaryKeyDef_var) primary_key_def; +- ACE_NESTED_CLASS (IR, FactoryDefSeq) factories; +- ACE_NESTED_CLASS (IR, FinderDefSeq) finders; +- ACE_NESTED_CLASS (IR, OpDescriptionSeq) operations; +- ACE_NESTED_CLASS (IR, AttrDescriptionSeq) attributes; ++ IR_PrimaryKeyDef_var primary_key_def; ++ IR_FactoryDefSeq factories; ++ IR_FinderDefSeq finders; ++ IR_OpDescriptionSeq operations; ++ IR_AttrDescriptionSeq attributes; + CORBA::Boolean is_basic; + }; + +-class TAO_Export HomeDescription_var ++class TAO_Export IR_HomeDescription_var + { + public: +- HomeDescription_var (void); // default constructor +- HomeDescription_var (HomeDescription *); +- HomeDescription_var (const HomeDescription_var &); // copy constructor +- ~HomeDescription_var (void); // destructor +- +- HomeDescription_var &operator= (HomeDescription *); +- HomeDescription_var &operator= (const HomeDescription_var &); +- HomeDescription *operator-> (void); +- const HomeDescription *operator-> (void) const; +- +- operator const HomeDescription &() const; +- operator HomeDescription &(); +- operator HomeDescription &() const; +- operator HomeDescription *&(); // variable-size types only ++ IR_HomeDescription_var (void); // default constructor ++ IR_HomeDescription_var (IR_HomeDescription *); ++ IR_HomeDescription_var (const IR_HomeDescription_var &); // copy constructor ++ ~IR_HomeDescription_var (void); // destructor ++ ++ IR_HomeDescription_var &operator= (IR_HomeDescription *); ++ IR_HomeDescription_var &operator= (const IR_HomeDescription_var &); ++ IR_HomeDescription *operator-> (void); ++ const IR_HomeDescription *operator-> (void) const; ++ ++ operator const IR_HomeDescription &() const; ++ operator IR_HomeDescription &(); ++ operator IR_HomeDescription &() const; ++ operator IR_HomeDescription *&(); // variable-size types only + + // in, inout, out, _retn +- const HomeDescription &in (void) const; +- HomeDescription &inout (void); +- HomeDescription *&out (void); +- HomeDescription *_retn (void); +- HomeDescription *ptr (void) const; ++ const IR_HomeDescription &in (void) const; ++ IR_HomeDescription &inout (void); ++ IR_HomeDescription *&out (void); ++ IR_HomeDescription *_retn (void); ++ IR_HomeDescription *ptr (void) const; + + private: +- HomeDescription *ptr_; ++ IR_HomeDescription *ptr_; + }; + +-class TAO_Export HomeDescription_out ++class TAO_Export IR_HomeDescription_out + { + public: +- HomeDescription_out (HomeDescription *&); +- HomeDescription_out (HomeDescription_var &); +- HomeDescription_out (const HomeDescription_out &); +- HomeDescription_out &operator= (const HomeDescription_out &); +- HomeDescription_out &operator= (HomeDescription *); +- operator HomeDescription *&(); +- HomeDescription *&ptr (void); +- HomeDescription *operator-> (void); ++ IR_HomeDescription_out (IR_HomeDescription *&); ++ IR_HomeDescription_out (IR_HomeDescription_var &); ++ IR_HomeDescription_out (const IR_HomeDescription_out &); ++ IR_HomeDescription_out &operator= (const IR_HomeDescription_out &); ++ IR_HomeDescription_out &operator= (IR_HomeDescription *); ++ operator IR_HomeDescription *&(); ++ IR_HomeDescription *&ptr (void); ++ IR_HomeDescription *operator-> (void); + + private: +- HomeDescription *&ptr_; ++ IR_HomeDescription *&ptr_; + // assignment from T_var not allowed +- void operator= (const HomeDescription_var &); ++ void operator= (const IR_HomeDescription_var &); + }; + +-TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HomeDescription; +- +- +-} +-TAO_NAMESPACE_CLOSE // module IR +- +-TAO_Export void operator<<= (CORBA::Any &, IR::DefinitionKind); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::DefinitionKind &); +-extern TAO_Export CORBA::_TAO_IRObject_Proxy_Broker * (*CORBA__TAO_IRObject_Proxy_Broker_Factory_function_pointer) ( ++TAO_Export void operator<<= (CORBA::Any &, IR_DefinitionKind); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_DefinitionKind &); ++extern TAO_Export _TAO_IRObject_Proxy_Broker * (*_TAO_IRObject_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface CORBA::IRObject +-TAO_Export void operator<<= (CORBA::Any &, CORBA::IRObject_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::IRObject *&); +-extern TAO_Export IR::_TAO_Contained_Proxy_Broker * (*IR__TAO_Contained_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface CORBA_IRObject ++TAO_Export void operator<<= (CORBA::Any &, CORBA_IRObject_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_IRObject *&); ++extern TAO_Export _TAO_Contained_Proxy_Broker * (*_TAO_Contained_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::Contained +-TAO_Export void operator<<= (CORBA::Any &, IR::Contained_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Contained *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::Contained::Description &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::Contained::Description*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Contained::Description *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::Contained::Description *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::InterfaceDefSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::InterfaceDefSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::InterfaceDefSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::InterfaceDefSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ValueDefSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ValueDefSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueDefSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ValueDefSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ComponentDefSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ComponentDefSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ComponentDefSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ComponentDefSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ProvidesDefSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ProvidesDefSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ProvidesDefSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ProvidesDefSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::UsesDefSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::UsesDefSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UsesDefSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UsesDefSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::HomeDefSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::HomeDefSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::HomeDefSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::HomeDefSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::EmitsDefSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::EmitsDefSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EmitsDefSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::EmitsDefSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::PublishesDefSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::PublishesDefSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PublishesDefSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::PublishesDefSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ConsumesDefSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ConsumesDefSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ConsumesDefSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ConsumesDefSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::FactoryDefSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::FactoryDefSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FactoryDefSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::FactoryDefSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::FinderDefSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::FinderDefSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FinderDefSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::FinderDefSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ContainedSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ContainedSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ContainedSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ContainedSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::StructMember &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::StructMember*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::StructMember *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::StructMember *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::StructMemberSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::StructMemberSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::StructMemberSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::StructMemberSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::Initializer &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::Initializer*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Initializer *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::Initializer *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::InitializerSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::InitializerSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::InitializerSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::InitializerSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::UnionMember &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::UnionMember*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UnionMember *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UnionMember *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::UnionMemberSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::UnionMemberSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UnionMemberSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UnionMemberSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::EnumMemberSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::EnumMemberSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EnumMemberSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::EnumMemberSeq *&); +-extern TAO_Export IR::_TAO_Container_Proxy_Broker * (*IR__TAO_Container_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_Contained ++TAO_Export void operator<<= (CORBA::Any &, IR_Contained_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Contained *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_Contained::Description &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_Contained::Description*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Contained::Description *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_Contained::Description *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_InterfaceDefSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_InterfaceDefSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_InterfaceDefSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_InterfaceDefSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ValueDefSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ValueDefSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueDefSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ValueDefSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ComponentDefSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ComponentDefSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ComponentDefSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ComponentDefSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ProvidesDefSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ProvidesDefSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ProvidesDefSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ProvidesDefSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_UsesDefSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_UsesDefSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UsesDefSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_UsesDefSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_HomeDefSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_HomeDefSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_HomeDefSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_HomeDefSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_EmitsDefSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_EmitsDefSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_EmitsDefSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_EmitsDefSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_PublishesDefSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_PublishesDefSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_PublishesDefSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_PublishesDefSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ConsumesDefSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ConsumesDefSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ConsumesDefSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ConsumesDefSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_FactoryDefSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_FactoryDefSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_FactoryDefSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_FactoryDefSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_FinderDefSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_FinderDefSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_FinderDefSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_FinderDefSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ContainedSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ContainedSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ContainedSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ContainedSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_StructMember &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_StructMember*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_StructMember *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_StructMember *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_StructMemberSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_StructMemberSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_StructMemberSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_StructMemberSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_Initializer &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_Initializer*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Initializer *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_Initializer *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_InitializerSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_InitializerSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_InitializerSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_InitializerSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_UnionMember &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_UnionMember*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UnionMember *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_UnionMember *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_UnionMemberSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_UnionMemberSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UnionMemberSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_UnionMemberSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_EnumMemberSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_EnumMemberSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_EnumMemberSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_EnumMemberSeq *&); ++extern TAO_Export _TAO_Container_Proxy_Broker * (*_TAO_Container_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::Container +-TAO_Export void operator<<= (CORBA::Any &, IR::Container_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Container *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::Container::Description &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::Container::Description*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Container::Description *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::Container::Description *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::Container::DescriptionSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::Container::DescriptionSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Container::DescriptionSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::Container::DescriptionSeq *&); +-extern TAO_Export IR::_TAO_IDLType_Proxy_Broker * (*IR__TAO_IDLType_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_Container ++TAO_Export void operator<<= (CORBA::Any &, IR_Container_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Container *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_Container::Description &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_Container::Description*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Container::Description *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_Container::Description *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_Container::DescriptionSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_Container::DescriptionSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Container::DescriptionSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_Container::DescriptionSeq *&); ++extern TAO_Export _TAO_IDLType_Proxy_Broker * (*_TAO_IDLType_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::IDLType +-TAO_Export void operator<<= (CORBA::Any &, IR::IDLType_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::IDLType *&); +-TAO_Export void operator<<= (CORBA::Any &, IR::PrimitiveKind); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PrimitiveKind &); +-extern TAO_Export IR::_TAO_Repository_Proxy_Broker * (*IR__TAO_Repository_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_IDLType ++TAO_Export void operator<<= (CORBA::Any &, IR_IDLType_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_IDLType *&); ++TAO_Export void operator<<= (CORBA::Any &, IR_PrimitiveKind); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_PrimitiveKind &); ++extern TAO_Export _TAO_Repository_Proxy_Broker * (*_TAO_Repository_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::Repository +-TAO_Export void operator<<= (CORBA::Any &, IR::Repository_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Repository *&); +-extern TAO_Export IR::_TAO_ComponentRepository_Proxy_Broker * (*IR__TAO_ComponentRepository_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_Repository ++TAO_Export void operator<<= (CORBA::Any &, IR_Repository_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_Repository *&); ++extern TAO_Export _TAO_ComponentRepository_Proxy_Broker * (*_TAO_ComponentRepository_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::ComponentRepository +-TAO_Export void operator<<= (CORBA::Any &, IR::ComponentRepository_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ComponentRepository *&); +-extern TAO_Export IR::_TAO_ModuleDef_Proxy_Broker * (*IR__TAO_ModuleDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_ComponentRepository ++TAO_Export void operator<<= (CORBA::Any &, IR_ComponentRepository_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ComponentRepository *&); ++extern TAO_Export _TAO_ModuleDef_Proxy_Broker * (*_TAO_ModuleDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::ModuleDef +-TAO_Export void operator<<= (CORBA::Any &, IR::ModuleDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ModuleDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ModuleDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ModuleDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ModuleDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ModuleDescription *&); +-extern TAO_Export IR::_TAO_ConstantDef_Proxy_Broker * (*IR__TAO_ConstantDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_ModuleDef ++TAO_Export void operator<<= (CORBA::Any &, IR_ModuleDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ModuleDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ModuleDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ModuleDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ModuleDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ModuleDescription *&); ++extern TAO_Export _TAO_ConstantDef_Proxy_Broker * (*_TAO_ConstantDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::ConstantDef +-TAO_Export void operator<<= (CORBA::Any &, IR::ConstantDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ConstantDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ConstantDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ConstantDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ConstantDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ConstantDescription *&); +-extern TAO_Export IR::_TAO_TypedefDef_Proxy_Broker * (*IR__TAO_TypedefDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_ConstantDef ++TAO_Export void operator<<= (CORBA::Any &, IR_ConstantDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ConstantDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ConstantDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ConstantDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ConstantDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ConstantDescription *&); ++extern TAO_Export _TAO_TypedefDef_Proxy_Broker * (*_TAO_TypedefDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::TypedefDef +-TAO_Export void operator<<= (CORBA::Any &, IR::TypedefDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::TypedefDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::TypeDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::TypeDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::TypeDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::TypeDescription *&); +-extern TAO_Export IR::_TAO_StructDef_Proxy_Broker * (*IR__TAO_StructDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_TypedefDef ++TAO_Export void operator<<= (CORBA::Any &, IR_TypedefDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_TypedefDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_TypeDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_TypeDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_TypeDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_TypeDescription *&); ++extern TAO_Export _TAO_StructDef_Proxy_Broker * (*_TAO_StructDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::StructDef +-TAO_Export void operator<<= (CORBA::Any &, IR::StructDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::StructDef *&); +-extern TAO_Export IR::_TAO_UnionDef_Proxy_Broker * (*IR__TAO_UnionDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_StructDef ++TAO_Export void operator<<= (CORBA::Any &, IR_StructDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_StructDef *&); ++extern TAO_Export _TAO_UnionDef_Proxy_Broker * (*_TAO_UnionDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::UnionDef +-TAO_Export void operator<<= (CORBA::Any &, IR::UnionDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UnionDef *&); +-extern TAO_Export IR::_TAO_EnumDef_Proxy_Broker * (*IR__TAO_EnumDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_UnionDef ++TAO_Export void operator<<= (CORBA::Any &, IR_UnionDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UnionDef *&); ++extern TAO_Export _TAO_EnumDef_Proxy_Broker * (*_TAO_EnumDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::EnumDef +-TAO_Export void operator<<= (CORBA::Any &, IR::EnumDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EnumDef *&); +-extern TAO_Export IR::_TAO_AliasDef_Proxy_Broker * (*IR__TAO_AliasDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_EnumDef ++TAO_Export void operator<<= (CORBA::Any &, IR_EnumDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_EnumDef *&); ++extern TAO_Export _TAO_AliasDef_Proxy_Broker * (*_TAO_AliasDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::AliasDef +-TAO_Export void operator<<= (CORBA::Any &, IR::AliasDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::AliasDef *&); +-extern TAO_Export IR::_TAO_NativeDef_Proxy_Broker * (*IR__TAO_NativeDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_AliasDef ++TAO_Export void operator<<= (CORBA::Any &, IR_AliasDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_AliasDef *&); ++extern TAO_Export _TAO_NativeDef_Proxy_Broker * (*_TAO_NativeDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::NativeDef +-TAO_Export void operator<<= (CORBA::Any &, IR::NativeDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::NativeDef *&); +-extern TAO_Export IR::_TAO_PrimitiveDef_Proxy_Broker * (*IR__TAO_PrimitiveDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_NativeDef ++TAO_Export void operator<<= (CORBA::Any &, IR_NativeDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_NativeDef *&); ++extern TAO_Export _TAO_PrimitiveDef_Proxy_Broker * (*_TAO_PrimitiveDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::PrimitiveDef +-TAO_Export void operator<<= (CORBA::Any &, IR::PrimitiveDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PrimitiveDef *&); +-extern TAO_Export IR::_TAO_StringDef_Proxy_Broker * (*IR__TAO_StringDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_PrimitiveDef ++TAO_Export void operator<<= (CORBA::Any &, IR_PrimitiveDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_PrimitiveDef *&); ++extern TAO_Export _TAO_StringDef_Proxy_Broker * (*_TAO_StringDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::StringDef +-TAO_Export void operator<<= (CORBA::Any &, IR::StringDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::StringDef *&); +-extern TAO_Export IR::_TAO_WstringDef_Proxy_Broker * (*IR__TAO_WstringDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_StringDef ++TAO_Export void operator<<= (CORBA::Any &, IR_StringDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_StringDef *&); ++extern TAO_Export _TAO_WstringDef_Proxy_Broker * (*_TAO_WstringDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::WstringDef +-TAO_Export void operator<<= (CORBA::Any &, IR::WstringDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::WstringDef *&); +-extern TAO_Export IR::_TAO_FixedDef_Proxy_Broker * (*IR__TAO_FixedDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_WstringDef ++TAO_Export void operator<<= (CORBA::Any &, IR_WstringDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_WstringDef *&); ++extern TAO_Export _TAO_FixedDef_Proxy_Broker * (*_TAO_FixedDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::FixedDef +-TAO_Export void operator<<= (CORBA::Any &, IR::FixedDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FixedDef *&); +-extern TAO_Export IR::_TAO_SequenceDef_Proxy_Broker * (*IR__TAO_SequenceDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_FixedDef ++TAO_Export void operator<<= (CORBA::Any &, IR_FixedDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_FixedDef *&); ++extern TAO_Export _TAO_SequenceDef_Proxy_Broker * (*_TAO_SequenceDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::SequenceDef +-TAO_Export void operator<<= (CORBA::Any &, IR::SequenceDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::SequenceDef *&); +-extern TAO_Export IR::_TAO_ArrayDef_Proxy_Broker * (*IR__TAO_ArrayDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_SequenceDef ++TAO_Export void operator<<= (CORBA::Any &, IR_SequenceDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_SequenceDef *&); ++extern TAO_Export _TAO_ArrayDef_Proxy_Broker * (*_TAO_ArrayDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::ArrayDef +-TAO_Export void operator<<= (CORBA::Any &, IR::ArrayDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ArrayDef *&); +-extern TAO_Export IR::_TAO_ExceptionDef_Proxy_Broker * (*IR__TAO_ExceptionDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_ArrayDef ++TAO_Export void operator<<= (CORBA::Any &, IR_ArrayDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ArrayDef *&); ++extern TAO_Export _TAO_ExceptionDef_Proxy_Broker * (*_TAO_ExceptionDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::ExceptionDef +-TAO_Export void operator<<= (CORBA::Any &, IR::ExceptionDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ExceptionDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ExceptionDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ExceptionDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ExceptionDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ExceptionDescription *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ExceptionDefSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ExceptionDefSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ExceptionDefSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ExceptionDefSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ExcDescriptionSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ExcDescriptionSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ExcDescriptionSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ExcDescriptionSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, IR::AttributeMode); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::AttributeMode &); +-extern TAO_Export IR::_TAO_AttributeDef_Proxy_Broker * (*IR__TAO_AttributeDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_ExceptionDef ++TAO_Export void operator<<= (CORBA::Any &, IR_ExceptionDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ExceptionDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ExceptionDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ExceptionDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ExceptionDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ExceptionDescription *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ExceptionDefSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ExceptionDefSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ExceptionDefSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ExceptionDefSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ExcDescriptionSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ExcDescriptionSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ExcDescriptionSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ExcDescriptionSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, IR_AttributeMode); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_AttributeMode &); ++extern TAO_Export _TAO_AttributeDef_Proxy_Broker * (*_TAO_AttributeDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::AttributeDef +-TAO_Export void operator<<= (CORBA::Any &, IR::AttributeDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::AttributeDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::AttributeDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::AttributeDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::AttributeDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::AttributeDescription *&); +-TAO_Export void operator<<= (CORBA::Any &, IR::OperationMode); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::OperationMode &); +-TAO_Export void operator<<= (CORBA::Any &, IR::ParameterMode); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ParameterMode &); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ParameterDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ParameterDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ParameterDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ParameterDescription *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ParDescriptionSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ParDescriptionSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ParDescriptionSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ParDescriptionSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ContextIdSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ContextIdSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ContextIdSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ContextIdSeq *&); +-extern TAO_Export IR::_TAO_OperationDef_Proxy_Broker * (*IR__TAO_OperationDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_AttributeDef ++TAO_Export void operator<<= (CORBA::Any &, IR_AttributeDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_AttributeDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_AttributeDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_AttributeDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_AttributeDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_AttributeDescription *&); ++TAO_Export void operator<<= (CORBA::Any &, IR_OperationMode); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_OperationMode &); ++TAO_Export void operator<<= (CORBA::Any &, IR_ParameterMode); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ParameterMode &); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ParameterDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ParameterDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ParameterDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ParameterDescription *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ParDescriptionSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ParDescriptionSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ParDescriptionSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ParDescriptionSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ContextIdSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ContextIdSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ContextIdSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ContextIdSeq *&); ++extern TAO_Export _TAO_OperationDef_Proxy_Broker * (*_TAO_OperationDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::OperationDef +-TAO_Export void operator<<= (CORBA::Any &, IR::OperationDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::OperationDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::OperationDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::OperationDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::OperationDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::OperationDescription *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::RepositoryIdSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::RepositoryIdSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::RepositoryIdSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::RepositoryIdSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::OpDescriptionSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::OpDescriptionSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::OpDescriptionSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::OpDescriptionSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::AttrDescriptionSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::AttrDescriptionSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::AttrDescriptionSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::AttrDescriptionSeq *&); +-extern TAO_Export IR::_TAO_InterfaceDef_Proxy_Broker * (*IR__TAO_InterfaceDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_OperationDef ++TAO_Export void operator<<= (CORBA::Any &, IR_OperationDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_OperationDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_OperationDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_OperationDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_OperationDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_OperationDescription *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_RepositoryIdSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_RepositoryIdSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_RepositoryIdSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_RepositoryIdSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_OpDescriptionSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_OpDescriptionSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_OpDescriptionSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_OpDescriptionSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_AttrDescriptionSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_AttrDescriptionSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_AttrDescriptionSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_AttrDescriptionSeq *&); ++extern TAO_Export _TAO_InterfaceDef_Proxy_Broker * (*_TAO_InterfaceDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::InterfaceDef +-TAO_Export void operator<<= (CORBA::Any &, IR::InterfaceDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::InterfaceDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::InterfaceDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::InterfaceDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::InterfaceDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::InterfaceDescription *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ValueMember &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ValueMember*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueMember *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ValueMember *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ValueMemberSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ValueMemberSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueMemberSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ValueMemberSeq *&); +-extern TAO_Export IR::_TAO_ValueMemberDef_Proxy_Broker * (*IR__TAO_ValueMemberDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_InterfaceDef ++TAO_Export void operator<<= (CORBA::Any &, IR_InterfaceDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_InterfaceDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_InterfaceDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_InterfaceDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_InterfaceDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_InterfaceDescription *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ValueMember &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ValueMember*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueMember *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ValueMember *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ValueMemberSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ValueMemberSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueMemberSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ValueMemberSeq *&); ++extern TAO_Export _TAO_ValueMemberDef_Proxy_Broker * (*_TAO_ValueMemberDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::ValueMemberDef +-TAO_Export void operator<<= (CORBA::Any &, IR::ValueMemberDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueMemberDef *&); +-extern TAO_Export IR::_TAO_ValueDef_Proxy_Broker * (*IR__TAO_ValueDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_ValueMemberDef ++TAO_Export void operator<<= (CORBA::Any &, IR_ValueMemberDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueMemberDef *&); ++extern TAO_Export _TAO_ValueDef_Proxy_Broker * (*_TAO_ValueDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::ValueDef +-TAO_Export void operator<<= (CORBA::Any &, IR::ValueDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ValueDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ValueDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ValueDescription *&); +-extern TAO_Export IR::_TAO_ValueBoxDef_Proxy_Broker * (*IR__TAO_ValueBoxDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_ValueDef ++TAO_Export void operator<<= (CORBA::Any &, IR_ValueDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ValueDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ValueDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ValueDescription *&); ++extern TAO_Export _TAO_ValueBoxDef_Proxy_Broker * (*_TAO_ValueBoxDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::ValueBoxDef +-TAO_Export void operator<<= (CORBA::Any &, IR::ValueBoxDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueBoxDef *&); +-extern TAO_Export IR::_TAO_ProvidesDef_Proxy_Broker * (*IR__TAO_ProvidesDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_ValueBoxDef ++TAO_Export void operator<<= (CORBA::Any &, IR_ValueBoxDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ValueBoxDef *&); ++extern TAO_Export _TAO_ProvidesDef_Proxy_Broker * (*_TAO_ProvidesDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::ProvidesDef +-TAO_Export void operator<<= (CORBA::Any &, IR::ProvidesDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ProvidesDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ProvidesDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ProvidesDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ProvidesDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ProvidesDescription *&); +-extern TAO_Export IR::_TAO_UsesDef_Proxy_Broker * (*IR__TAO_UsesDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_ProvidesDef ++TAO_Export void operator<<= (CORBA::Any &, IR_ProvidesDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ProvidesDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ProvidesDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ProvidesDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ProvidesDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ProvidesDescription *&); ++extern TAO_Export _TAO_UsesDef_Proxy_Broker * (*_TAO_UsesDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::UsesDef +-TAO_Export void operator<<= (CORBA::Any &, IR::UsesDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UsesDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::UsesDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::UsesDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UsesDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UsesDescription *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ProvidesDescSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ProvidesDescSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ProvidesDescSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ProvidesDescSeq *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::UsesDescSeq &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::UsesDescSeq*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UsesDescSeq *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UsesDescSeq *&); +-extern TAO_Export IR::_TAO_EventDef_Proxy_Broker * (*IR__TAO_EventDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_UsesDef ++TAO_Export void operator<<= (CORBA::Any &, IR_UsesDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UsesDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_UsesDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_UsesDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UsesDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_UsesDescription *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ProvidesDescSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ProvidesDescSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ProvidesDescSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ProvidesDescSeq *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_UsesDescSeq &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_UsesDescSeq*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_UsesDescSeq *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_UsesDescSeq *&); ++extern TAO_Export _TAO_EventDef_Proxy_Broker * (*_TAO_EventDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::EventDef +-TAO_Export void operator<<= (CORBA::Any &, IR::EventDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EventDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::EventDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::EventDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EventDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::EventDescription *&); +-extern TAO_Export IR::_TAO_EmitsDef_Proxy_Broker * (*IR__TAO_EmitsDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_EventDef ++TAO_Export void operator<<= (CORBA::Any &, IR_EventDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_EventDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_EventDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_EventDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_EventDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_EventDescription *&); ++extern TAO_Export _TAO_EmitsDef_Proxy_Broker * (*_TAO_EmitsDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::EmitsDef +-TAO_Export void operator<<= (CORBA::Any &, IR::EmitsDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EmitsDef *&); +-extern TAO_Export IR::_TAO_PublishesDef_Proxy_Broker * (*IR__TAO_PublishesDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_EmitsDef ++TAO_Export void operator<<= (CORBA::Any &, IR_EmitsDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_EmitsDef *&); ++extern TAO_Export _TAO_PublishesDef_Proxy_Broker * (*_TAO_PublishesDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::PublishesDef +-TAO_Export void operator<<= (CORBA::Any &, IR::PublishesDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PublishesDef *&); +-extern TAO_Export IR::_TAO_ConsumesDef_Proxy_Broker * (*IR__TAO_ConsumesDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_PublishesDef ++TAO_Export void operator<<= (CORBA::Any &, IR_PublishesDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_PublishesDef *&); ++extern TAO_Export _TAO_ConsumesDef_Proxy_Broker * (*_TAO_ConsumesDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::ConsumesDef +-TAO_Export void operator<<= (CORBA::Any &, IR::ConsumesDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ConsumesDef *&); +-extern TAO_Export IR::_TAO_ComponentDef_Proxy_Broker * (*IR__TAO_ComponentDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_ConsumesDef ++TAO_Export void operator<<= (CORBA::Any &, IR_ConsumesDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ConsumesDef *&); ++extern TAO_Export _TAO_ComponentDef_Proxy_Broker * (*_TAO_ComponentDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::ComponentDef +-TAO_Export void operator<<= (CORBA::Any &, IR::ComponentDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ComponentDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::ComponentDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::ComponentDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ComponentDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ComponentDescription *&); +-extern TAO_Export IR::_TAO_PrimaryKeyDef_Proxy_Broker * (*IR__TAO_PrimaryKeyDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_ComponentDef ++TAO_Export void operator<<= (CORBA::Any &, IR_ComponentDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ComponentDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_ComponentDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_ComponentDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_ComponentDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_ComponentDescription *&); ++extern TAO_Export _TAO_PrimaryKeyDef_Proxy_Broker * (*_TAO_PrimaryKeyDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::PrimaryKeyDef +-TAO_Export void operator<<= (CORBA::Any &, IR::PrimaryKeyDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PrimaryKeyDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::PrimaryKeyDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::PrimaryKeyDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PrimaryKeyDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::PrimaryKeyDescription *&); +-extern TAO_Export IR::_TAO_FactoryDef_Proxy_Broker * (*IR__TAO_FactoryDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_PrimaryKeyDef ++TAO_Export void operator<<= (CORBA::Any &, IR_PrimaryKeyDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_PrimaryKeyDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_PrimaryKeyDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_PrimaryKeyDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_PrimaryKeyDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_PrimaryKeyDescription *&); ++extern TAO_Export _TAO_FactoryDef_Proxy_Broker * (*_TAO_FactoryDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::FactoryDef +-TAO_Export void operator<<= (CORBA::Any &, IR::FactoryDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FactoryDef *&); +-extern TAO_Export IR::_TAO_FinderDef_Proxy_Broker * (*IR__TAO_FinderDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_FactoryDef ++TAO_Export void operator<<= (CORBA::Any &, IR_FactoryDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_FactoryDef *&); ++extern TAO_Export _TAO_FinderDef_Proxy_Broker * (*_TAO_FinderDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::FinderDef +-TAO_Export void operator<<= (CORBA::Any &, IR::FinderDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FinderDef *&); +-extern TAO_Export IR::_TAO_HomeDef_Proxy_Broker * (*IR__TAO_HomeDef_Proxy_Broker_Factory_function_pointer) ( ++// Any operators for interface IR_FinderDef ++TAO_Export void operator<<= (CORBA::Any &, IR_FinderDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_FinderDef *&); ++extern TAO_Export _TAO_HomeDef_Proxy_Broker * (*_TAO_HomeDef_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ); +-// Any operators for interface IR::HomeDef +-TAO_Export void operator<<= (CORBA::Any &, IR::HomeDef_ptr); +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::HomeDef *&); +-TAO_Export void operator<<= (CORBA::Any &, const IR::HomeDescription &); // copying version +-TAO_Export void operator<<= (CORBA::Any &, IR::HomeDescription*); // noncopying version +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::HomeDescription *&); // deprecated +-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::HomeDescription *&); ++// Any operators for interface IR_HomeDef ++TAO_Export void operator<<= (CORBA::Any &, IR_HomeDef_ptr); ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_HomeDef *&); ++TAO_Export void operator<<= (CORBA::Any &, const IR_HomeDescription &); // copying version ++TAO_Export void operator<<= (CORBA::Any &, IR_HomeDescription*); // noncopying version ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_HomeDescription *&); // deprecated ++TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR_HomeDescription *&); + + #ifndef __ACE_INLINE__ + +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::DefinitionKind &); // +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::DefinitionKind &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::IRObject_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::IRObject_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::Contained_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::Contained_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::Contained::Description &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::Contained::Description &); +- +-#if !defined _TAO_CDR_OP_IR_InterfaceDefSeq_H_ +-#define _TAO_CDR_OP_IR_InterfaceDefSeq_H_ ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_DefinitionKind &); // ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_DefinitionKind &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA_IRObject_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA_IRObject_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_Contained_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_Contained_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_Contained::Description &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_Contained::Description &); + + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::InterfaceDefSeq & ++ const IR_InterfaceDefSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::InterfaceDefSeq & ++ IR_InterfaceDefSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_InterfaceDefSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_ValueDefSeq_H_ +-#define _TAO_CDR_OP_IR_ValueDefSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::ValueDefSeq & ++ const IR_ValueDefSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::ValueDefSeq & ++ IR_ValueDefSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_ValueDefSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_ComponentDefSeq_H_ +-#define _TAO_CDR_OP_IR_ComponentDefSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::ComponentDefSeq & ++ const IR_ComponentDefSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::ComponentDefSeq & ++ IR_ComponentDefSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_ComponentDefSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_ProvidesDefSeq_H_ +-#define _TAO_CDR_OP_IR_ProvidesDefSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::ProvidesDefSeq & ++ const IR_ProvidesDefSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::ProvidesDefSeq & ++ IR_ProvidesDefSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_ProvidesDefSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_UsesDefSeq_H_ +-#define _TAO_CDR_OP_IR_UsesDefSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::UsesDefSeq & ++ const IR_UsesDefSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::UsesDefSeq & ++ IR_UsesDefSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_UsesDefSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_HomeDefSeq_H_ +-#define _TAO_CDR_OP_IR_HomeDefSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::HomeDefSeq & ++ const IR_HomeDefSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::HomeDefSeq & ++ IR_HomeDefSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_HomeDefSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_EmitsDefSeq_H_ +-#define _TAO_CDR_OP_IR_EmitsDefSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::EmitsDefSeq & ++ const IR_EmitsDefSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::EmitsDefSeq & ++ IR_EmitsDefSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_EmitsDefSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_PublishesDefSeq_H_ +-#define _TAO_CDR_OP_IR_PublishesDefSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::PublishesDefSeq & ++ const IR_PublishesDefSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::PublishesDefSeq & ++ IR_PublishesDefSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_PublishesDefSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_ConsumesDefSeq_H_ +-#define _TAO_CDR_OP_IR_ConsumesDefSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::ConsumesDefSeq & ++ const IR_ConsumesDefSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::ConsumesDefSeq & ++ IR_ConsumesDefSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_ConsumesDefSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_FactoryDefSeq_H_ +-#define _TAO_CDR_OP_IR_FactoryDefSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::FactoryDefSeq & ++ const IR_FactoryDefSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::FactoryDefSeq & ++ IR_FactoryDefSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_FactoryDefSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_FinderDefSeq_H_ +-#define _TAO_CDR_OP_IR_FinderDefSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::FinderDefSeq & ++ const IR_FinderDefSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::FinderDefSeq & ++ IR_FinderDefSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_FinderDefSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_ContainedSeq_H_ +-#define _TAO_CDR_OP_IR_ContainedSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::ContainedSeq & ++ const IR_ContainedSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::ContainedSeq & ++ IR_ContainedSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_ContainedSeq_H_ */ +- +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::StructMember &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::StructMember &); +- +-#if !defined _TAO_CDR_OP_IR_StructMemberSeq_H_ +-#define _TAO_CDR_OP_IR_StructMemberSeq_H_ ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_StructMember &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_StructMember &); + + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::StructMemberSeq & ++ const IR_StructMemberSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::StructMemberSeq & ++ IR_StructMemberSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_StructMemberSeq_H_ */ +- +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::Initializer &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::Initializer &); +- +-#if !defined _TAO_CDR_OP_IR_InitializerSeq_H_ +-#define _TAO_CDR_OP_IR_InitializerSeq_H_ ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_Initializer &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_Initializer &); + + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::InitializerSeq & ++ const IR_InitializerSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::InitializerSeq & ++ IR_InitializerSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_InitializerSeq_H_ */ +- +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::UnionMember &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::UnionMember &); +- +-#if !defined _TAO_CDR_OP_IR_UnionMemberSeq_H_ +-#define _TAO_CDR_OP_IR_UnionMemberSeq_H_ ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_UnionMember &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_UnionMember &); + + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::UnionMemberSeq & ++ const IR_UnionMemberSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::UnionMemberSeq & ++ IR_UnionMemberSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_UnionMemberSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_EnumMemberSeq_H_ +-#define _TAO_CDR_OP_IR_EnumMemberSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::EnumMemberSeq & ++ const IR_EnumMemberSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::EnumMemberSeq & ++ IR_EnumMemberSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_EnumMemberSeq_H_ */ +- +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::Container_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::Container_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::Container::Description &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::Container::Description &); +- +-#if !defined _TAO_CDR_OP_IR_Container_DescriptionSeq_H_ +-#define _TAO_CDR_OP_IR_Container_DescriptionSeq_H_ ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_Container_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_Container_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_Container::Description &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_Container::Description &); + + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::Container::DescriptionSeq & ++ const IR_Container::DescriptionSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::Container::DescriptionSeq & ++ IR_Container::DescriptionSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_Container_DescriptionSeq_H_ */ +- +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::IDLType_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::IDLType_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PrimitiveKind &); // +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PrimitiveKind &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::Repository_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::Repository_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ComponentRepository_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ComponentRepository_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ModuleDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ModuleDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ModuleDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ModuleDescription &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ConstantDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ConstantDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ConstantDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ConstantDescription &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::TypedefDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::TypedefDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::TypeDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::TypeDescription &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::StructDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::StructDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::UnionDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::UnionDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::EnumDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::EnumDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::AliasDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::AliasDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::NativeDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::NativeDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PrimitiveDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PrimitiveDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::StringDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::StringDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::WstringDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::WstringDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::FixedDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::FixedDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::SequenceDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::SequenceDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ArrayDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ArrayDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ExceptionDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ExceptionDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ExceptionDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ExceptionDescription &); +- +-#if !defined _TAO_CDR_OP_IR_ExceptionDefSeq_H_ +-#define _TAO_CDR_OP_IR_ExceptionDefSeq_H_ ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_IDLType_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_IDLType_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_PrimitiveKind &); // ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_PrimitiveKind &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_Repository_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_Repository_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ComponentRepository_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ComponentRepository_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ModuleDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ModuleDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ModuleDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ModuleDescription &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ConstantDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ConstantDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ConstantDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ConstantDescription &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_TypedefDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_TypedefDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_TypeDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_TypeDescription &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_StructDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_StructDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_UnionDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_UnionDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_EnumDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_EnumDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_AliasDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_AliasDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_NativeDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_NativeDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_PrimitiveDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_PrimitiveDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_StringDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_StringDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_WstringDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_WstringDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_FixedDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_FixedDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_SequenceDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_SequenceDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ArrayDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ArrayDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ExceptionDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ExceptionDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ExceptionDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ExceptionDescription &); + + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::ExceptionDefSeq & ++ const IR_ExceptionDefSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::ExceptionDefSeq & ++ IR_ExceptionDefSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_ExceptionDefSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_ExcDescriptionSeq_H_ +-#define _TAO_CDR_OP_IR_ExcDescriptionSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::ExcDescriptionSeq & ++ const IR_ExcDescriptionSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::ExcDescriptionSeq & ++ IR_ExcDescriptionSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_ExcDescriptionSeq_H_ */ +- +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::AttributeMode &); // ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_AttributeMode &); // + TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::AttributeMode &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::AttributeDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::AttributeDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::AttributeDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::AttributeDescription &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::OperationMode &); // ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_AttributeDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_AttributeDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_AttributeDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_AttributeDescription &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_OperationMode &); // + TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::OperationMode &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ParameterMode &); // ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ParameterMode &); // + TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ParameterMode &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ParameterDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ParameterDescription &); +- +-#if !defined _TAO_CDR_OP_IR_ParDescriptionSeq_H_ +-#define _TAO_CDR_OP_IR_ParDescriptionSeq_H_ ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ParameterDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ParameterDescription &); + + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::ParDescriptionSeq & ++ const IR_ParDescriptionSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::ParDescriptionSeq & ++ IR_ParDescriptionSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_ParDescriptionSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_ContextIdSeq_H_ +-#define _TAO_CDR_OP_IR_ContextIdSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::ContextIdSeq & ++ const IR_ContextIdSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::ContextIdSeq & ++ IR_ContextIdSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_ContextIdSeq_H_ */ +- +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::OperationDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::OperationDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::OperationDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::OperationDescription &); +- +-#if !defined _TAO_CDR_OP_IR_RepositoryIdSeq_H_ +-#define _TAO_CDR_OP_IR_RepositoryIdSeq_H_ ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_OperationDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_OperationDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_OperationDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_OperationDescription &); + + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::RepositoryIdSeq & ++ const IR_RepositoryIdSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::RepositoryIdSeq & ++ IR_RepositoryIdSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_RepositoryIdSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_OpDescriptionSeq_H_ +-#define _TAO_CDR_OP_IR_OpDescriptionSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::OpDescriptionSeq & ++ const IR_OpDescriptionSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::OpDescriptionSeq & ++ IR_OpDescriptionSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_OpDescriptionSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_AttrDescriptionSeq_H_ +-#define _TAO_CDR_OP_IR_AttrDescriptionSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::AttrDescriptionSeq & ++ const IR_AttrDescriptionSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::AttrDescriptionSeq & ++ IR_AttrDescriptionSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_AttrDescriptionSeq_H_ */ +- +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::InterfaceDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::InterfaceDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::InterfaceDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::InterfaceDescription &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ValueMember &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ValueMember &); +- +-#if !defined _TAO_CDR_OP_IR_ValueMemberSeq_H_ +-#define _TAO_CDR_OP_IR_ValueMemberSeq_H_ ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_InterfaceDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_InterfaceDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_InterfaceDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_InterfaceDescription &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ValueMember &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ValueMember &); + + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::ValueMemberSeq & ++ const IR_ValueMemberSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::ValueMemberSeq & ++ IR_ValueMemberSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_ValueMemberSeq_H_ */ +- +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ValueMemberDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ValueMemberDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ValueDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ValueDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ValueDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ValueDescription &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ValueBoxDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ValueBoxDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ProvidesDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ProvidesDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ProvidesDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ProvidesDescription &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::UsesDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::UsesDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::UsesDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::UsesDescription &); +- +-#if !defined _TAO_CDR_OP_IR_ProvidesDescSeq_H_ +-#define _TAO_CDR_OP_IR_ProvidesDescSeq_H_ ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ValueMemberDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ValueMemberDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ValueDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ValueDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ValueDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ValueDescription &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ValueBoxDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ValueBoxDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ProvidesDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ProvidesDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ProvidesDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ProvidesDescription &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_UsesDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_UsesDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_UsesDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_UsesDescription &); + + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::ProvidesDescSeq & ++ const IR_ProvidesDescSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::ProvidesDescSeq & ++ IR_ProvidesDescSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_ProvidesDescSeq_H_ */ +- +- +-#if !defined _TAO_CDR_OP_IR_UsesDescSeq_H_ +-#define _TAO_CDR_OP_IR_UsesDescSeq_H_ +- + TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, +- const IR::UsesDescSeq & ++ const IR_UsesDescSeq & + ); + TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, +- IR::UsesDescSeq & ++ IR_UsesDescSeq & + ); + +-#endif /* _TAO_CDR_OP_IR_UsesDescSeq_H_ */ +- +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::EventDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::EventDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::EventDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::EventDescription &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::EmitsDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::EmitsDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PublishesDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PublishesDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ConsumesDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ConsumesDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ComponentDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ComponentDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ComponentDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ComponentDescription &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PrimaryKeyDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PrimaryKeyDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PrimaryKeyDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PrimaryKeyDescription &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::FactoryDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::FactoryDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::FinderDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::FinderDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::HomeDef_ptr ); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::HomeDef_ptr &); +-TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::HomeDescription &); +-TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::HomeDescription &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_EventDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_EventDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_EventDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_EventDescription &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_EmitsDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_EmitsDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_PublishesDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_PublishesDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ConsumesDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ConsumesDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ComponentDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ComponentDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_ComponentDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_ComponentDescription &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_PrimaryKeyDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_PrimaryKeyDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_PrimaryKeyDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_PrimaryKeyDescription &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_FactoryDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_FactoryDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_FinderDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_FinderDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_HomeDef_ptr ); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_HomeDef_ptr &); ++TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR_HomeDescription &); ++TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR_HomeDescription &); + + #endif /* __ACE_INLINE__ */ + +@@ -30227,5 +18392,6 @@ + #pragma warning(pop) + #endif /* _MSC_VER */ + ++#endif /* TAO_HAS_INTERFACE_REPOSITORY == 1 */ + #include "ace/post.h" + #endif /* ifndef */ |